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 ok((lpData
[0]==0x77010203)&&(lpData
[1]==0x00010203)&&(lpData
[2]==0xCCCCCCCC)&&(lpData
[3]==0xCCCCCCCC),
291 "Destination data after blitting is not correct\n");
292 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
293 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
295 /* Also test SetColorKey */
296 IDirectDrawSurface_GetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
297 ok(DDColorKey
.dwColorSpaceLowValue
== 0xFF00FF && DDColorKey
.dwColorSpaceHighValue
== 0xFF00FF,
298 "GetColorKey does not return the colorkey used at surface creation\n");
300 DDColorKey
.dwColorSpaceLowValue
= 0x00FF00;
301 DDColorKey
.dwColorSpaceHighValue
= 0x00FF00;
302 IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
304 DDColorKey
.dwColorSpaceLowValue
= 0;
305 DDColorKey
.dwColorSpaceHighValue
= 0;
306 IDirectDrawSurface_GetColorKey(lpSrc
, DDCKEY_SRCBLT
, &DDColorKey
);
307 ok(DDColorKey
.dwColorSpaceLowValue
== 0x00FF00 && DDColorKey
.dwColorSpaceHighValue
== 0x00FF00,
308 "GetColorKey does not return the colorkey set with SetColorKey\n");
310 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0;
311 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0;
312 IDirectDrawSurface_GetSurfaceDesc(lpSrc
, &ddsd
);
313 ok(ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
== 0x00FF00 && ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
== 0x00FF00,
314 "GetSurfaceDesc does not return the colorkey set with SetColorKey\n");
316 IDirectDrawSurface_Release(lpSrc
);
317 IDirectDrawSurface_Release(lpDst
);
319 /* start with a new set of surfaces to test the color keying parameters to blit */
320 memset(&ddsd
, 0, sizeof(ddsd
));
321 ddsd
.dwSize
= sizeof(ddsd
);
322 ddsd
.ddpfPixelFormat
.dwSize
= sizeof(ddsd
.ddpfPixelFormat
);
323 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CKSRCBLT
| DDSD_CKDESTBLT
;
324 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
327 ddsd
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
328 U1(ddsd
.ddpfPixelFormat
).dwRGBBitCount
= 32;
329 U2(ddsd
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
330 U3(ddsd
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
331 U4(ddsd
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
332 ddsd
.ddckCKDestBlt
.dwColorSpaceLowValue
= 0xFF0000;
333 ddsd
.ddckCKDestBlt
.dwColorSpaceHighValue
= 0xFF0000;
334 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0x00FF00;
335 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0x00FF00;
336 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpDst
, NULL
);
337 ok(rc
==DD_OK
|| rc
== DDERR_NOCOLORKEYHW
,"CreateSurface returned: %x\n",rc
);
340 skip("Failed to create surface\n");
344 /* start with a new set of surfaces to test the color keying parameters to blit */
345 memset(&ddsd
, 0, sizeof(ddsd
));
346 ddsd
.dwSize
= sizeof(ddsd
);
347 ddsd
.ddpfPixelFormat
.dwSize
= sizeof(ddsd
.ddpfPixelFormat
);
348 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CKSRCBLT
| DDSD_CKDESTBLT
;
349 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
352 ddsd
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
353 U1(ddsd
.ddpfPixelFormat
).dwRGBBitCount
= 32;
354 U2(ddsd
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
355 U3(ddsd
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
356 U4(ddsd
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
357 ddsd
.ddckCKSrcBlt
.dwColorSpaceLowValue
= 0x0000FF;
358 ddsd
.ddckCKSrcBlt
.dwColorSpaceHighValue
= 0x0000FF;
359 ddsd
.ddckCKDestBlt
.dwColorSpaceLowValue
= 0x000000;
360 ddsd
.ddckCKDestBlt
.dwColorSpaceHighValue
= 0x000000;
361 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &lpSrc
, NULL
);
362 ok(rc
==DD_OK
|| rc
== DDERR_NOCOLORKEYHW
,"CreateSurface returned: %x\n",rc
);
365 skip("Failed to create surface\n");
366 IDirectDrawSurface_Release(lpDst
);
370 memset(&fx
, 0, sizeof(fx
));
371 fx
.dwSize
= sizeof(fx
);
372 fx
.ddckSrcColorkey
.dwColorSpaceHighValue
= 0x110000;
373 fx
.ddckSrcColorkey
.dwColorSpaceLowValue
= 0x110000;
374 fx
.ddckDestColorkey
.dwColorSpaceHighValue
= 0x001100;
375 fx
.ddckDestColorkey
.dwColorSpaceLowValue
= 0x001100;
377 rc
= IDirectDrawSurface_Lock(lpSrc
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
378 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
379 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
380 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
381 lpData
[0] = 0x000000FF; /* Applies to src blt key in src surface */
382 lpData
[1] = 0x00000000; /* Applies to dst blt key in src surface */
383 lpData
[2] = 0x00FF0000; /* Dst color key in dst surface */
384 lpData
[3] = 0x0000FF00; /* Src color key in dst surface */
385 lpData
[4] = 0x00001100; /* Src color key in ddbltfx */
386 lpData
[5] = 0x00110000; /* Dst color key in ddbltfx */
387 rc
= IDirectDrawSurface_Unlock(lpSrc
, NULL
);
388 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
390 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
391 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
392 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
393 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
394 lpData
[0] = 0x55555555;
395 lpData
[1] = 0x55555555;
396 lpData
[2] = 0x55555555;
397 lpData
[3] = 0x55555555;
398 lpData
[4] = 0x55555555;
399 lpData
[5] = 0x55555555;
400 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
401 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
403 /* Test a blit without keying */
404 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, 0, &fx
);
405 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
407 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
408 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
409 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
410 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
411 /* Should have copied src data unmodified to dst */
412 ok(lpData
[0] == 0x000000FF &&
413 lpData
[1] == 0x00000000 &&
414 lpData
[2] == 0x00FF0000 &&
415 lpData
[3] == 0x0000FF00 &&
416 lpData
[4] == 0x00001100 &&
417 lpData
[5] == 0x00110000, "Surface data after unkeyed blit does not match\n");
419 lpData
[0] = 0x55555555;
420 lpData
[1] = 0x55555555;
421 lpData
[2] = 0x55555555;
422 lpData
[3] = 0x55555555;
423 lpData
[4] = 0x55555555;
424 lpData
[5] = 0x55555555;
425 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
426 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
429 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
, &fx
);
430 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
432 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
433 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
434 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
435 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
437 ok(lpData
[0] == 0x55555555 && /* Here the src key applied */
438 lpData
[1] == 0x00000000 &&
439 lpData
[2] == 0x00FF0000 &&
440 lpData
[3] == 0x0000FF00 &&
441 lpData
[4] == 0x00001100 &&
442 lpData
[5] == 0x00110000, "Surface data after srckey blit does not match\n");
444 lpData
[0] = 0x55555555;
445 lpData
[1] = 0x55555555;
446 lpData
[2] = 0x55555555;
447 lpData
[3] = 0x55555555;
448 lpData
[4] = 0x55555555;
449 lpData
[5] = 0x55555555;
450 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
451 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
454 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, &fx
);
455 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
457 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
458 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
459 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
460 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
462 ok(lpData
[0] == 0x000000FF &&
463 lpData
[1] == 0x00000000 &&
464 lpData
[2] == 0x00FF0000 &&
465 lpData
[3] == 0x0000FF00 &&
466 lpData
[4] == 0x00001100 &&
467 lpData
[5] == 0x55555555, /* Override key applies here */
468 "Surface data after src override key blit does not match\n");
470 lpData
[0] = 0x55555555;
471 lpData
[1] = 0x55555555;
472 lpData
[2] = 0x55555555;
473 lpData
[3] = 0x55555555;
474 lpData
[4] = 0x55555555;
475 lpData
[5] = 0x55555555;
476 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
477 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
479 /* Src override AND src key. That is not supposed to work */
480 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
| DDBLT_KEYSRCOVERRIDE
, &fx
);
481 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
483 /* Verify that the destination is unchanged */
484 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
485 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
486 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
487 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
489 ok(lpData
[0] == 0x55555555 &&
490 lpData
[1] == 0x55555555 &&
491 lpData
[2] == 0x55555555 &&
492 lpData
[3] == 0x55555555 &&
493 lpData
[4] == 0x55555555 &&
494 lpData
[5] == 0x55555555, /* Override key applies here */
495 "Surface data after src key blit with override does not match\n");
497 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
498 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
499 lpData
[2] = 0x00001100; /* Dest key in override */
500 lpData
[3] = 0x00001100; /* Dest key in override */
501 lpData
[4] = 0x00000000; /* Dest key in src surface */
502 lpData
[5] = 0x00000000; /* Dest key in src surface */
503 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
504 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
507 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
, &fx
);
508 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
510 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
511 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
512 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
513 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
515 /* DirectDraw uses the dest blit key from the SOURCE surface ! */
516 ok(lpData
[0] == 0x00ff0000 &&
517 lpData
[1] == 0x00ff0000 &&
518 lpData
[2] == 0x00001100 &&
519 lpData
[3] == 0x00001100 &&
520 lpData
[4] == 0x00001100 && /* Key applies here */
521 lpData
[5] == 0x00110000, /* Key applies here */
522 "Surface data after dest key blit does not match\n");
524 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
525 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
526 lpData
[2] = 0x00001100; /* Dest key in override */
527 lpData
[3] = 0x00001100; /* Dest key in override */
528 lpData
[4] = 0x00000000; /* Dest key in src surface */
529 lpData
[5] = 0x00000000; /* Dest key in src surface */
530 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
531 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
533 /* Dest override key blit */
534 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, &fx
);
535 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
537 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
538 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
539 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
540 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
542 ok(lpData
[0] == 0x00FF0000 &&
543 lpData
[1] == 0x00FF0000 &&
544 lpData
[2] == 0x00FF0000 && /* Key applies here */
545 lpData
[3] == 0x0000FF00 && /* Key applies here */
546 lpData
[4] == 0x00000000 &&
547 lpData
[5] == 0x00000000,
548 "Surface data after dest key override blit does not match\n");
550 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
551 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
552 lpData
[2] = 0x00001100; /* Dest key in override */
553 lpData
[3] = 0x00001100; /* Dest key in override */
554 lpData
[4] = 0x00000000; /* Dest key in src surface */
555 lpData
[5] = 0x00000000; /* Dest key in src surface */
556 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
557 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
559 /* Dest override key blit. Supposed to fail too */
560 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
| DDBLT_KEYDESTOVERRIDE
, &fx
);
561 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
563 /* Check for unchanged data */
564 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
565 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
566 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
567 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
569 ok(lpData
[0] == 0x00FF0000 &&
570 lpData
[1] == 0x00FF0000 &&
571 lpData
[2] == 0x00001100 && /* Key applies here */
572 lpData
[3] == 0x00001100 && /* Key applies here */
573 lpData
[4] == 0x00000000 &&
574 lpData
[5] == 0x00000000,
575 "Surface data with dest key and dest override does not match\n");
577 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
578 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
579 lpData
[2] = 0x00001100; /* Dest key in override */
580 lpData
[3] = 0x00001100; /* Dest key in override */
581 lpData
[4] = 0x00000000; /* Dest key in src surface */
582 lpData
[5] = 0x00000000; /* Dest key in src surface */
583 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
584 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
586 /* Modify the source data a bit to give some more conclusive results */
587 rc
= IDirectDrawSurface_Lock(lpSrc
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
588 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
589 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
590 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
591 lpData
[5] = 0x000000FF; /* Applies to src blt key in src surface */
592 rc
= IDirectDrawSurface_Unlock(lpSrc
, NULL
);
593 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
595 /* Source and destination key */
596 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
| DDBLT_KEYSRC
, &fx
);
597 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
599 rc
= IDirectDrawSurface_Lock(lpDst
, NULL
, &ddsd2
, DDLOCK_WAIT
, NULL
);
600 ok(rc
==DD_OK
,"Lock returned: %x\n",rc
);
601 ok((ddsd2
.dwFlags
& DDSD_LPSURFACE
) == 0, "Surface desc has LPSURFACE Flags set\n");
602 lpData
= (LPDWORD
)ddsd2
.lpSurface
;
604 ok(lpData
[0] == 0x00FF0000 && /* Masked by Destination key */
605 lpData
[1] == 0x00FF0000 && /* Masked by Destination key */
606 lpData
[2] == 0x00001100 && /* Masked by Destination key */
607 lpData
[3] == 0x00001100 && /* Masked by Destination key */
608 lpData
[4] == 0x00001100 && /* Allowed by destination key, not masked by source key */
609 lpData
[5] == 0x00000000, /* Allowed by dst key, but masked by source key */
610 "Surface data with src key and dest key blit does not match\n");
612 lpData
[0] = 0x00FF0000; /* Dest key in dst surface */
613 lpData
[1] = 0x00FF0000; /* Dest key in dst surface */
614 lpData
[2] = 0x00001100; /* Dest key in override */
615 lpData
[3] = 0x00001100; /* Dest key in override */
616 lpData
[4] = 0x00000000; /* Dest key in src surface */
617 lpData
[5] = 0x00000000; /* Dest key in src surface */
618 rc
= IDirectDrawSurface_Unlock(lpDst
, NULL
);
619 ok(rc
==DD_OK
,"Unlock returned: %x\n",rc
);
621 /* Override keys without ddbltfx parameter fail */
622 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, NULL
);
623 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
624 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, NULL
);
625 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
627 /* Try blitting without keys in the source surface*/
628 rc
= IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_SRCBLT
, NULL
);
629 ok(rc
== DD_OK
, "SetColorKey returned %x\n", rc
);
630 rc
= IDirectDrawSurface_SetColorKey(lpSrc
, DDCKEY_DESTBLT
, NULL
);
631 ok(rc
== DD_OK
, "SetColorKey returned %x\n", rc
);
633 /* That fails now. Do not bother to check that the data is unmodified */
634 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRC
, &fx
);
635 ok(rc
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
637 /* Dest key blit still works. Which key is used this time??? */
638 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDEST
, &fx
);
639 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
641 /* With korrectly passed override keys no key in the surface is needed.
642 * Again, the result was checked before, no need to do that again
644 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYDESTOVERRIDE
, &fx
);
645 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
646 rc
= IDirectDrawSurface_Blt(lpDst
, NULL
, lpSrc
, NULL
, DDBLT_KEYSRCOVERRIDE
, &fx
);
647 ok(rc
== DD_OK
, "IDirectDrawSurface_Blt returned %08x\n", rc
);
649 IDirectDrawSurface_Release(lpSrc
);
650 IDirectDrawSurface_Release(lpDst
);
653 static void QueryInterface(void)
655 LPDIRECTDRAWSURFACE dsurface
;
656 DDSURFACEDESC surface
;
660 /* Create a surface */
661 ZeroMemory(&surface
, sizeof(surface
));
662 surface
.dwSize
= sizeof(surface
);
663 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
664 surface
.dwHeight
= 10;
665 surface
.dwWidth
= 10;
666 ret
= IDirectDraw_CreateSurface(lpDD
, &surface
, &dsurface
, NULL
);
669 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
673 /* Call IUnknown::QueryInterface */
674 ret
= IDirectDrawSurface_QueryInterface(dsurface
, 0, &object
);
675 ok(ret
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface::QueryInterface returned %x\n", ret
);
677 IDirectDrawSurface_Release(dsurface
);
680 /* The following tests test which interface is returned by IDirectDrawSurfaceX::GetDDInterface.
681 * It uses refcounts to test that and compares the interface addresses. Partially fits here, and
682 * partially in the refcount test
685 static unsigned long getref(IUnknown
*iface
)
687 IUnknown_AddRef(iface
);
688 return IUnknown_Release(iface
);
691 static void GetDDInterface_1(void)
693 LPDIRECTDRAWSURFACE dsurface
;
694 LPDIRECTDRAWSURFACE2 dsurface2
;
695 DDSURFACEDESC surface
;
700 unsigned long ref1
, ref2
, ref4
, ref7
;
703 /* Create a surface */
704 ZeroMemory(&surface
, sizeof(surface
));
705 surface
.dwSize
= sizeof(surface
);
706 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
707 surface
.dwHeight
= 10;
708 surface
.dwWidth
= 10;
709 ret
= IDirectDraw_CreateSurface(lpDD
, &surface
, &dsurface
, NULL
);
712 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
715 ret
= IDirectDrawSurface_QueryInterface(dsurface
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
716 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
717 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
718 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
719 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
720 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
721 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
722 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
724 ref1
= getref((IUnknown
*) lpDD
);
725 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
726 ref2
= getref((IUnknown
*) dd2
);
727 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
728 ref4
= getref((IUnknown
*) dd4
);
729 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
730 ref7
= getref((IUnknown
*) dd7
);
731 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
734 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
735 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
736 ok(getref((IUnknown
*) lpDD
) == ref1
+ 1, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
737 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
738 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
739 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
741 ok(dd
== lpDD
, "Returned interface pointer is not equal to the creation interface\n");
742 IUnknown_Release((IUnknown
*) dd
);
744 /* try a NULL pointer */
745 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, NULL
);
746 ok(ret
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
748 IDirectDraw_Release(dd2
);
749 IDirectDraw_Release(dd4
);
750 IDirectDraw_Release(dd7
);
751 IDirectDrawSurface2_Release(dsurface2
);
752 IDirectDrawSurface_Release(dsurface
);
755 static void GetDDInterface_2(void)
757 LPDIRECTDRAWSURFACE dsurface
;
758 LPDIRECTDRAWSURFACE2 dsurface2
;
759 DDSURFACEDESC surface
;
764 unsigned long ref1
, ref2
, ref4
, ref7
;
767 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
768 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
769 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
770 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
771 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
772 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
774 /* Create a surface */
775 ZeroMemory(&surface
, sizeof(surface
));
776 surface
.dwSize
= sizeof(surface
);
777 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
778 surface
.dwHeight
= 10;
779 surface
.dwWidth
= 10;
780 ret
= IDirectDraw2_CreateSurface(dd2
, &surface
, &dsurface
, NULL
);
783 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
786 ret
= IDirectDrawSurface_QueryInterface(dsurface
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
787 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
789 ref1
= getref((IUnknown
*) lpDD
);
790 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
791 ref2
= getref((IUnknown
*) dd2
);
792 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
793 ref4
= getref((IUnknown
*) dd4
);
794 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
795 ref7
= getref((IUnknown
*) dd7
);
796 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
799 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
800 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
801 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
802 ok(getref((IUnknown
*) dd2
) == ref2
+ 1, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
803 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
804 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
806 ok(dd
== dd2
, "Returned interface pointer is not equal to the creation interface\n");
807 IUnknown_Release((IUnknown
*) dd
);
809 IDirectDraw_Release(dd2
);
810 IDirectDraw_Release(dd4
);
811 IDirectDraw_Release(dd7
);
812 IDirectDrawSurface2_Release(dsurface2
);
813 IDirectDrawSurface_Release(dsurface
);
816 static void GetDDInterface_4(void)
818 LPDIRECTDRAWSURFACE2 dsurface2
;
819 LPDIRECTDRAWSURFACE4 dsurface4
;
820 DDSURFACEDESC2 surface
;
825 unsigned long ref1
, ref2
, ref4
, ref7
;
828 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
829 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
830 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
831 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
832 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
833 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
835 /* Create a surface */
836 ZeroMemory(&surface
, sizeof(surface
));
837 surface
.dwSize
= sizeof(surface
);
838 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
839 surface
.dwHeight
= 10;
840 surface
.dwWidth
= 10;
841 ret
= IDirectDraw4_CreateSurface(dd4
, &surface
, &dsurface4
, NULL
);
844 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
847 ret
= IDirectDrawSurface4_QueryInterface(dsurface4
, &IID_IDirectDrawSurface2
, (void **) &dsurface2
);
848 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
850 ref1
= getref((IUnknown
*) lpDD
);
851 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
852 ref2
= getref((IUnknown
*) dd2
);
853 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
854 ref4
= getref((IUnknown
*) dd4
);
855 ok(ref4
== 2, "IDirectDraw4 refcount is %ld\n", ref4
);
856 ref7
= getref((IUnknown
*) dd7
);
857 ok(ref7
== 1, "IDirectDraw7 refcount is %ld\n", ref7
);
859 ret
= IDirectDrawSurface4_GetDDInterface(dsurface4
, &dd
);
860 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
861 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
862 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
863 ok(getref((IUnknown
*) dd4
) == ref4
+ 1, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
864 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
866 ok(dd
== dd4
, "Returned interface pointer is not equal to the creation interface\n");
867 IUnknown_Release((IUnknown
*) dd
);
869 /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
870 ret
= IDirectDrawSurface2_GetDDInterface(dsurface2
, &dd
);
871 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
872 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
873 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
874 ok(getref((IUnknown
*) dd4
) == ref4
+ 1, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
875 ok(getref((IUnknown
*) dd7
) == ref7
+ 0, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
877 ok(dd
== dd4
, "Returned interface pointer is not equal to the creation interface\n");
878 IUnknown_Release((IUnknown
*) dd
);
880 IDirectDraw_Release(dd2
);
881 IDirectDraw_Release(dd4
);
882 IDirectDraw_Release(dd7
);
883 IDirectDrawSurface4_Release(dsurface4
);
884 IDirectDrawSurface2_Release(dsurface2
);
887 static void GetDDInterface_7(void)
889 LPDIRECTDRAWSURFACE4 dsurface4
;
890 LPDIRECTDRAWSURFACE7 dsurface7
;
891 DDSURFACEDESC2 surface
;
896 unsigned long ref1
, ref2
, ref4
, ref7
;
899 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw2
, (void **) &dd2
);
900 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
901 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw4
, (void **) &dd4
);
902 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
903 ret
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
904 ok(ret
== DD_OK
, "IDirectDraw7_QueryInterface returned %08x\n", ret
);
906 /* Create a surface */
907 ZeroMemory(&surface
, sizeof(surface
));
908 surface
.dwSize
= sizeof(surface
);
909 surface
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
;
910 surface
.dwHeight
= 10;
911 surface
.dwWidth
= 10;
912 ret
= IDirectDraw7_CreateSurface(dd7
, &surface
, &dsurface7
, NULL
);
915 ok(FALSE
, "IDirectDraw::CreateSurface failed with error %x\n", ret
);
918 ret
= IDirectDrawSurface7_QueryInterface(dsurface7
, &IID_IDirectDrawSurface4
, (void **) &dsurface4
);
919 ok(ret
== DD_OK
, "IDirectDrawSurface_QueryInterface returned %08x\n", ret
);
921 ref1
= getref((IUnknown
*) lpDD
);
922 ok(ref1
== 1, "IDirectDraw refcount is %ld\n", ref1
);
923 ref2
= getref((IUnknown
*) dd2
);
924 ok(ref2
== 1, "IDirectDraw2 refcount is %ld\n", ref2
);
925 ref4
= getref((IUnknown
*) dd4
);
926 ok(ref4
== 1, "IDirectDraw4 refcount is %ld\n", ref4
);
927 ref7
= getref((IUnknown
*) dd7
);
928 ok(ref7
== 2, "IDirectDraw7 refcount is %ld\n", ref7
);
930 ret
= IDirectDrawSurface7_GetDDInterface(dsurface7
, &dd
);
931 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
932 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
933 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
934 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
935 ok(getref((IUnknown
*) dd7
) == ref7
+ 1, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
937 ok(dd
== dd7
, "Returned interface pointer is not equal to the creation interface\n");
938 IUnknown_Release((IUnknown
*) dd
);
940 /* Now test what happens if we QI the surface for some other version - It should still return the creation interface */
941 ret
= IDirectDrawSurface4_GetDDInterface(dsurface4
, &dd
);
942 ok(ret
== DD_OK
, "IDirectDrawSurface7_GetDDInterface returned %08x\n", ret
);
943 ok(getref((IUnknown
*) lpDD
) == ref1
+ 0, "IDirectDraw refcount was increased by %ld\n", getref((IUnknown
*) lpDD
) - ref1
);
944 ok(getref((IUnknown
*) dd2
) == ref2
+ 0, "IDirectDraw2 refcount was increased by %ld\n", getref((IUnknown
*) dd2
) - ref2
);
945 ok(getref((IUnknown
*) dd4
) == ref4
+ 0, "IDirectDraw4 refcount was increased by %ld\n", getref((IUnknown
*) dd4
) - ref4
);
946 ok(getref((IUnknown
*) dd7
) == ref7
+ 1, "IDirectDraw7 refcount was increased by %ld\n", getref((IUnknown
*) dd7
) - ref7
);
948 ok(dd
== dd7
, "Returned interface pointer is not equal to the creation interface\n");
949 IUnknown_Release((IUnknown
*) dd
);
951 IDirectDraw_Release(dd2
);
952 IDirectDraw_Release(dd4
);
953 IDirectDraw_Release(dd7
);
954 IDirectDrawSurface4_Release(dsurface4
);
955 IDirectDrawSurface7_Release(dsurface7
);
958 #define MAXEXPECTED 8 /* Can match up to 8 expected surfaces */
961 IDirectDrawSurface
*expected
[MAXEXPECTED
];
965 static HRESULT WINAPI
enumCB(IDirectDrawSurface
*surf
, DDSURFACEDESC
*desc
, void *ctx
)
970 for(i
= 0; i
< MAXEXPECTED
; i
++)
972 if(((struct enumstruct
*)ctx
)->expected
[i
] == surf
) found
= TRUE
;
975 ok(found
, "Unexpected surface %p enumerated\n", surf
);
976 ((struct enumstruct
*)ctx
)->count
++;
977 IDirectDrawSurface_Release(surf
);
981 static void EnumTest(void)
985 IDirectDrawSurface
*surface
;
986 struct enumstruct ctx
;
988 ddsd
.dwSize
= sizeof(ddsd
);
989 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
990 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
991 U2(ddsd
).dwMipMapCount
= 3;
994 rc
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface
, NULL
);
995 ok(rc
==DD_OK
,"CreateSurface returned: %x\n",rc
);
997 memset(&ctx
, 0, sizeof(ctx
));
998 ctx
.expected
[0] = surface
;
999 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[0], &ddsd
.ddsCaps
, &ctx
.expected
[1]);
1000 ok(rc
== DD_OK
, "GetAttachedSurface returned %08x\n", rc
);
1001 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[1], &ddsd
.ddsCaps
, &ctx
.expected
[2]);
1002 ok(rc
== DD_OK
, "GetAttachedSurface returned %08x\n", rc
);
1003 rc
= IDirectDrawSurface_GetAttachedSurface(ctx
.expected
[2], &ddsd
.ddsCaps
, &ctx
.expected
[3]);
1004 ok(rc
== DDERR_NOTFOUND
, "GetAttachedSurface returned %08x\n", rc
);
1007 rc
= IDirectDraw_EnumSurfaces(lpDD
, DDENUMSURFACES_DOESEXIST
| DDENUMSURFACES_ALL
, &ddsd
, (void *) &ctx
, enumCB
);
1008 ok(rc
== DD_OK
, "IDirectDraw_EnumSurfaces returned %08x\n", rc
);
1009 ok(ctx
.count
== 3, "%d surfaces enumerated, expected 3\n", ctx
.count
);
1011 IDirectDrawSurface_Release(ctx
.expected
[2]);
1012 IDirectDrawSurface_Release(ctx
.expected
[1]);
1013 IDirectDrawSurface_Release(surface
);
1016 HRESULT WINAPI
SurfaceCounter(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1018 UINT
*num
= context
;
1020 IDirectDrawSurface_Release(surface
);
1021 return DDENUMRET_OK
;
1024 static void AttachmentTest7(void)
1028 IDirectDrawSurface7
*surface1
, *surface2
, *surface3
, *surface4
;
1029 DDSURFACEDESC2 ddsd
;
1031 DDSCAPS2 caps
= {DDSCAPS_TEXTURE
, 0, 0, 0};
1032 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
1034 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1035 ok(hr
== DD_OK
, "IDirectDraw_QueryInterface returned %08x\n", hr
);
1037 memset(&ddsd
, 0, sizeof(ddsd
));
1038 ddsd
.dwSize
= sizeof(ddsd
);
1039 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
1040 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
1041 U2(ddsd
).dwMipMapCount
= 3; /* Will create 128x128, 64x64, 32x32 */
1043 ddsd
.dwHeight
= 128;
1044 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1045 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1049 IDirectDrawSurface7_EnumAttachedSurfaces(surface1
, &num
, SurfaceCounter
);
1050 ok(num
== 1, "Mipmap root has %d surfaces attached, expected 1\n", num
);
1054 hr
= IDirectDrawSurface7_GetAttachedSurface(surface1
, &caps
, &surface2
);
1055 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1057 IDirectDrawSurface7_EnumAttachedSurfaces(surface2
, &num
, SurfaceCounter
);
1058 ok(num
== 1, "First mip level has %d surfaces attached, expected 1\n", num
);
1062 hr
= IDirectDrawSurface7_GetAttachedSurface(surface2
, &caps
, &surface3
);
1063 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1064 IDirectDrawSurface7_Release(surface2
);
1066 IDirectDrawSurface7_EnumAttachedSurfaces(surface3
, &num
, SurfaceCounter
);
1067 ok(num
== 0, "Second mip level has %d surfaces attached, expected 1\n", num
);
1069 /* Mip level 3 is still needed */
1071 /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1072 memset(&ddsd
, 0, sizeof(ddsd
));
1073 ddsd
.dwSize
= sizeof(ddsd
);
1074 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1075 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1078 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1079 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1081 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1082 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr
);
1083 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1084 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr
);
1085 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface2
);
1086 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr
);
1087 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1088 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr
);
1090 IDirectDrawSurface7_Release(surface2
);
1092 memset(&ddsd
, 0, sizeof(ddsd
));
1093 ddsd
.dwSize
= sizeof(ddsd
);
1094 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1095 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_SYSTEMMEMORY
| DDSCAPS_OFFSCREENPLAIN
;
1098 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1099 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1101 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1102 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr
);
1103 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1104 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr
);
1105 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface2
);
1106 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr
);
1107 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1108 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr
);
1110 IDirectDrawSurface7_Release(surface3
);
1111 IDirectDrawSurface7_Release(surface2
);
1112 IDirectDrawSurface7_Release(surface1
);
1114 hr
= IDirectDraw7_SetCooperativeLevel(dd7
, window
, DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN
);
1115 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1117 memset(&ddsd
, 0, sizeof(ddsd
));
1118 ddsd
.dwSize
= sizeof(ddsd
);
1119 ddsd
.dwFlags
= DDSD_BACKBUFFERCOUNT
| DDSD_CAPS
;
1120 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_COMPLEX
| DDSCAPS_FLIP
;
1121 ddsd
.dwBackBufferCount
= 2;
1122 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1123 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1126 IDirectDrawSurface7_EnumAttachedSurfaces(surface1
, &num
, SurfaceCounter
);
1127 ok(num
== 1, "Primary surface has %d surfaces attached, expected 1\n", num
);
1128 IDirectDrawSurface7_Release(surface1
);
1130 /* Those are some invalid descriptions, no need to test attachments with them */
1131 memset(&ddsd
, 0, sizeof(ddsd
));
1132 ddsd
.dwSize
= sizeof(ddsd
);
1133 ddsd
.dwFlags
= DDSD_CAPS
;
1134 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_FRONTBUFFER
;
1135 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1136 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1137 memset(&ddsd
, 0, sizeof(ddsd
));
1138 ddsd
.dwSize
= sizeof(ddsd
);
1139 ddsd
.dwFlags
= DDSD_CAPS
;
1140 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_BACKBUFFER
;
1141 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1142 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1144 /* Try a single primary and two offscreen plain surfaces */
1145 memset(&ddsd
, 0, sizeof(ddsd
));
1146 ddsd
.dwSize
= sizeof(ddsd
);
1147 ddsd
.dwFlags
= DDSD_CAPS
;
1148 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
1149 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface1
, NULL
);
1150 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1152 memset(&ddsd
, 0, sizeof(ddsd
));
1153 ddsd
.dwSize
= sizeof(ddsd
);
1154 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1155 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1156 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1157 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1158 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface2
, NULL
);
1159 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1161 memset(&ddsd
, 0, sizeof(ddsd
));
1162 ddsd
.dwSize
= sizeof(ddsd
);
1163 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1164 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1165 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1166 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1167 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface3
, NULL
);
1168 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1170 /* This one has a different size */
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
;
1176 ddsd
.dwHeight
= 128;
1177 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface4
, NULL
);
1178 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1180 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface2
);
1181 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr
);
1182 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface1
);
1183 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr
);
1184 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface3
);
1185 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr
);
1186 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
);
1187 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr
);
1188 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
);
1189 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr
);
1191 IDirectDrawSurface7_Release(surface4
);
1192 IDirectDrawSurface7_Release(surface3
);
1193 IDirectDrawSurface7_Release(surface2
);
1194 IDirectDrawSurface7_Release(surface1
);
1196 hr
=IDirectDraw7_SetCooperativeLevel(dd7
, NULL
, DDSCL_NORMAL
);
1197 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1198 IDirectDraw7_Release(dd7
);
1201 static void AttachmentTest(void)
1204 IDirectDrawSurface
*surface1
, *surface2
, *surface3
, *surface4
;
1206 DDSCAPS caps
= {DDSCAPS_TEXTURE
};
1207 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
1209 memset(&ddsd
, 0, sizeof(ddsd
));
1210 ddsd
.dwSize
= sizeof(ddsd
);
1211 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_MIPMAPCOUNT
;
1212 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
;
1213 U2(ddsd
).dwMipMapCount
= 3; /* Will create 128x128, 64x64, 32x32 */
1215 ddsd
.dwHeight
= 128;
1216 hr
= IDirectDraw7_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1217 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1219 hr
= IDirectDrawSurface7_GetAttachedSurface(surface1
, &caps
, &surface2
);
1220 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1221 hr
= IDirectDrawSurface7_GetAttachedSurface(surface2
, &caps
, &surface3
);
1222 ok(hr
== DD_OK
, "GetAttachedSurface returned %08x\n", hr
);
1224 /* Try to attach a 16x16 miplevel - Should not work as far I can see */
1225 memset(&ddsd
, 0, sizeof(ddsd
));
1226 ddsd
.dwSize
= sizeof(ddsd
);
1227 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1228 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1231 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1232 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1234 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
);
1235 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 128x128 texture root returned %08x\n", hr
);
1236 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
);
1237 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 texture returned %08x\n", hr
);
1238 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface4
);
1239 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 32x32 texture mip level returned %08x\n", hr
);
1240 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface3
);
1241 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 surface returned %08x\n", hr
);
1242 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface4
);
1243 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 surface to a 64x64 texture sublevel returned %08x\n", hr
);
1244 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface2
);
1245 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 64x64 texture sublevel to a 16x16 texture returned %08x\n", hr
);
1247 IDirectDrawSurface7_Release(surface4
);
1249 memset(&ddsd
, 0, sizeof(ddsd
));
1250 ddsd
.dwSize
= sizeof(ddsd
);
1251 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1252 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_SYSTEMMEMORY
| DDSCAPS_OFFSCREENPLAIN
;
1255 hr
= IDirectDraw7_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1256 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1258 hr
= IDirectDrawSurface7_AddAttachedSurface(surface1
, surface4
); /* Succeeds on refrast */
1259 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 128x128 texture root returned %08x\n", hr
);
1260 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface1
, 0, surface4
);
1261 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface1
); /* Succeeds on refrast */
1262 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 128x128 texture root to a 16x16 offscreen plain surface returned %08x\n", hr
);
1263 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface1
, 0, surface1
);
1264 hr
= IDirectDrawSurface7_AddAttachedSurface(surface3
, surface4
); /* Succeeds on refrast */
1265 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 32x32 texture mip level returned %08x\n", hr
);
1266 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface3
, 0, surface4
);
1267 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface3
);
1268 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 32x32 texture mip level to a 16x16 offscreen plain surface returned %08x\n", hr
);
1269 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface4
, 0, surface3
);
1270 hr
= IDirectDrawSurface7_AddAttachedSurface(surface2
, surface4
); /* Succeeds on refrast */
1271 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 16x16 offscreen plain surface to a 64x64 texture sublevel returned %08x\n", hr
);
1272 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface2
, 0, surface4
);
1273 hr
= IDirectDrawSurface7_AddAttachedSurface(surface4
, surface2
);
1274 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a 64x64 texture sublevel to a 16x16 offscreen plain surface returned %08x\n", hr
);
1275 if(SUCCEEDED(hr
)) IDirectDrawSurface7_DeleteAttachedSurface(surface4
, 0, surface2
);
1277 IDirectDrawSurface7_Release(surface4
);
1278 IDirectDrawSurface7_Release(surface3
);
1279 IDirectDrawSurface7_Release(surface2
);
1280 IDirectDrawSurface7_Release(surface1
);
1282 hr
= IDirectDraw_SetCooperativeLevel(lpDD
, window
, DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN
);
1283 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1285 /* Creating a back buffer as-is, is not allowed. No need to perform attachment tests */
1286 memset(&ddsd
, 0, sizeof(ddsd
));
1287 ddsd
.dwSize
= sizeof(ddsd
);
1288 ddsd
.dwFlags
= DDSD_CAPS
;
1289 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_BACKBUFFER
;
1290 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface2
, NULL
);
1291 ok(hr
==DDERR_INVALIDCAPS
,"CreateSurface returned: %x\n",hr
);
1292 /* This old ddraw version happily creates explicit front buffers */
1293 memset(&ddsd
, 0, sizeof(ddsd
));
1294 ddsd
.dwSize
= sizeof(ddsd
);
1295 ddsd
.dwFlags
= DDSD_CAPS
;
1296 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
| DDSCAPS_FRONTBUFFER
;
1297 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1298 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1299 IDirectDrawSurface_Release(surface1
);
1301 /* Try a single primary and two offscreen plain surfaces */
1302 memset(&ddsd
, 0, sizeof(ddsd
));
1303 ddsd
.dwSize
= sizeof(ddsd
);
1304 ddsd
.dwFlags
= DDSD_CAPS
;
1305 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_PRIMARYSURFACE
;
1306 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface1
, NULL
);
1307 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1309 memset(&ddsd
, 0, sizeof(ddsd
));
1310 ddsd
.dwSize
= sizeof(ddsd
);
1311 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1312 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1313 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1314 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1315 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface2
, NULL
);
1316 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1318 memset(&ddsd
, 0, sizeof(ddsd
));
1319 ddsd
.dwSize
= sizeof(ddsd
);
1320 ddsd
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
;
1321 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_OFFSCREENPLAIN
;
1322 ddsd
.dwWidth
= GetSystemMetrics(SM_CXSCREEN
);
1323 ddsd
.dwHeight
= GetSystemMetrics(SM_CYSCREEN
);
1324 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface3
, NULL
);
1325 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1327 /* This one has a different size */
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
;
1333 ddsd
.dwHeight
= 128;
1334 hr
= IDirectDraw_CreateSurface(lpDD
, &ddsd
, &surface4
, NULL
);
1335 ok(hr
==DD_OK
,"CreateSurface returned: %x\n",hr
);
1337 hr
= IDirectDrawSurface_AddAttachedSurface(surface1
, surface2
);
1338 ok(hr
== DD_OK
, "Attaching an offscreen plain surface to a front buffer returned %08x\n", hr
);
1339 /* Try the reverse without detaching first */
1340 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface1
);
1341 ok(hr
== DDERR_SURFACEALREADYATTACHED
, "Attaching an attached surface to its attachee returned %08x\n", hr
);
1342 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface1
, 0, surface2
);
1343 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1344 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface1
);
1345 ok(hr
== DD_OK
, "Attaching a front buffer to an offscreen plain surface returned %08x\n", hr
);
1346 /* Try to detach reversed */
1347 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface1
, 0, surface2
);
1348 ok(hr
== DDERR_CANNOTDETACHSURFACE
, "DeleteAttachedSurface returned %08x\n", hr
);
1349 /* Now the proper detach */
1350 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface2
, 0, surface1
);
1351 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1352 hr
= IDirectDrawSurface_AddAttachedSurface(surface2
, surface3
); /* Fails on refrast */
1353 ok(hr
== DD_OK
, "Attaching an offscreen plain surface to another offscreen plain surface returned %08x\n", hr
);
1356 hr
= IDirectDrawSurface_DeleteAttachedSurface(surface2
, 0, surface3
);
1357 ok(hr
== DD_OK
, "DeleteAttachedSurface failed with %08x\n", hr
);
1359 hr
= IDirectDrawSurface_AddAttachedSurface(surface1
, surface4
);
1360 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching an offscreen plain surface to a front buffer of different size returned %08x\n", hr
);
1361 hr
= IDirectDrawSurface_AddAttachedSurface(surface4
, surface1
);
1362 ok(hr
== DDERR_CANNOTATTACHSURFACE
, "Attaching a front buffer to an offscreen plain surface of different size returned %08x\n", hr
);
1364 IDirectDrawSurface_Release(surface4
);
1365 IDirectDrawSurface_Release(surface3
);
1366 IDirectDrawSurface_Release(surface2
);
1367 IDirectDrawSurface_Release(surface1
);
1369 hr
=IDirectDraw_SetCooperativeLevel(lpDD
, NULL
, DDSCL_NORMAL
);
1370 ok(hr
== DD_OK
, "SetCooperativeLevel returned %08x\n", hr
);
1372 DestroyWindow(window
);
1377 DWORD width
, height
;
1382 HRESULT WINAPI
CubeTestLvl2Enum(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1384 UINT
*mips
= context
;
1387 IDirectDrawSurface7_EnumAttachedSurfaces(surface
,
1391 return DDENUMRET_OK
;
1394 HRESULT WINAPI
CubeTestLvl1Enum(IDirectDrawSurface7
*surface
, DDSURFACEDESC2
*desc
, void *context
)
1397 UINT
*num
= (UINT
*) context
;
1398 static const struct compare expected
[] =
1402 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1403 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEZ
,
1408 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1409 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEZ
,
1414 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1415 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEY
,
1420 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1421 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEY
,
1426 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1427 DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_NEGATIVEX
,
1431 64, 64, /* This is the first mipmap */
1432 DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
,
1433 DDSCAPS2_MIPMAPSUBLEVEL
| DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_POSITIVEX
,
1439 IDirectDrawSurface7_EnumAttachedSurfaces(surface
,
1443 ok(desc
->dwWidth
== expected
[*num
].width
, "Surface width is %d expected %d\n", desc
->dwWidth
, expected
[*num
].width
);
1444 ok(desc
->dwHeight
== expected
[*num
].height
, "Surface height is %d expected %d\n", desc
->dwHeight
, expected
[*num
].height
);
1445 ok(desc
->ddsCaps
.dwCaps
== expected
[*num
].caps
, "Surface caps are %08x expected %08x\n", desc
->ddsCaps
.dwCaps
, expected
[*num
].caps
);
1446 ok(desc
->ddsCaps
.dwCaps2
== expected
[*num
].caps2
, "Surface caps2 are %08x expected %08x\n", desc
->ddsCaps
.dwCaps2
, expected
[*num
].caps2
);
1447 ok(mips
== expected
[*num
].mips
, "Surface has %d mipmaps, expected %d\n", mips
, expected
[*num
].mips
);
1451 IDirectDrawSurface7_Release(surface
);
1453 return DDENUMRET_OK
;
1456 static void CubeMapTest(void)
1458 IDirectDraw7
*dd7
= NULL
;
1459 IDirectDrawSurface7
*cubemap
;
1460 DDSURFACEDESC2 ddsd
;
1463 struct enumstruct ctx
;
1465 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1466 ok(hr
== DD_OK
, "IDirectDraw::QueryInterface returned %08x\n", hr
);
1468 memset(&ddsd
, 0, sizeof(ddsd
));
1469 ddsd
.dwSize
= sizeof(ddsd
);
1470 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1471 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1473 ddsd
.dwHeight
= 128;
1474 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1475 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP
| DDSCAPS2_CUBEMAP_ALLFACES
;
1478 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1479 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1480 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1481 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1482 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1484 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1485 ok(hr
== DD_OK
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1487 hr
= IDirectDrawSurface7_GetSurfaceDesc(cubemap
, &ddsd
);
1488 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetSurfaceDesc returned %08x\n", hr
);
1489 ok(ddsd
.ddsCaps
.dwCaps
== (DDSCAPS_MIPMAP
| DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
| DDSCAPS_COMPLEX
),
1490 "Root Caps are %08x\n", ddsd
.ddsCaps
.dwCaps
);
1491 ok(ddsd
.ddsCaps
.dwCaps2
== (DDSCAPS2_CUBEMAP_POSITIVEX
| DDSCAPS2_CUBEMAP
),
1492 "Root Caps2 are %08x\n", ddsd
.ddsCaps
.dwCaps2
);
1494 IDirectDrawSurface7_EnumAttachedSurfaces(cubemap
,
1497 trace("Enumerated %d surfaces in total\n", num
);
1498 ok(num
== 6, "Surface has %d attachments\n", num
);
1499 IDirectDrawSurface7_Release(cubemap
);
1501 /* What happens if I do not specify any faces? */
1502 memset(&ddsd
, 0, sizeof(ddsd
));
1503 ddsd
.dwSize
= sizeof(ddsd
);
1504 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1505 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1507 ddsd
.dwHeight
= 128;
1508 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1509 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP
;
1512 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1513 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1514 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1515 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1516 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1518 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1519 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDraw7::CreateSurface asking for a cube map without faces returned %08x\n", hr
);
1521 /* Cube map faces without a cube map? */
1522 memset(&ddsd
, 0, sizeof(ddsd
));
1523 ddsd
.dwSize
= sizeof(ddsd
);
1524 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1525 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1527 ddsd
.dwHeight
= 128;
1528 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1529 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP_ALLFACES
;
1532 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1533 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1534 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1535 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1536 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1538 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1539 ok(hr
== DDERR_INVALIDCAPS
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1541 memset(&ddsd
, 0, sizeof(ddsd
));
1542 ddsd
.dwSize
= sizeof(ddsd
);
1543 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1544 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1546 ddsd
.dwHeight
= 128;
1547 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_COMPLEX
| DDSCAPS_MIPMAP
| DDSCAPS_SYSTEMMEMORY
;
1548 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_CUBEMAP_POSITIVEX
;
1551 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1552 U1(U4(ddsd
).ddpfPixelFormat
).dwRGBBitCount
= 16;
1553 U2(U4(ddsd
).ddpfPixelFormat
).dwRBitMask
= 0xF800;
1554 U3(U4(ddsd
).ddpfPixelFormat
).dwGBitMask
= 0x07E0;
1555 U4(U4(ddsd
).ddpfPixelFormat
).dwBBitMask
= 0x001F;
1557 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &cubemap
, NULL
);
1558 ok(hr
== DDERR_INVALIDCAPS
, "IDirectDraw7::CreateSurface returned %08x\n", hr
);
1560 /* Make sure everything is cleaned up properly. Use the enumSurfaces test infrastructure */
1561 memset(&ctx
, 0, sizeof(ctx
));
1562 memset(&ddsd
, 0, sizeof(ddsd
));
1563 ddsd
.dwSize
= sizeof(DDSURFACEDESC
);
1564 hr
= IDirectDraw_EnumSurfaces(lpDD
, DDENUMSURFACES_DOESEXIST
| DDENUMSURFACES_ALL
, (DDSURFACEDESC
*) &ddsd
, (void *) &ctx
, enumCB
);
1565 ok(hr
== DD_OK
, "IDirectDraw_EnumSurfaces returned %08x\n", hr
);
1566 ok(ctx
.count
== 0, "%d surfaces enumerated, expected 0\n", ctx
.count
);
1568 IDirectDraw7_Release(dd7
);
1571 static void test_lockrect_invalid(void)
1584 {68, 60, 60, 68}, /* left > right */
1585 {60, 68, 68, 60}, /* top > bottom */
1586 {-8, 60, 0, 68}, /* left < surface */
1587 {60, -8, 68, 0}, /* top < surface */
1588 {-16, 60, -8, 68}, /* right < surface */
1589 {60, -16, 68, -8}, /* bottom < surface */
1590 {60, 60, 136, 68}, /* right > surface */
1591 {60, 60, 68, 136}, /* bottom > surface */
1592 {136, 60, 144, 68}, /* left > surface */
1593 {60, 136, 68, 144}, /* top > surface */
1596 const DWORD dds_caps
[] = {
1597 DDSCAPS_OFFSCREENPLAIN
1600 for (j
= 0; j
< (sizeof(dds_caps
) / sizeof(*dds_caps
)); ++j
)
1602 IDirectDrawSurface
*surface
= 0;
1603 DDSURFACEDESC surface_desc
= {0};
1604 DDSURFACEDESC locked_desc
= {0};
1607 surface_desc
.dwSize
= sizeof(surface_desc
);
1608 surface_desc
.ddpfPixelFormat
.dwSize
= sizeof(surface_desc
.ddpfPixelFormat
);
1609 surface_desc
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
;
1610 surface_desc
.ddsCaps
.dwCaps
= dds_caps
[j
];
1611 surface_desc
.dwWidth
= 128;
1612 surface_desc
.dwHeight
= 128;
1613 surface_desc
.ddpfPixelFormat
.dwFlags
= DDPF_RGB
;
1614 U1(surface_desc
.ddpfPixelFormat
).dwRGBBitCount
= 32;
1615 U2(surface_desc
.ddpfPixelFormat
).dwRBitMask
= 0xFF0000;
1616 U3(surface_desc
.ddpfPixelFormat
).dwGBitMask
= 0x00FF00;
1617 U4(surface_desc
.ddpfPixelFormat
).dwBBitMask
= 0x0000FF;
1619 hr
= IDirectDraw_CreateSurface(lpDD
, &surface_desc
, &surface
, NULL
);
1620 ok(SUCCEEDED(hr
), "CreateSurface failed (0x%08x)\n", hr
);
1622 skip("failed to create surface\n");
1626 for (i
= 0; i
< (sizeof(valid
) / sizeof(*valid
)); ++i
)
1628 RECT
*rect
= &valid
[i
];
1630 memset(&locked_desc
, 0, sizeof(locked_desc
));
1631 locked_desc
.dwSize
= sizeof(locked_desc
);
1633 hr
= IDirectDrawSurface_Lock(surface
, rect
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1634 ok(SUCCEEDED(hr
), "Lock failed (0x%08x) for rect [%d, %d]->[%d, %d]\n",
1635 hr
, rect
->left
, rect
->top
, rect
->right
, rect
->bottom
);
1637 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1638 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1641 for (i
= 0; i
< (sizeof(invalid
) / sizeof(*invalid
)); ++i
)
1643 RECT
*rect
= &invalid
[i
];
1645 hr
= IDirectDrawSurface_Lock(surface
, rect
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1646 ok(hr
== DDERR_INVALIDPARAMS
, "Lock returned 0x%08x for rect [%d, %d]->[%d, %d]"
1647 ", expected DDERR_INVALIDPARAMS (0x%08x)\n", hr
, rect
->left
, rect
->top
,
1648 rect
->right
, rect
->bottom
, DDERR_INVALIDPARAMS
);
1651 hr
= IDirectDrawSurface_Lock(surface
, NULL
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1652 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock(rect = NULL) failed (0x%08x)\n", hr
);
1653 hr
= IDirectDrawSurface_Lock(surface
, NULL
, &locked_desc
, DDLOCK_WAIT
, NULL
);
1654 ok(hr
== DDERR_SURFACEBUSY
, "Double lock(rect = NULL) returned 0x%08x\n", hr
);
1656 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1657 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1659 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1660 ok(SUCCEEDED(hr
), "Unlock failed (0x%08x)\n", hr
);
1662 memset(&locked_desc
, 0, sizeof(locked_desc
));
1663 locked_desc
.dwSize
= sizeof(locked_desc
);
1664 hr
= IDirectDrawSurface_Lock(surface
, &valid
[0], &locked_desc
, DDLOCK_WAIT
, NULL
);
1665 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1666 valid
[0].left
, valid
[0].top
, valid
[0].right
, valid
[0].bottom
, hr
);
1667 hr
= IDirectDrawSurface_Lock(surface
, &valid
[0], &locked_desc
, DDLOCK_WAIT
, NULL
);
1668 ok(hr
== DDERR_SURFACEBUSY
, "Double lock(rect = [%d, %d]->[%d, %d]) failed (0x%08x)\n",
1669 valid
[0].left
, valid
[0].top
, valid
[0].right
, valid
[0].bottom
, hr
);
1671 /* Locking a different rectangle returns DD_OK, but it seems to break the surface.
1672 * Afterwards unlocking the surface fails(NULL rectangle, and both locked rectangles
1675 hr
= IDirectDrawSurface_Unlock(surface
, NULL
);
1676 ok(hr
== DD_OK
, "Unlock returned (0x%08x)\n", hr
);
1678 IDirectDrawSurface_Release(surface
);
1682 static void CompressedTest(void)
1685 IDirectDrawSurface7
*surface
;
1686 DDSURFACEDESC2 ddsd
, ddsd2
;
1687 IDirectDraw7
*dd7
= NULL
;
1688 RECT r
= { 0, 0, 128, 128 };
1689 RECT r2
= { 32, 32, 64, 64 };
1691 hr
= IDirectDraw_QueryInterface(lpDD
, &IID_IDirectDraw7
, (void **) &dd7
);
1692 ok(hr
== DD_OK
, "IDirectDraw::QueryInterface returned %08x\n", hr
);
1694 memset(&ddsd
, 0, sizeof(ddsd
));
1695 ddsd
.dwSize
= sizeof(ddsd
);
1696 U4(ddsd
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd
).ddpfPixelFormat
);
1697 ddsd
.dwFlags
= DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_PIXELFORMAT
| DDSD_CAPS
;
1699 ddsd
.dwHeight
= 128;
1700 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
;
1701 U4(ddsd
).ddpfPixelFormat
.dwFlags
= DDPF_FOURCC
;
1702 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1704 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1705 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1707 skip("failed to create surface\n");
1711 memset(&ddsd2
, 0, sizeof(ddsd2
));
1712 ddsd2
.dwSize
= sizeof(ddsd2
);
1713 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1714 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1715 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1717 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1718 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1719 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1720 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1721 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1722 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1723 ok(U1(ddsd2
).dwLinearSize
== 8192, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1724 ok(ddsd2
.ddsCaps
.dwCaps2
== 0, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1725 IDirectDrawSurface7_Release(surface
);
1727 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
1728 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1729 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1731 skip("failed to create surface\n");
1735 memset(&ddsd2
, 0, sizeof(ddsd2
));
1736 ddsd2
.dwSize
= sizeof(ddsd2
);
1737 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1738 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1739 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1741 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1742 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1743 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1744 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1745 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1746 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1747 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1748 IDirectDrawSurface7_Release(surface
);
1750 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
1751 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1752 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1754 skip("failed to create surface\n");
1758 memset(&ddsd2
, 0, sizeof(ddsd2
));
1759 ddsd2
.dwSize
= sizeof(ddsd2
);
1760 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1761 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1762 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1764 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1765 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1766 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1767 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1768 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1769 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1770 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1771 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
1773 memset(&ddsd2
, 0, sizeof(ddsd2
));
1774 ddsd2
.dwSize
= sizeof(ddsd2
);
1775 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1777 /* Show that the description is not changed when locking the surface. What is really interesting
1778 * about this is that DDSD_LPSURFACE isn't set.
1780 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
1781 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1783 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1784 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1785 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1786 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1787 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1788 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1789 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1790 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1792 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
1793 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1795 /* Now what about a locking rect? */
1796 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
1797 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1799 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1800 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1801 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1802 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1803 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1804 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1805 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1806 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1808 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
1809 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1811 /* Now what about a different locking offset? */
1812 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
1813 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1815 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1816 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1817 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1818 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1819 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1820 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1821 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1822 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1824 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
1825 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1826 IDirectDrawSurface7_Release(surface
);
1828 /* Try this with video memory. A kind of surprise. It still has the LINEARSIZE flag set,
1829 * but seems to have a pitch instead.
1831 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
;
1832 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1834 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1835 ok(hr
== DD_OK
|| hr
== DDERR_NOTEXTUREHW
|| hr
== DDERR_INVALIDPARAMS
,
1836 "CreateSurface returned %08x\n", hr
);
1838 /* Not supported everywhere */
1841 memset(&ddsd2
, 0, sizeof(ddsd2
));
1842 ddsd2
.dwSize
= sizeof(ddsd2
);
1843 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1844 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1845 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1847 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1848 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1849 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1850 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1851 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1852 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1853 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1854 ok(ddsd2
.ddsCaps
.dwCaps2
== 0, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1855 IDirectDrawSurface7_Release(surface
);
1857 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
1858 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1859 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1861 memset(&ddsd2
, 0, sizeof(ddsd2
));
1862 ddsd2
.dwSize
= sizeof(ddsd2
);
1863 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1864 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1865 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1867 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1868 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1869 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1870 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1871 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1872 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1873 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1874 IDirectDrawSurface7_Release(surface
);
1876 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
1877 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1878 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1880 memset(&ddsd2
, 0, sizeof(ddsd2
));
1881 ddsd2
.dwSize
= sizeof(ddsd2
);
1882 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1883 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1884 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1886 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1887 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1888 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1889 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1890 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1891 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1892 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1893 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
1895 memset(&ddsd2
, 0, sizeof(ddsd2
));
1896 ddsd2
.dwSize
= sizeof(ddsd2
);
1897 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1899 /* Show that the description is not changed when locking the surface. What is really interesting
1900 * about this is that DDSD_LPSURFACE isn't set.
1902 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
1903 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1905 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1906 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1907 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1908 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1909 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1910 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1911 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1912 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1914 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
1915 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1917 /* Now what about a locking rect? */
1918 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
1919 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1921 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1922 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1923 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1924 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1925 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1926 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1927 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1928 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1930 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
1931 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1933 /* Now what about a different locking offset? */
1934 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
1935 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
1937 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1938 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1939 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1940 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1941 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_VIDEOMEMORY
| DDSCAPS_LOCALVIDMEM
),
1942 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1943 /* ATI drivers report a broken linear size, thus no need to clone the exact behaviour. nvidia reports the correct size */
1944 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
1946 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
1947 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
1949 IDirectDrawSurface7_Release(surface
);
1953 skip("Hardware DXTN textures not supported\n");
1956 /* What happens to managed textures? Interestingly, Windows reports them as being in system
1957 * memory. The linear size fits again.
1959 ddsd
.ddsCaps
.dwCaps
= DDSCAPS_TEXTURE
;
1960 ddsd
.ddsCaps
.dwCaps2
= DDSCAPS2_TEXTUREMANAGE
;
1961 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','1');
1963 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1964 ok(hr
== DD_OK
|| hr
== DDERR_NOTEXTUREHW
, "CreateSurface returned %08x\n", hr
);
1966 /* Not supported everywhere */
1969 memset(&ddsd2
, 0, sizeof(ddsd2
));
1970 ddsd2
.dwSize
= sizeof(ddsd2
);
1971 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1972 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1973 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1975 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1976 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1977 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1978 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1979 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
1980 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
1981 ok(U1(ddsd2
).dwLinearSize
== 8192, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
1982 ok(ddsd2
.ddsCaps
.dwCaps2
== DDSCAPS2_TEXTUREMANAGE
, "Caps2: %08x\n", ddsd2
.ddsCaps
.dwCaps2
);
1983 IDirectDrawSurface7_Release(surface
);
1985 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','3');
1986 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
1987 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
1989 memset(&ddsd2
, 0, sizeof(ddsd2
));
1990 ddsd2
.dwSize
= sizeof(ddsd2
);
1991 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
1992 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
1993 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
1995 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
1996 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
1997 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
1998 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
1999 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2000 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2001 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2002 IDirectDrawSurface7_Release(surface
);
2004 U4(ddsd
).ddpfPixelFormat
.dwFourCC
= MAKEFOURCC('D','X','T','5');
2005 hr
= IDirectDraw7_CreateSurface(dd7
, &ddsd
, &surface
, NULL
);
2006 ok(hr
== DD_OK
, "CreateSurface returned %08x\n", hr
);
2008 memset(&ddsd2
, 0, sizeof(ddsd2
));
2009 ddsd2
.dwSize
= sizeof(ddsd2
);
2010 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
2011 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface
, &ddsd2
);
2012 ok(hr
== DD_OK
, "GetSurfaceDesc returned %08x\n", hr
);
2014 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2015 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2016 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2017 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2018 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2019 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2020 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2021 ok(ddsd2
.lpSurface
== 0, "Surface memory is at %p, expected NULL\n", ddsd2
.lpSurface
);
2023 memset(&ddsd2
, 0, sizeof(ddsd2
));
2024 ddsd2
.dwSize
= sizeof(ddsd2
);
2025 U4(ddsd2
).ddpfPixelFormat
.dwSize
= sizeof(U4(ddsd2
).ddpfPixelFormat
);
2027 /* Show that the description is not changed when locking the surface. What is really interesting
2028 * about this is that DDSD_LPSURFACE isn't set.
2030 hr
= IDirectDrawSurface7_Lock(surface
, NULL
, &ddsd2
, DDLOCK_READONLY
, 0);
2031 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2033 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2034 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2035 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2036 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2037 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2038 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2039 ok(U1(ddsd2
).dwLinearSize
== 16384, "Linear size is %d\n", U1(ddsd2
).dwLinearSize
);
2040 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2042 hr
= IDirectDrawSurface7_Unlock(surface
, NULL
);
2043 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2045 /* Now what about a locking rect? */
2046 hr
= IDirectDrawSurface7_Lock(surface
, &r
, &ddsd2
, DDLOCK_READONLY
, 0);
2047 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2049 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2050 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2051 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2052 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2053 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2054 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2055 ok(U1(ddsd2
).dwLinearSize
== 16384, "\"Linear\" size is %d\n", U1(ddsd2
).dwLinearSize
);
2056 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2058 hr
= IDirectDrawSurface7_Unlock(surface
, &r
);
2059 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2061 /* Now what about a different locking offset? */
2062 hr
= IDirectDrawSurface7_Lock(surface
, &r2
, &ddsd2
, DDLOCK_READONLY
, 0);
2063 ok(hr
== DD_OK
, "Lock returned %08x\n", hr
);
2065 ok(ddsd2
.dwFlags
== (DDSD_PIXELFORMAT
| DDSD_WIDTH
| DDSD_HEIGHT
| DDSD_CAPS
| DDSD_LINEARSIZE
),
2066 "Surface desc flags: %08x\n", ddsd2
.dwFlags
);
2067 ok(U4(ddsd2
).ddpfPixelFormat
.dwFlags
== DDPF_FOURCC
, "Pixel format flags: %08x\n", U4(ddsd2
).ddpfPixelFormat
.dwFlags
);
2068 ok(U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
== 0, "RGB bitcount: %08x\n", U1(U4(ddsd2
).ddpfPixelFormat
).dwRGBBitCount
);
2069 ok(ddsd2
.ddsCaps
.dwCaps
== (DDSCAPS_TEXTURE
| DDSCAPS_SYSTEMMEMORY
),
2070 "Surface caps flags: %08x\n", ddsd2
.ddsCaps
.dwCaps
);
2071 ok(U1(ddsd2
).dwLinearSize
== 16384, "\"Linear\" size is %d\n", U1(ddsd2
).dwLinearSize
);
2072 ok(ddsd2
.lpSurface
!= 0, "Surface memory is at NULL\n");
2074 hr
= IDirectDrawSurface7_Unlock(surface
, &r2
);
2075 ok(hr
== DD_OK
, "Unlock returned %08x\n", hr
);
2077 IDirectDrawSurface7_Release(surface
);
2081 skip("Hardware DXTN textures not supported\n");
2084 IDirectDraw7_Release(dd7
);
2087 static void SizeTest(void)
2089 LPDIRECTDRAWSURFACE dsurface
= NULL
;
2092 HWND window
= CreateWindow( "static", "ddraw_test", WS_OVERLAPPEDWINDOW
, 100, 100, 160, 160, NULL
, NULL
, NULL
, NULL
);
2094 /* Create an offscreen surface surface without a size */
2095 ZeroMemory(&desc
, sizeof(desc
));
2096 desc
.dwSize
= sizeof(desc
);
2097 desc
.dwFlags
= DDSD_CAPS
;
2098 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2099 trace("before offscreenplain create dsurface = %p\n", dsurface
);
2100 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2101 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without a size info returned %08x (dsurface=%p)\n", ret
, dsurface
);
2104 trace("Surface at %p\n", dsurface
);
2105 IDirectDrawSurface_Release(dsurface
);
2109 /* Create an offscreen surface surface with only a width parameter */
2110 ZeroMemory(&desc
, sizeof(desc
));
2111 desc
.dwSize
= sizeof(desc
);
2112 desc
.dwFlags
= DDSD_CAPS
| DDSD_WIDTH
;
2113 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2115 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2116 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without hight info returned %08x\n", ret
);
2119 IDirectDrawSurface_Release(dsurface
);
2123 /* Create an offscreen surface surface with only a height parameter */
2124 ZeroMemory(&desc
, sizeof(desc
));
2125 desc
.dwSize
= sizeof(desc
);
2126 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
;
2127 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2128 desc
.dwHeight
= 128;
2129 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2130 ok(ret
== DDERR_INVALIDPARAMS
, "Creating an offscreen plain surface without width info returned %08x\n", ret
);
2133 IDirectDrawSurface_Release(dsurface
);
2138 ZeroMemory(&desc
, sizeof(desc
));
2139 desc
.dwSize
= sizeof(desc
);
2140 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2141 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2142 desc
.dwHeight
= 128;
2144 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2145 ok(ret
== DD_OK
, "Creating an offscreen plain surface with width and height info returned %08x\n", ret
);
2148 IDirectDrawSurface_Release(dsurface
);
2152 /* Test a primary surface size */
2153 ret
= IDirectDraw_SetCooperativeLevel(lpDD
, window
, DDSCL_NORMAL
);
2154 ok(ret
== DD_OK
, "SetCooperativeLevel failed with %08x\n", ret
);
2156 ZeroMemory(&desc
, sizeof(desc
));
2157 desc
.dwSize
= sizeof(desc
);
2158 desc
.dwFlags
= DDSD_CAPS
;
2159 desc
.ddsCaps
.dwCaps
|= DDSCAPS_PRIMARYSURFACE
;
2160 desc
.dwHeight
= 128; /* Keep them set to check what happens */
2161 desc
.dwWidth
= 128; /* Keep them set to check what happens */
2162 ret
= IDirectDraw_CreateSurface(lpDD
, &desc
, &dsurface
, NULL
);
2163 ok(ret
== DD_OK
, "Creating a primary surface without width and height info returned %08x\n", ret
);
2166 ret
= IDirectDrawSurface_GetSurfaceDesc(dsurface
, &desc
);
2167 ok(ret
== DD_OK
, "GetSurfaceDesc returned %x\n", ret
);
2169 IDirectDrawSurface_Release(dsurface
);
2172 ok(desc
.dwFlags
& DDSD_WIDTH
, "Primary surface doesn't have width set\n");
2173 ok(desc
.dwFlags
& DDSD_HEIGHT
, "Primary surface doesn't have height set\n");
2174 ok(desc
.dwWidth
== GetSystemMetrics(SM_CXSCREEN
), "Surface width differs from screen width\n");
2175 ok(desc
.dwHeight
== GetSystemMetrics(SM_CYSCREEN
), "Surface height differs from screen height\n");
2177 ret
= IDirectDraw_SetCooperativeLevel(lpDD
, NULL
, DDSCL_NORMAL
);
2178 ok(ret
== DD_OK
, "SetCooperativeLevel failed with %08x\n", ret
);
2181 static void PrivateDataTest(void)
2184 IDirectDrawSurface7
*surface7
= NULL
;
2185 IDirectDrawSurface
*surface
= NULL
;
2189 DWORD size
= sizeof(IUnknown
*);
2191 ZeroMemory(&desc
, sizeof(desc
));
2192 desc
.dwSize
= sizeof(desc
);
2193 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2194 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2195 desc
.dwHeight
= 128;
2197 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface
, NULL
);
2198 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2203 hr
= IDirectDrawSurface_QueryInterface(surface
, &IID_IDirectDrawSurface7
, (void **) &surface7
);
2204 ok(hr
== DD_OK
, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr
);
2207 IDirectDrawSurface_Release(surface
);
2212 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, 0, DDSPD_IUNKNOWNPOINTER
);
2213 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2214 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, 5, DDSPD_IUNKNOWNPOINTER
);
2215 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2216 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, sizeof(IUnknown
*) * 2, DDSPD_IUNKNOWNPOINTER
);
2217 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2219 ref
= getref((IUnknown
*) lpDD
);
2220 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
/* Abuse this tag */, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2221 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2222 ref2
= getref((IUnknown
*) lpDD
);
2223 ok(ref2
== ref
+ 1, "Object reference is %d, expected %d\n", ref2
, ref
+ 1);
2224 hr
= IDirectDrawSurface7_FreePrivateData(surface7
, &IID_IDirectDrawSurface7
);
2225 ref2
= getref((IUnknown
*) lpDD
);
2226 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2228 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2229 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2230 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, surface7
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2231 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2232 ref2
= getref((IUnknown
*) lpDD
);
2233 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2235 hr
= IDirectDrawSurface7_SetPrivateData(surface7
, &IID_IDirectDrawSurface7
, lpDD
, sizeof(IUnknown
*), DDSPD_IUNKNOWNPOINTER
);
2236 ok(hr
== DD_OK
, "IDirectDrawSurface7_SetPrivateData failed with %08x\n", hr
);
2237 hr
= IDirectDrawSurface7_GetPrivateData(surface7
, &IID_IDirectDrawSurface7
, &ptr
, &size
);
2238 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetPrivateData failed with %08x\n", hr
);
2239 ref2
= getref((IUnknown
*) lpDD
);
2240 /* Object is NOT beein addrefed */
2241 ok(ptr
== (IUnknown
*) lpDD
, "Returned interface pointer is %p, expected %p\n", ptr
, lpDD
);
2242 ok(ref2
== ref
+ 1, "Object reference is %d, expected %d. ptr at %p, orig at %p\n", ref2
, ref
+ 1, ptr
, lpDD
);
2244 IDirectDrawSurface_Release(surface
);
2245 IDirectDrawSurface7_Release(surface7
);
2247 /* Destroying the surface frees the held reference */
2248 ref2
= getref((IUnknown
*) lpDD
);
2249 ok(ref2
== ref
, "Object reference is %d, expected %d\n", ref2
, ref
);
2252 static void BltParamTest(void)
2254 IDirectDrawSurface
*surface1
= NULL
, *surface2
= NULL
;
2258 RECT valid
= {10, 10, 20, 20};
2259 RECT invalid1
= {20, 10, 10, 20};
2260 RECT invalid2
= {20, 20, 20, 20};
2261 RECT invalid3
= {-1, -1, 20, 20};
2262 RECT invalid4
= {60, 60, 70, 70};
2264 memset(&desc
, 0, sizeof(desc
));
2265 desc
.dwSize
= sizeof(desc
);
2266 desc
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2267 desc
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2268 desc
.dwHeight
= 128;
2270 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface1
, NULL
);
2271 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2275 hr
= IDirectDraw_CreateSurface(lpDD
, &desc
, &surface2
, NULL
);
2276 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2281 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, NULL
, NULL
, 0);
2282 ok(hr
== DD_OK
, "BltFast from NULL surface returned %08x\n", hr
);
2284 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface2
, NULL
, 0);
2285 ok(hr
== DD_OK
, "BltFast from smaller to bigger surface returned %08x\n", hr
);
2286 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, NULL
, 0);
2287 ok(hr
== DDERR_INVALIDRECT
, "BltFast from bigger to smaller surface returned %08x\n", hr
);
2288 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &valid
, 0);
2289 ok(hr
== DD_OK
, "BltFast from bigger to smaller surface using a valid rectangle returned %08x\n", hr
);
2290 hr
= IDirectDrawSurface_BltFast(surface2
, 60, 60, surface1
, &valid
, 0);
2291 ok(hr
== DDERR_INVALIDRECT
, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr
);
2292 hr
= IDirectDrawSurface_BltFast(surface1
, 90, 90, surface2
, NULL
, 0);
2293 ok(hr
== DDERR_INVALIDRECT
, "BltFast with a rectangle resulting in an off-surface write returned %08x\n", hr
);
2294 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid1
, 0);
2295 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 1 returned %08x\n", hr
);
2296 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid2
, 0);
2297 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 2 returned %08x\n", hr
);
2298 hr
= IDirectDrawSurface_BltFast(surface2
, 0, 0, surface1
, &invalid3
, 0);
2299 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 3 returned %08x\n", hr
);
2300 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface2
, &invalid4
, 0);
2301 ok(hr
== DDERR_INVALIDRECT
, "BltFast with invalid rectangle 3 returned %08x\n", hr
);
2302 hr
= IDirectDrawSurface_BltFast(surface1
, 0, 0, surface1
, NULL
, 0);
2303 ok(hr
== DD_OK
, "BltFast blitting a surface onto itself returned %08x\n", hr
);
2305 /* Blt(non-fast) tests */
2306 memset(&BltFx
, 0, sizeof(BltFx
));
2307 BltFx
.dwSize
= sizeof(BltFx
);
2308 U5(BltFx
).dwFillColor
= 0xaabbccdd;
2310 hr
= IDirectDrawSurface_Blt(surface1
, &valid
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2311 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a valid rectangle for color fill returned %08x\n", hr
);
2312 hr
= IDirectDrawSurface_Blt(surface1
, &valid
, NULL
, &invalid3
, DDBLT_COLORFILL
, &BltFx
);
2313 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a invalid, unused rectangle returned %08x\n", hr
);
2314 hr
= IDirectDrawSurface_Blt(surface2
, &invalid1
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2315 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2316 hr
= IDirectDrawSurface_Blt(surface2
, &invalid2
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2317 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2318 hr
= IDirectDrawSurface_Blt(surface2
, &invalid3
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2319 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2320 hr
= IDirectDrawSurface_Blt(surface2
, &invalid4
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2321 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2323 /* Valid on surface 1 */
2324 hr
= IDirectDrawSurface_Blt(surface1
, &invalid4
, NULL
, NULL
, DDBLT_COLORFILL
, &BltFx
);
2325 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt with a subrectangle fill returned %08x\n", hr
);
2327 /* Works - stretched blit */
2328 hr
= IDirectDrawSurface_Blt(surface1
, NULL
, surface2
, NULL
, 0, NULL
);
2329 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt from a smaller to a bigger surface returned %08x\n", hr
);
2330 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, NULL
, 0, NULL
);
2331 ok(hr
== DD_OK
, "IDirectDrawSurface_Blt from a bigger to a smaller surface %08x\n", hr
);
2333 /* Invalid dest rects in sourced blits */
2334 hr
= IDirectDrawSurface_Blt(surface2
, &invalid1
, surface1
, NULL
, 0, NULL
);
2335 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2336 hr
= IDirectDrawSurface_Blt(surface2
, &invalid2
, surface1
, NULL
, 0, NULL
);
2337 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2338 hr
= IDirectDrawSurface_Blt(surface2
, &invalid3
, surface1
, NULL
, 0, NULL
);
2339 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2340 hr
= IDirectDrawSurface_Blt(surface2
, &invalid4
, surface1
, NULL
, 0, NULL
);
2341 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2343 /* Invalid src rects */
2344 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid1
, 0, NULL
);
2345 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 1 returned %08x\n", hr
);
2346 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid2
, 0, NULL
);
2347 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 2 returned %08x\n", hr
);
2348 hr
= IDirectDrawSurface_Blt(surface2
, NULL
, surface1
, &invalid3
, 0, NULL
);
2349 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 3 returned %08x\n", hr
);
2350 hr
= IDirectDrawSurface_Blt(surface1
, NULL
, surface2
, &invalid4
, 0, NULL
);
2351 ok(hr
== DDERR_INVALIDRECT
, "IDirectDrawSurface_Blt with a with invalid rectangle 4 returned %08x\n", hr
);
2353 IDirectDrawSurface_Release(surface1
);
2354 IDirectDrawSurface_Release(surface2
);
2357 static void StructSizeTest(void)
2359 IDirectDrawSurface
*surface1
;
2360 IDirectDrawSurface7
*surface7
;
2362 DDSURFACEDESC desc1
;
2363 DDSURFACEDESC2 desc2
;
2364 char blob
[1024]; /* To get a bunch of writable memory */
2366 DDSURFACEDESC create
;
2369 memset(&desc
, 0, sizeof(desc
));
2370 memset(&create
, 0, sizeof(create
));
2372 memset(&create
, 0, sizeof(create
));
2373 create
.dwSize
= sizeof(create
);
2374 create
.dwFlags
= DDSD_CAPS
| DDSD_HEIGHT
| DDSD_WIDTH
;
2375 create
.ddsCaps
.dwCaps
|= DDSCAPS_OFFSCREENPLAIN
;
2376 create
.dwHeight
= 128;
2377 create
.dwWidth
= 128;
2378 hr
= IDirectDraw_CreateSurface(lpDD
, &create
, &surface1
, NULL
);
2379 ok(hr
== DD_OK
, "Creating an offscreen plain surface failed with %08x\n", hr
);
2380 hr
= IDirectDrawSurface_QueryInterface(surface1
, &IID_IDirectDrawSurface7
, (void **) &surface7
);
2381 ok(hr
== DD_OK
, "IDirectDrawSurface_QueryInterface failed with %08x\n", hr
);
2383 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
);
2384 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2385 ok(hr
== DD_OK
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2386 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2387 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2389 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
);
2390 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2391 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2392 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2393 ok(hr
== DD_OK
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2395 desc
.desc2
.dwSize
= 0;
2396 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2397 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size 0 returned %08x\n", hr
);
2398 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2399 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size 0 returned %08x\n", hr
);
2401 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
) + 1;
2402 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2403 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2404 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2405 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2407 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
) + 1;
2408 hr
= IDirectDrawSurface_GetSurfaceDesc(surface1
, &desc
.desc1
);
2409 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2410 hr
= IDirectDrawSurface7_GetSurfaceDesc(surface7
, &desc
.desc2
);
2411 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_GetSurfaceDesc with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2413 /* Tests for Lock() */
2415 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
);
2416 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2417 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2418 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2419 ok(desc
.desc1
.dwSize
== sizeof(DDSURFACEDESC
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2420 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2421 ok(hr
== DD_OK
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) returned %08x\n", hr
);
2422 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2423 ok(desc
.desc2
.dwSize
== sizeof(DDSURFACEDESC
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2425 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
);
2426 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2427 ok(hr
== DD_OK
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2428 ok(desc
.desc1
.dwSize
== sizeof(DDSURFACEDESC2
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2429 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2430 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2431 ok(hr
== DD_OK
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) returned %08x\n", hr
);
2432 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2433 ok(desc
.desc2
.dwSize
== sizeof(DDSURFACEDESC2
), "Destination size was changed to %d\n", desc
.desc1
.dwSize
);
2435 desc
.desc2
.dwSize
= 0;
2436 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2437 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size 0 returned %08x\n", hr
);
2438 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2439 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2440 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size 0 returned %08x\n", hr
);
2441 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2443 desc
.desc1
.dwSize
= sizeof(DDSURFACEDESC
) + 1;
2444 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2445 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2446 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2447 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2448 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC) + 1 returned %08x\n", hr
);
2449 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2451 desc
.desc2
.dwSize
= sizeof(DDSURFACEDESC2
) + 1;
2452 hr
= IDirectDrawSurface_Lock(surface1
, NULL
, &desc
.desc1
, 0, 0);
2453 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2454 if(SUCCEEDED(hr
)) IDirectDrawSurface_Unlock(surface1
, NULL
);
2455 hr
= IDirectDrawSurface7_Lock(surface7
, NULL
, &desc
.desc2
, 0, 0);
2456 ok(hr
== DDERR_INVALIDPARAMS
, "IDirectDrawSurface7_Lock with desc size sizeof(DDSURFACEDESC2) + 1returned %08x\n", hr
);
2457 if(SUCCEEDED(hr
)) IDirectDrawSurface7_Unlock(surface7
, NULL
);
2459 IDirectDrawSurface7_Release(surface7
);
2460 IDirectDrawSurface_Release(surface1
);
2463 START_TEST(dsurface
)
2465 if (!CreateDirectDraw())
2467 MipMapCreationTest();
2468 SrcColorKey32BlitTest();
2478 test_lockrect_invalid();
2484 ReleaseDirectDraw();