?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 1.3.7.
[wine/gsoc-2012-control.git] / dlls / ddraw / tests / visual.c
blobc756bacb5f1d0d053f22a6f8268ab77602da49c8
1 /*
2 * Copyright (C) 2007 Stefan Dösinger(for CodeWeavers)
3 * Copyright (C) 2008 Alexander Dorofeyev
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 /* See comment in dlls/d3d9/tests/visual.c for general guidelines */
21
22 #include <assert.h>
23 #include "wine/test.h"
24 #include "ddraw.h"
25 #include "d3d.h"
26
27 static HWND window;
28 static IDirectDraw7 *DirectDraw;
29 static IDirectDrawSurface7 *Surface;
30 static IDirectDrawSurface7 *depth_buffer;
31 static IDirect3D7 *Direct3D;
32 static IDirect3DDevice7 *Direct3DDevice;
33
34 static IDirectDraw *DirectDraw1;
35 static IDirectDrawSurface *Surface1;
36 static IDirect3D *Direct3D1;
37 static IDirect3DDevice *Direct3DDevice1;
38 static IDirect3DExecuteBuffer *ExecuteBuffer;
39 static IDirect3DViewport *Viewport;
40
41 static BOOL refdevice = FALSE;
42
43 static HRESULT (WINAPI *pDirectDrawCreateEx)(LPGUID,LPVOID*,REFIID,LPUNKNOWN);
44
45 static BOOL color_match(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff)
46 {
47 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
48 c1 >>= 8; c2 >>= 8;
49 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
50 c1 >>= 8; c2 >>= 8;
51 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
52 c1 >>= 8; c2 >>= 8;
53 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
54 return TRUE;
55 }
56
57 static BOOL createObjects(void)
58 {
59 HRESULT hr;
60 HMODULE hmod = GetModuleHandleA("ddraw.dll");
61 WNDCLASS wc = {0};
62 DDSURFACEDESC2 ddsd;
63
64
65 if(!hmod) return FALSE;
66 pDirectDrawCreateEx = (void*)GetProcAddress(hmod, "DirectDrawCreateEx");
67 if(!pDirectDrawCreateEx) return FALSE;
68
69 hr = pDirectDrawCreateEx(NULL, (void **) &DirectDraw, &IID_IDirectDraw7, NULL);
70 ok(hr==DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", hr);
71 if(!DirectDraw) goto err;
72
73 wc.lpfnWndProc = DefWindowProc;
74 wc.lpszClassName = "d3d7_test_wc";
75 RegisterClass(&wc);
76 window = CreateWindow("d3d7_test_wc", "d3d7_test", WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
77
78 hr = IDirectDraw7_SetCooperativeLevel(DirectDraw, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
79 ok(hr == DD_OK, "IDirectDraw7_SetCooperativeLevel failed with %08x\n", hr);
80 if(FAILED(hr)) goto err;
81 hr = IDirectDraw7_SetDisplayMode(DirectDraw, 640, 480, 32, 0, 0);
82 if(FAILED(hr)) {
83 /* 24 bit is fine too */
84 hr = IDirectDraw7_SetDisplayMode(DirectDraw, 640, 480, 24, 0, 0);
85
86 }
87 ok(hr == DD_OK || hr == DDERR_UNSUPPORTED, "IDirectDraw7_SetDisplayMode failed with %08x\n", hr);
88 if(FAILED(hr)) {
89 /* use trace, the caller calls skip() */
90 trace("SetDisplayMode failed\n");
91 goto err;
92 }
93
94 hr = IDirectDraw7_QueryInterface(DirectDraw, &IID_IDirect3D7, (void**) &Direct3D);
95 if (hr == E_NOINTERFACE) goto err;
96 ok(hr==DD_OK, "QueryInterface returned: %08x\n", hr);
97
98 /* DirectDraw Flipping behavior doesn't seem that well-defined. The reference rasterizer behaves differently
99 * than hardware implementations. Request single buffering, that seems to work everywhere
100 */
101 memset(&ddsd, 0, sizeof(ddsd));
102 ddsd.dwSize = sizeof(ddsd);
103 ddsd.dwFlags = DDSD_CAPS;
104 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;
105 ddsd.dwBackBufferCount = 1;
106 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &Surface, NULL);
107 if(FAILED(hr)) goto err;
108
109 memset(&ddsd, 0, sizeof(ddsd));
110 ddsd.dwSize = sizeof(ddsd);
111 ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
112 ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
113 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
114 U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_ZBUFFER;
115 U1(U4(ddsd).ddpfPixelFormat).dwZBufferBitDepth = 32;
116 U3(U4(ddsd).ddpfPixelFormat).dwZBitMask = 0x00ffffff;
117 ddsd.dwWidth = 640;
118 ddsd.dwHeight = 480;
119 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &depth_buffer, NULL);
120 ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr);
121 if (FAILED(hr)) goto err;
122
123 hr = IDirectDrawSurface_AddAttachedSurface(Surface, depth_buffer);
124 ok(SUCCEEDED(hr), "AddAttachedSurface failed, hr %#x.\n", hr);
125 if (FAILED(hr)) goto err;
126
127 hr = IDirect3D7_CreateDevice(Direct3D, &IID_IDirect3DTnLHalDevice, Surface, &Direct3DDevice);
128 if(FAILED(hr))
129 {
130 trace("Creating a TnLHal Device failed, trying HAL\n");
131 hr = IDirect3D7_CreateDevice(Direct3D, &IID_IDirect3DHALDevice, Surface, &Direct3DDevice);
132 if(FAILED(hr))
133 {
134 trace("Creating a HAL device failed, trying Ref\n");
135 hr = IDirect3D7_CreateDevice(Direct3D, &IID_IDirect3DRefDevice, Surface, &Direct3DDevice);
136 if (SUCCEEDED(hr))
137 refdevice = TRUE;
138 }
139 }
140 if(!Direct3DDevice) goto err;
141 return TRUE;
142
143 err:
144 if(DirectDraw) IDirectDraw7_Release(DirectDraw);
145 if (depth_buffer) IDirectDrawSurface7_Release(depth_buffer);
146 if(Surface) IDirectDrawSurface7_Release(Surface);
147 if(Direct3D) IDirect3D7_Release(Direct3D);
148 if(Direct3DDevice) IDirect3DDevice7_Release(Direct3DDevice);
149 if(window) DestroyWindow(window);
150 return FALSE;
151 }
152
153 static void releaseObjects(void)
154 {
155 IDirect3DDevice7_Release(Direct3DDevice);
156 IDirect3D7_Release(Direct3D);
157 IDirectDrawSurface7_Release(depth_buffer);
158 IDirectDrawSurface7_Release(Surface);
159 IDirectDraw7_Release(DirectDraw);
160 DestroyWindow(window);
161 }
162
163 static DWORD getPixelColor(IDirect3DDevice7 *device, UINT x, UINT y)
164 {
165 DWORD ret;
166 HRESULT hr;
167 DDSURFACEDESC2 ddsd;
168 RECT rectToLock = {x, y, x+1, y+1};
169 IDirectDrawSurface7 *surf = NULL;
170
171 /* Some implementations seem to dislike direct locking on the front buffer. Thus copy the front buffer
172 * to an offscreen surface and lock it instead of the front buffer
173 */
174 memset(&ddsd, 0, sizeof(ddsd));
175 ddsd.dwSize = sizeof(ddsd);
176 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
177 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
178 ddsd.dwWidth = 640;
179 ddsd.dwHeight = 480;
180 ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
181 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &surf, NULL);
182 ok(hr == DD_OK, "IDirectDraw7_CreateSurface failed with %08x\n", hr);
183 if(!surf)
184 {
185 trace("cannot create helper surface\n");
186 return 0xdeadbeef;
187 }
188
189 memset(&ddsd, 0, sizeof(ddsd));
190 ddsd.dwSize = sizeof(ddsd);
191 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
192
193 hr = IDirectDrawSurface_BltFast(surf, 0, 0, Surface, NULL, 0);
194 ok(hr == DD_OK, "IDirectDrawSurface7_BltFast returned %08x\n", hr);
195 if(FAILED(hr))
196 {
197 trace("Cannot blit\n");
198 ret = 0xdeadbee;
199 goto out;
200 }
201
202 hr = IDirectDrawSurface7_Lock(surf, &rectToLock, &ddsd, DDLOCK_READONLY | DDLOCK_WAIT, NULL);
203 if(FAILED(hr))
204 {
205 trace("Can't lock the offscreen surface, hr=%08x\n", hr);
206 ret = 0xdeadbeec;
207 goto out;
208 }
209
210 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
211 * really important for these tests
212 */
213 ret = ((DWORD *) ddsd.lpSurface)[0] & 0x00ffffff;
214 hr = IDirectDrawSurface7_Unlock(surf, NULL);
215 if(FAILED(hr))
216 {
217 trace("Can't unlock the offscreen surface, hr=%08x\n", hr);
218 }
219
220 out:
221 IDirectDrawSurface7_Release(surf);
222 return ret;
223 }
224
225 /*
226 * Helper function to get and set the viewport - needed on geforce 8800 on XP - driver bug?
227 * This is needed after IDirect3DDevice7_SetRenderTarget in combination with offscreen to backbuffer rendering.
228 */
229 static void set_the_same_viewport_again(IDirect3DDevice7 *device)
230 {
231 D3DVIEWPORT7 vp = {0};
232 HRESULT hr;
233 hr = IDirect3DDevice7_GetViewport(device,&vp);
234 ok(hr == D3D_OK && vp.dwWidth == 640 && vp.dwHeight == 480, "IDirect3DDevice7_SetViewport returned %08x\n", hr);
235 hr = IDirect3DDevice7_SetViewport(device, &vp);
236 ok(hr == D3D_OK, "IDirect3DDevice7_SetViewport returned %08x\n", hr);
237 return;
238 }
239
240 struct vertex
241 {
242 float x, y, z;
243 DWORD diffuse;
244 };
245
246 struct tvertex
247 {
248 float x, y, z, w;
249 DWORD diffuse;
250 };
251
252 struct nvertex
253 {
254 float x, y, z;
255 float nx, ny, nz;
256 DWORD diffuse;
257 };
258
259 static void lighting_test(IDirect3DDevice7 *device)
260 {
261 HRESULT hr;
262 DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
263 DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
264 DWORD color;
265
266 float mat[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
267 0.0f, 1.0f, 0.0f, 0.0f,
268 0.0f, 0.0f, 1.0f, 0.0f,
269 0.0f, 0.0f, 0.0f, 1.0f };
270
271 struct vertex unlitquad[] =
272 {
273 {-1.0f, -1.0f, 0.1f, 0xffff0000},
274 {-1.0f, 0.0f, 0.1f, 0xffff0000},
275 { 0.0f, 0.0f, 0.1f, 0xffff0000},
276 { 0.0f, -1.0f, 0.1f, 0xffff0000},
277 };
278 struct vertex litquad[] =
279 {
280 {-1.0f, 0.0f, 0.1f, 0xff00ff00},
281 {-1.0f, 1.0f, 0.1f, 0xff00ff00},
282 { 0.0f, 1.0f, 0.1f, 0xff00ff00},
283 { 0.0f, 0.0f, 0.1f, 0xff00ff00},
284 };
285 struct nvertex unlitnquad[] =
286 {
287 { 0.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
288 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
289 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
290 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
291 };
292 struct nvertex litnquad[] =
293 {
294 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
295 { 0.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
296 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
297 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
298 };
299 WORD Indices[] = {0, 1, 2, 2, 3, 0};
300
301 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
302 ok(hr == D3D_OK, "IDirect3DDevice7_Clear failed with %08x\n", hr);
303
304 /* Setup some states that may cause issues */
305 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_WORLD, (D3DMATRIX *) mat);
306 ok(hr == D3D_OK, "IDirect3DDevice7_SetTransform returned %08x\n", hr);
307 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_VIEW, (D3DMATRIX *)mat);
308 ok(hr == D3D_OK, "IDirect3DDevice7_SetTransform returned %08x\n", hr);
309 hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_PROJECTION, (D3DMATRIX *) mat);
310 ok(hr == D3D_OK, "IDirect3DDevice7_SetTransform returned %08x\n", hr);
311 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CLIPPING, FALSE);
312 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
313 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, FALSE);
314 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
315 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, FALSE);
316 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
317 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_STENCILENABLE, FALSE);
318 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
319 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHATESTENABLE, FALSE);
320 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
321 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
322 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
323 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);
324 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed with %08x\n", hr);
325
326 hr = IDirect3DDevice7_BeginScene(device);
327 ok(hr == D3D_OK, "IDirect3DDevice7_BeginScene failed with %08x\n", hr);
328 if(hr == D3D_OK)
329 {
330 /* No lights are defined... That means, lit vertices should be entirely black */
331 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
332 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
333 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, fvf, unlitquad, 4 /* NumVerts */,
334 Indices, 6 /* Indexcount */, 0 /* flags */);
335 ok(hr == D3D_OK, "IDirect3DDevice7_DrawIndexedPrimitiveUP failed with %08x\n", hr);
336
337 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, TRUE);
338 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
339 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, fvf, litquad, 4 /* NumVerts */,
340 Indices, 6 /* Indexcount */, 0 /* flags */);
341 ok(hr == D3D_OK, "IDirect3DDevice7_DrawIndexedPrimitiveUP failed with %08x\n", hr);
342
343 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
344 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
345 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, nfvf, unlitnquad, 4 /* NumVerts */,
346 Indices, 6 /* Indexcount */, 0 /* flags */);
347 ok(hr == D3D_OK, "IDirect3DDevice7_DrawIndexedPrimitiveUP failed with %08x\n", hr);
348
349 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, TRUE);
350 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
351 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, nfvf, litnquad, 4 /* NumVerts */,
352 Indices, 6 /* Indexcount */, 0 /* flags */);
353 ok(hr == D3D_OK, "IDirect3DDevice7_DrawIndexedPrimitiveUP failed with %08x\n", hr);
354
355 IDirect3DDevice7_EndScene(device);
356 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed with %08x\n", hr);
357 }
358
359 color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
360 ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
361 color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
362 ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
363 color = getPixelColor(device, 480, 360); /* lower left quad - unlit width normals */
364 ok(color == 0x000000ff, "Unlit quad width normals has color %08x\n", color);
365 color = getPixelColor(device, 480, 120); /* upper left quad - lit width normals */
366 ok(color == 0x00000000, "Lit quad width normals has color %08x\n", color);
367
368 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
369 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned %08x\n", hr);
370 }
371
372 static void clear_test(IDirect3DDevice7 *device)
373 {
374 /* Tests the correctness of clearing parameters */
375 HRESULT hr;
376 D3DRECT rect[2];
377 D3DRECT rect_negneg;
378 DWORD color;
379
380 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
381 ok(hr == D3D_OK, "IDirect3DDevice7_Clear failed with %08x\n", hr);
382
383 /* Positive x, negative y */
384 U1(rect[0]).x1 = 0;
385 U2(rect[0]).y1 = 480;
386 U3(rect[0]).x2 = 320;
387 U4(rect[0]).y2 = 240;
388
389 /* Positive x, positive y */
390 U1(rect[1]).x1 = 0;
391 U2(rect[1]).y1 = 0;
392 U3(rect[1]).x2 = 320;
393 U4(rect[1]).y2 = 240;
394 /* Clear 2 rectangles with one call. Shows that a positive value is returned, but the negative rectangle
395 * is ignored, the positive is still cleared afterwards
396 */
397 hr = IDirect3DDevice7_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
398 ok(hr == D3D_OK, "IDirect3DDevice7_Clear failed with %08x\n", hr);
399
400 /* negative x, negative y */
401 U1(rect_negneg).x1 = 640;
402 U2(rect_negneg).y1 = 240;
403 U3(rect_negneg).x2 = 320;
404 U4(rect_negneg).y2 = 0;
405 hr = IDirect3DDevice7_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
406 ok(hr == D3D_OK, "IDirect3DDevice7_Clear failed with %08x\n", hr);
407
408 color = getPixelColor(device, 160, 360); /* lower left quad */
409 ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
410 color = getPixelColor(device, 160, 120); /* upper left quad */
411 ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
412 color = getPixelColor(device, 480, 360); /* lower right quad */
413 ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
414 color = getPixelColor(device, 480, 120); /* upper right quad */
415 ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
416 }
417
418 struct sVertex {
419 float x, y, z;
420 DWORD diffuse;
421 DWORD specular;
422 };
423
424 struct sVertexT {
425 float x, y, z, rhw;
426 DWORD diffuse;
427 DWORD specular;
428 };
429
430 static void fog_test(IDirect3DDevice7 *device)
431 {
432 HRESULT hr;
433 DWORD color;
434 float start = 0.0, end = 1.0;
435 D3DDEVICEDESC7 caps;
436
437 /* Gets full z based fog with linear fog, no fog with specular color */
438 struct sVertex unstransformed_1[] = {
439 {-1, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
440 {-1, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
441 { 0, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
442 { 0, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
443 };
444 /* Ok, I am too lazy to deal with transform matrices */
445 struct sVertex unstransformed_2[] = {
446 {-1, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
447 {-1, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
448 { 0, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
449 { 0, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
450 };
451 /* Untransformed ones. Give them a different diffuse color to make the test look
452 * nicer. It also makes making sure that they are drawn correctly easier.
453 */
454 struct sVertexT transformed_1[] = {
455 {320, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
456 {640, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
457 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
458 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
459 };
460 struct sVertexT transformed_2[] = {
461 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
462 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
463 {640, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
464 {320, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
465 };
466 WORD Indices[] = {0, 1, 2, 2, 3, 0};
467
468 memset(&caps, 0, sizeof(caps));
469 hr = IDirect3DDevice7_GetCaps(device, &caps);
470 ok(hr == D3D_OK, "IDirect3DDevice7_GetCaps returned %08x\n", hr);
471 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
472 ok(hr == D3D_OK, "IDirect3DDevice7_Clear returned %08x\n", hr);
473
474 /* Setup initial states: No lighting, fog on, fog color */
475 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
476 ok(hr == D3D_OK, "Turning off lighting returned %08x\n", hr);
477 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, TRUE);
478 ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
479 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGCOLOR, 0xFF00FF00 /* A nice green */);
480 ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
481
482 /* First test: Both table fog and vertex fog off */
483 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_NONE);
484 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
485 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_NONE);
486 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
487
488 /* Start = 0, end = 1. Should be default, but set them */
489 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGSTART, *((DWORD *) &start));
490 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
491 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGEND, *((DWORD *) &end));
492 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
493
494 if(IDirect3DDevice7_BeginScene(device) == D3D_OK)
495 {
496 /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
497 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR,
498 unstransformed_1, 4, Indices, 6, 0);
499 ok(hr == D3D_OK, "DrawIndexedPrimitive returned %08x\n", hr);
500
501 /* That makes it use the Z value */
502 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_LINEAR);
503 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
504 /* Untransformed, vertex fog != none (or table fog != none):
505 * Use the Z value as input into the equation
506 */
507 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR,
508 unstransformed_2, 4, Indices, 6, 0);
509 ok(hr == D3D_OK, "DrawIndexedPrimitive returned %08x\n", hr);
510
511 /* transformed verts */
512 ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
513 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
514 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR,
515 transformed_1, 4, Indices, 6, 0);
516 ok(hr == D3D_OK, "DrawIndexedPrimitive returned %08x\n", hr);
517
518 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_LINEAR);
519 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
520 /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
521 * equation
522 */
523 hr = IDirect3DDevice7_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR,
524 transformed_2, 4, Indices, 6, 0);
525 ok(hr == D3D_OK, "DrawIndexedPrimitive returned %08x\n", hr);
526
527 hr = IDirect3DDevice7_EndScene(device);
528 ok(hr == D3D_OK, "EndScene returned %08x\n", hr);
529 }
530 else
531 {
532 ok(FALSE, "BeginScene failed\n");
533 }
534
535 color = getPixelColor(device, 160, 360);
536 ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
537 color = getPixelColor(device, 160, 120);
538 ok(color == 0x0000FF00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
539 color = getPixelColor(device, 480, 120);
540 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
541 if(caps.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_FOGTABLE)
542 {
543 color = getPixelColor(device, 480, 360);
544 ok(color == 0x0000FF00, "Transformed vertex with linear table fog has color %08x\n", color);
545 }
546 else
547 {
548 /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
549 * The settings above result in no fogging with vertex fog
550 */
551 color = getPixelColor(device, 480, 120);
552 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
553 trace("Info: Table fog not supported by this device\n");
554 }
555
556 /* Turn off the fog master switch to avoid confusing other tests */
557 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, FALSE);
558 ok(hr == D3D_OK, "Turning off fog calculations returned %08x\n", hr);
559 }
560
561 static void blt_test(IDirect3DDevice7 *device)
562 {
563 IDirectDrawSurface7 *backbuffer = NULL, *offscreen = NULL;
564 DDSURFACEDESC2 ddsd;
565 HRESULT hr;
566
567 memset(&ddsd, 0, sizeof(ddsd));
568 ddsd.dwSize = sizeof(ddsd);
569 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
570 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
571 ddsd.dwWidth = 640;
572 ddsd.dwHeight = 480;
573 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_3DDEVICE;
574 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &offscreen, NULL);
575 ok(hr == D3D_OK, "Creating the offscreen render target failed, hr = %08x\n", hr);
576
577 /* Offscreen blits with the same source as destination */
578 if(SUCCEEDED(hr))
579 {
580 RECT src_rect, dst_rect;
581
582 /* Blit the whole surface to itself */
583 hr = IDirectDrawSurface_Blt(offscreen, NULL, offscreen, NULL, 0, NULL);
584 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
585
586 /* Overlapped blit */
587 dst_rect.left = 0; dst_rect.right = 480;
588 dst_rect.top = 0; dst_rect.bottom = 480;
589 src_rect.left = 160; src_rect.right = 640;
590 src_rect.top = 0; src_rect.bottom = 480;
591 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, offscreen, &src_rect, 0, NULL);
592 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
593
594 /* Overlapped blit, flip-y through source rectangle (not allowed) */
595 dst_rect.left = 0; dst_rect.right = 480;
596 dst_rect.top = 0; dst_rect.bottom = 480;
597 src_rect.left = 160; src_rect.right = 640;
598 src_rect.top = 480; src_rect.bottom = 0;
599 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, offscreen, &src_rect, 0, NULL);
600 ok(hr == DDERR_INVALIDRECT, "IDirectDrawSurface7_Blt returned %08x\n", hr);
601
602 /* Overlapped blit, with shrinking in x */
603 dst_rect.left = 0; dst_rect.right = 480;
604 dst_rect.top = 0; dst_rect.bottom = 480;
605 src_rect.left = 160; src_rect.right = 480;
606 src_rect.top = 0; src_rect.bottom = 480;
607 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, offscreen, &src_rect, 0, NULL);
608 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
609 }
610
611 hr = IDirect3DDevice7_GetRenderTarget(device, &backbuffer);
612 ok(hr == D3D_OK, "Unable to obtain a surface pointer to the backbuffer, hr = %08x\n", hr);
613
614 /* backbuffer ==> texture blits */
615 if(SUCCEEDED(hr) && offscreen)
616 {
617 RECT src_rect, dst_rect;
618
619 /* backbuffer ==> texture, src_rect=NULL, dst_rect=NULL, no scaling */
620 hr = IDirectDrawSurface_Blt(offscreen, NULL, backbuffer, NULL, 0, NULL);
621 ok(hr == DD_OK, "fullscreen Blt from backbuffer => texture failed with hr = %08x\n", hr);
622
623 /* backbuffer ==> texture, full surface blits, no scaling */
624 dst_rect.left = 0; dst_rect.right = 640;
625 dst_rect.top = 0; dst_rect.bottom = 480;
626 src_rect.left = 0; src_rect.right = 640;
627 src_rect.top = 0; src_rect.bottom = 480;
628 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, backbuffer, &src_rect, 0, NULL);
629 ok(hr == DD_OK, "fullscreen Blt from backbuffer => texture failed with hr = %08x\n", hr);
630
631 /* backbuffer ==> texture, flip in y-direction through source rectangle, no scaling (allowed) */
632 dst_rect.left = 0; dst_rect.right = 640;
633 dst_rect.top = 480; dst_rect.top = 0;
634 src_rect.left = 0; src_rect.right = 640;
635 src_rect.top = 0; src_rect.bottom = 480;
636 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, backbuffer, &src_rect, 0, NULL);
637 ok(hr == DD_OK, "backbuffer => texture flip-y src_rect failed with hr = %08x\n", hr);
638
639 /* backbuffer ==> texture, flip in x-direction through source rectangle, no scaling (not allowed) */
640 dst_rect.left = 640; dst_rect.right = 0;
641 dst_rect.top = 0; dst_rect.top = 480;
642 src_rect.left = 0; src_rect.right = 640;
643 src_rect.top = 0; src_rect.bottom = 480;
644 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, backbuffer, &src_rect, 0, NULL);
645 ok(hr == DDERR_INVALIDRECT, "backbuffer => texture flip-x src_rect failed with hr = %08x\n", hr);
646
647 /* backbuffer ==> texture, flip in y-direction through destination rectangle (not allowed) */
648 dst_rect.left = 0; dst_rect.right = 640;
649 dst_rect.top = 0; dst_rect.top = 480;
650 src_rect.left = 0; src_rect.right = 640;
651 src_rect.top = 480; src_rect.bottom = 0;
652 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, backbuffer, &src_rect, 0, NULL);
653 ok(hr == DDERR_INVALIDRECT, "backbuffer => texture flip-y dst_rect failed with hr = %08x\n", hr);
654
655 /* backbuffer ==> texture, flip in x-direction through destination rectangle, no scaling (not allowed) */
656 dst_rect.left = 0; dst_rect.right = 640;
657 dst_rect.top = 0; dst_rect.top = 480;
658 src_rect.left = 640; src_rect.right = 0;
659 src_rect.top = 0; src_rect.bottom = 480;
660 hr = IDirectDrawSurface_Blt(offscreen, &dst_rect, backbuffer, &src_rect, 0, NULL);
661 ok(hr == DDERR_INVALIDRECT, "backbuffer => texture flip-x dst_rect failed with hr = %08x\n", hr);
662 }
663
664 if(offscreen) IDirectDrawSurface7_Release(offscreen);
665 if(backbuffer) IDirectDrawSurface7_Release(backbuffer);
666 }
667
668 static void offscreen_test(IDirect3DDevice7 *device)
669 {
670 HRESULT hr;
671 IDirectDrawSurface7 *backbuffer = NULL, *offscreen = NULL;
672 DWORD color;
673 DDSURFACEDESC2 ddsd;
674
675 static float quad[][5] = {
676 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
677 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
678 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
679 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
680 };
681
682 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
683 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
684
685 memset(&ddsd, 0, sizeof(ddsd));
686 ddsd.dwSize = sizeof(ddsd);
687 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
688 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
689 ddsd.dwWidth = 128;
690 ddsd.dwHeight = 128;
691 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_3DDEVICE;
692 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &offscreen, NULL);
693 ok(hr == D3D_OK, "Creating the offscreen render target failed, hr = %08x\n", hr);
694 if(!offscreen) {
695 goto out;
696 }
697
698 hr = IDirect3DDevice7_GetRenderTarget(device, &backbuffer);
699 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
700 if(!backbuffer) {
701 goto out;
702 }
703
704 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
705 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
706 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
707 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
708 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_MINFILTER, D3DFILTER_NEAREST);
709 ok(SUCCEEDED(hr), "SetTextureStageState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
710 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_MAGFILTER, D3DFILTER_NEAREST);
711 ok(SUCCEEDED(hr), "SetTextureStageState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
712 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
713 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState returned hr = %08x\n", hr);
714
715 if (refdevice) {
716 win_skip("Tests would crash on W2K with a refdevice\n");
717 goto out;
718 }
719
720 if(IDirect3DDevice7_BeginScene(device) == D3D_OK) {
721 hr = IDirect3DDevice7_SetRenderTarget(device, offscreen, 0);
722 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
723 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
724 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
725
726 /* Draw without textures - Should result in a white quad */
727 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEX1, quad, 4, 0);
728 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
729
730 hr = IDirect3DDevice7_SetRenderTarget(device, backbuffer, 0);
731 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
732 set_the_same_viewport_again(device);
733
734 hr = IDirect3DDevice7_SetTexture(device, 0, offscreen);
735 ok(hr == D3D_OK, "SetTexture failed, %08x\n", hr);
736
737 /* This time with the texture */
738 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEX1, quad, 4, 0);
739 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
740
741 IDirect3DDevice7_EndScene(device);
742 }
743
744 /* Center quad - should be white */
745 color = getPixelColor(device, 320, 240);
746 ok(color == 0x00ffffff, "Offscreen failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
747 /* Some quad in the cleared part of the texture */
748 color = getPixelColor(device, 170, 240);
749 ok(color == 0x00ff00ff, "Offscreen failed: Got color 0x%08x, expected 0x00ff00ff.\n", color);
750 /* Part of the originally cleared back buffer */
751 color = getPixelColor(device, 10, 10);
752 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
753 if(0) {
754 /* Lower left corner of the screen, where back buffer offscreen rendering draws the offscreen texture.
755 * It should be red, but the offscreen texture may leave some junk there. Not tested yet. Depending on
756 * the offscreen rendering mode this test would succeed or fail
757 */
758 color = getPixelColor(device, 10, 470);
759 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
760 }
761
762 out:
763 hr = IDirect3DDevice7_SetTexture(device, 0, NULL);
764 ok(SUCCEEDED(hr), "IDirect3DDevice7_SetTexture returned %#x.\n", hr);
765
766 /* restore things */
767 if(backbuffer) {
768 hr = IDirect3DDevice7_SetRenderTarget(device, backbuffer, 0);
769 ok(SUCCEEDED(hr), "IDirect3DDevice7_SetRenderTarget returned %#x.\n", hr);
770 IDirectDrawSurface7_Release(backbuffer);
771 }
772 if(offscreen) {
773 IDirectDrawSurface7_Release(offscreen);
774 }
775 }
776
777 static void alpha_test(IDirect3DDevice7 *device)
778 {
779 HRESULT hr;
780 IDirectDrawSurface7 *backbuffer = NULL, *offscreen = NULL;
781 DWORD color, red, green, blue;
782 DDSURFACEDESC2 ddsd;
783
784 struct vertex quad1[] =
785 {
786 {-1.0f, -1.0f, 0.1f, 0x4000ff00},
787 {-1.0f, 0.0f, 0.1f, 0x4000ff00},
788 { 1.0f, -1.0f, 0.1f, 0x4000ff00},
789 { 1.0f, 0.0f, 0.1f, 0x4000ff00},
790 };
791 struct vertex quad2[] =
792 {
793 {-1.0f, 0.0f, 0.1f, 0xc00000ff},
794 {-1.0f, 1.0f, 0.1f, 0xc00000ff},
795 { 1.0f, 0.0f, 0.1f, 0xc00000ff},
796 { 1.0f, 1.0f, 0.1f, 0xc00000ff},
797 };
798 static float composite_quad[][5] = {
799 { 0.0f, -1.0f, 0.1f, 0.0f, 1.0f},
800 { 0.0f, 1.0f, 0.1f, 0.0f, 0.0f},
801 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f},
802 { 1.0f, 1.0f, 0.1f, 1.0f, 0.0f},
803 };
804
805 /* Clear the render target with alpha = 0.5 */
806 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
807 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
808
809 memset(&ddsd, 0, sizeof(ddsd));
810 ddsd.dwSize = sizeof(ddsd);
811 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT;
812 ddsd.dwWidth = 128;
813 ddsd.dwHeight = 128;
814 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_3DDEVICE;
815 U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
816 U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 32;
817 U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
818 U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
819 U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x000000ff;
820 U5(U4(ddsd).ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000;
821 hr = IDirectDraw7_CreateSurface(DirectDraw, &ddsd, &offscreen, NULL);
822 ok(hr == D3D_OK, "Creating the offscreen render target failed, hr = %08x\n", hr);
823 if(!offscreen) {
824 goto out;
825 }
826 hr = IDirect3DDevice7_GetRenderTarget(device, &backbuffer);
827 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
828 if(!backbuffer) {
829 goto out;
830 }
831
832 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
833 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
834 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
835 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
836 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_MINFILTER, D3DFILTER_NEAREST);
837 ok(SUCCEEDED(hr), "SetTextureStageState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
838 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_MAGFILTER, D3DFILTER_NEAREST);
839 ok(SUCCEEDED(hr), "SetTextureStageState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
840
841 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, TRUE);
842 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
843
844 if (refdevice) {
845 win_skip("Tests would crash on W2K with a refdevice\n");
846 goto out;
847 }
848
849 if(IDirect3DDevice7_BeginScene(device) == D3D_OK) {
850
851 /* Draw two quads, one with src alpha blending, one with dest alpha blending. The
852 * SRCALPHA / INVSRCALPHA blend doesn't give any surprises. Colors are blended based on
853 * the input alpha
854 *
855 * The DESTALPHA / INVDESTALPHA do not "work" on the regular buffer because there is no alpha.
856 * They give essentially ZERO and ONE blend factors
857 */
858 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
859 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
860 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
861 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
862 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad1, 4, 0);
863 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
864
865 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_DESTALPHA);
866 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
867 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVDESTALPHA);
868 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
869 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad2, 4, 0);
870 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
871
872 /* Switch to the offscreen buffer, and redo the testing. SRCALPHA and DESTALPHA. The offscreen buffer
873 * has a alpha channel on its own. Clear the offscreen buffer with alpha = 0.5 again, then draw the
874 * quads again. The SRCALPHA/INVSRCALPHA doesn't give any surprises, but the DESTALPHA/INVDESTALPHA
875 * blending works as supposed now - blend factor is 0.5 in both cases, not 0.75 as from the input
876 * vertices
877 */
878 hr = IDirect3DDevice7_SetRenderTarget(device, offscreen, 0);
879 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
880 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
881 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
882
883 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA);
884 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
885 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA);
886 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
887 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad1, 4, 0);
888 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
889
890 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_SRCBLEND, D3DBLEND_DESTALPHA);
891 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
892 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVDESTALPHA);
893 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
894 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad2, 4, 0);
895 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
896
897 hr = IDirect3DDevice7_SetRenderTarget(device, backbuffer, 0);
898 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
899 set_the_same_viewport_again(device);
900
901 /* Render the offscreen texture onto the frame buffer to be able to compare it regularly.
902 * Disable alpha blending for the final composition
903 */
904 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
905 ok(hr == D3D_OK, "IDirect3DDevice7_SetRenderState failed, hr = %08x\n", hr);
906
907 hr = IDirect3DDevice7_SetTexture(device, 0, offscreen);
908 ok(hr == D3D_OK, "IDirect3DDevice7_SetTexture failed, hr = %08x\n", hr);
909 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEX1, composite_quad, 4, 0);
910 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
911 hr = IDirect3DDevice7_SetTexture(device, 0, NULL);
912 ok(hr == D3D_OK, "IDirect3DDevice7_SetTexture failed, hr = %08x\n", hr);
913
914 hr = IDirect3DDevice7_EndScene(device);
915 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
916 }
917
918 color = getPixelColor(device, 160, 360);
919 red = (color & 0x00ff0000) >> 16;
920 green = (color & 0x0000ff00) >> 8;
921 blue = (color & 0x000000ff);
922 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
923 "SRCALPHA on frame buffer returned color 0x%08x, expected 0x00bf4000\n", color);
924
925 color = getPixelColor(device, 160, 120);
926 red = (color & 0x00ff0000) >> 16;
927 green = (color & 0x0000ff00) >> 8;
928 blue = (color & 0x000000ff);
929 ok(red == 0x00 && green == 0x00 && blue >= 0xfe && blue <= 0xff ,
930 "DSTALPHA on frame buffer returned color 0x%08x, expected 0x000000ff\n", color);
931
932 color = getPixelColor(device, 480, 360);
933 red = (color & 0x00ff0000) >> 16;
934 green = (color & 0x0000ff00) >> 8;
935 blue = (color & 0x000000ff);
936 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
937 "SRCALPHA on texture returned color 0x%08x, expected 0x00bf4000\n", color);
938
939 color = getPixelColor(device, 480, 120);
940 red = (color & 0x00ff0000) >> 16;
941 green = (color & 0x0000ff00) >> 8;
942 blue = (color & 0x000000ff);
943 ok(red >= 0x7e && red <= 0x81 && green == 0x00 && blue >= 0x7e && blue <= 0x81,
944 "DSTALPHA on texture returned color 0x%08x, expected 0x00800080\n", color);
945
946 out:
947 if(offscreen) IDirectDrawSurface7_Release(offscreen);
948 if(backbuffer) IDirectDrawSurface7_Release(backbuffer);
949 }
950
951 static void rhw_zero_test(IDirect3DDevice7 *device)
952 {
953 /* Test if it will render a quad correctly when vertex rhw = 0 */
954 HRESULT hr;
955 DWORD color;
956
957 struct {
958 float x, y, z;
959 float rhw;
960 DWORD diffuse;
961 } quad1[] =
962 {
963 {0, 100, 0, 0, 0xffffffff},
964 {0, 0, 0, 0, 0xffffffff},
965 {100, 100, 0, 0, 0xffffffff},
966 {100, 0, 0, 0, 0xffffffff},
967 };
968
969 /* Clear to black */
970 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0, 0);
971 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
972
973 hr = IDirect3DDevice7_BeginScene(device);
974 ok(hr == D3D_OK, "IDirect3DDevice7_BeginScene failed with %08x\n", hr);
975
976 if (SUCCEEDED(hr)) {
977 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, quad1, 4, 0);
978 ok(hr == D3D_OK, "DrawPrimitive failed, hr = %08x\n", hr);
979
980 hr = IDirect3DDevice7_EndScene(device);
981 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
982 }
983
984 color = getPixelColor(device, 5, 5);
985 ok(color == 0xffffff ||
986 broken(color == 0), /* VMware */
987 "Got color %08x, expected 00ffffff\n", color);
988
989 color = getPixelColor(device, 105, 105);
990 ok(color == 0, "Got color %08x, expected 00000000\n", color);
991 }
992
993 static BOOL D3D1_createObjects(void)
994 {
995 WNDCLASS wc = {0};
996 HRESULT hr;
997 DDSURFACEDESC ddsd;
998 D3DEXECUTEBUFFERDESC exdesc;
999 D3DVIEWPORT vp_data;
1000
1001 /* An IDirect3DDevice cannot be queryInterfaced from an IDirect3DDevice7 on windows */
1002 hr = DirectDrawCreate(NULL, &DirectDraw1, NULL);
1003
1004 ok(hr==DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreate returned: %x\n", hr);
1005 if (FAILED(hr)) {
1006 return FALSE;
1007 }
1008
1009 wc.lpfnWndProc = DefWindowProc;
1010 wc.lpszClassName = "texturemapblend_test_wc";
1011 RegisterClass(&wc);
1012 window = CreateWindow("texturemapblend_test_wc", "texturemapblend_test", WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
1013
1014 hr = IDirectDraw_SetCooperativeLevel(DirectDraw1, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
1015 ok(hr==DD_OK, "SetCooperativeLevel returned: %x\n", hr);
1016 if(FAILED(hr)) {
1017 return FALSE;
1018 }
1019
1020 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 32);
1021 if(FAILED(hr)) {
1022 /* 24 bit is fine too */
1023 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 24);
1024 }
1025 ok(hr==DD_OK || hr == DDERR_UNSUPPORTED, "SetDisplayMode returned: %x\n", hr);
1026 if (FAILED(hr)) {
1027 return FALSE;
1028 }
1029
1030 hr = IDirectDraw_QueryInterface(DirectDraw1, &IID_IDirect3D, (void**) &Direct3D1);
1031 ok(hr==DD_OK, "QueryInterface returned: %x\n", hr);
1032 if (FAILED(hr)) {
1033 return FALSE;
1034 }
1035
1036 memset(&ddsd, 0, sizeof(ddsd));
1037 ddsd.dwSize = sizeof(ddsd);
1038 ddsd.dwFlags = DDSD_CAPS;
1039 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;
1040 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &Surface1, NULL);
1041 ok(hr==DD_OK, "CreateSurface returned: %x\n", hr);
1042 if (FAILED(hr)) {
1043 return FALSE;
1044 }
1045
1046 hr = IDirectDrawSurface_QueryInterface(Surface1, &IID_IDirect3DHALDevice, (void **) &Direct3DDevice1);
1047 if(FAILED(hr)) {
1048 trace("Creating a HAL device failed, trying Ref\n");
1049 hr = IDirectDrawSurface_QueryInterface(Surface1, &IID_IDirect3DRefDevice, (void **) &Direct3DDevice1);
1050 }
1051 ok(hr==D3D_OK, "Creating 3D device returned: %x\n", hr);
1052 if(FAILED(hr)) {
1053 return FALSE;
1054 }
1055
1056 hr = IDirect3D_CreateViewport(Direct3D1, &Viewport, NULL);
1057 ok(hr == D3D_OK, "IDirect3D_CreateViewport failed: %08x\n", hr);
1058 if (FAILED(hr)) {
1059 return FALSE;
1060 }
1061
1062 hr = IDirect3DViewport_Initialize(Viewport, Direct3D1);
1063 ok(hr == D3D_OK || hr == DDERR_ALREADYINITIALIZED, "IDirect3DViewport_Initialize returned %08x\n", hr);
1064 hr = IDirect3DDevice_AddViewport(Direct3DDevice1, Viewport);
1065 ok(hr == D3D_OK, "IDirect3DDevice_AddViewport returned %08x\n", hr);
1066 vp_data.dwSize = sizeof(vp_data);
1067 vp_data.dwX = 0;
1068 vp_data.dwY = 0;
1069 vp_data.dwWidth = 640;
1070 vp_data.dwHeight = 480;
1071 vp_data.dvScaleX = 1;
1072 vp_data.dvScaleY = 1;
1073 vp_data.dvMaxX = 640;
1074 vp_data.dvMaxY = 480;
1075 vp_data.dvMinZ = 0;
1076 vp_data.dvMaxZ = 1;
1077 hr = IDirect3DViewport_SetViewport(Viewport, &vp_data);
1078 ok(hr == D3D_OK, "IDirect3DViewport_SetViewport returned %08x\n", hr);
1079
1080 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1081 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1082 exdesc.dwFlags = D3DDEB_BUFSIZE | D3DDEB_CAPS;
1083 exdesc.dwBufferSize = 512;
1084 exdesc.dwCaps = D3DDEBCAPS_SYSTEMMEMORY;
1085 hr = IDirect3DDevice_CreateExecuteBuffer(Direct3DDevice1, &exdesc, &ExecuteBuffer, NULL);
1086 ok(hr == D3D_OK, "IDirect3DDevice_CreateExecuteBuffer failed with %08x\n", hr);
1087 if (FAILED(hr)) {
1088 return FALSE;
1089 }
1090
1091 return TRUE;
1092 }
1093
1094 static void D3D1_releaseObjects(void)
1095 {
1096 if(ExecuteBuffer) IDirect3DExecuteBuffer_Release(ExecuteBuffer);
1097 if(Surface1) IDirectDrawSurface_Release(Surface1);
1098 if(Viewport) IDirect3DViewport_Release(Viewport);
1099 if(Direct3DDevice1) IDirect3DDevice_Release(Direct3DDevice1);
1100 if(Direct3D1) IDirect3D_Release(Direct3D1);
1101 if(DirectDraw1) IDirectDraw_Release(DirectDraw1);
1102 if(window) DestroyWindow(window);
1103 }
1104
1105 static DWORD D3D1_getPixelColor(IDirectDraw *DirectDraw1, IDirectDrawSurface *Surface, UINT x, UINT y)
1106 {
1107 DWORD ret;
1108 HRESULT hr;
1109 DDSURFACEDESC ddsd;
1110 RECT rectToLock = {x, y, x+1, y+1};
1111 IDirectDrawSurface *surf = NULL;
1112
1113 /* Some implementations seem to dislike direct locking on the front buffer. Thus copy the front buffer
1114 * to an offscreen surface and lock it instead of the front buffer
1115 */
1116 memset(&ddsd, 0, sizeof(ddsd));
1117 ddsd.dwSize = sizeof(ddsd);
1118 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1119 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
1120 ddsd.dwWidth = 640;
1121 ddsd.dwHeight = 480;
1122 ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
1123 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &surf, NULL);
1124 ok(hr == DD_OK, "IDirectDraw_CreateSurface failed with %08x\n", hr);
1125 if(!surf)
1126 {
1127 trace("cannot create helper surface\n");
1128 return 0xdeadbeef;
1129 }
1130
1131 memset(&ddsd, 0, sizeof(ddsd));
1132 ddsd.dwSize = sizeof(ddsd);
1133 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1134
1135 hr = IDirectDrawSurface_BltFast(surf, 0, 0, Surface, NULL, 0);
1136 ok(hr == DD_OK, "IDirectDrawSurface_BltFast returned %08x\n", hr);
1137 if(FAILED(hr))
1138 {
1139 trace("Cannot blit\n");
1140 ret = 0xdeadbee;
1141 goto out;
1142 }
1143
1144 hr = IDirectDrawSurface_Lock(surf, &rectToLock, &ddsd, DDLOCK_READONLY | DDLOCK_WAIT, NULL);
1145 if(FAILED(hr))
1146 {
1147 trace("Can't lock the offscreen surface, hr=%08x\n", hr);
1148 ret = 0xdeadbeec;
1149 goto out;
1150 }
1151
1152 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
1153 * really important for these tests
1154 */
1155 ret = ((DWORD *) ddsd.lpSurface)[0] & 0x00ffffff;
1156 hr = IDirectDrawSurface_Unlock(surf, NULL);
1157 if(FAILED(hr))
1158 {
1159 trace("Can't unlock the offscreen surface, hr=%08x\n", hr);
1160 }
1161
1162 out:
1163 IDirectDrawSurface_Release(surf);
1164 return ret;
1165 }
1166
1167 #define EXEBUF_START_RENDER_STATES(count, ptr) do {\
1168 ((D3DINSTRUCTION*)(ptr))->bOpcode = D3DOP_STATERENDER;\
1169 ((D3DINSTRUCTION*)(ptr))->bSize = sizeof(D3DSTATE);\
1170 ((D3DINSTRUCTION*)(ptr))->wCount = count;\
1171 ptr = ((D3DINSTRUCTION*)(ptr))+1; } while (0)
1172
1173 #define EXEBUF_PUT_RENDER_STATE(state, value, ptr) do {\
1174 U1(*((D3DSTATE*)(ptr))).drstRenderStateType = state; \
1175 U2(*((D3DSTATE*)(ptr))).dwArg[0] = value; \
1176 ptr = ((D3DSTATE*)(ptr))+1; } while (0)
1177
1178 #define EXEBUF_PUT_PROCESSVERTICES(nvertices, ptr) do {\
1179 ((D3DINSTRUCTION*)(ptr))->bOpcode = D3DOP_PROCESSVERTICES;\
1180 ((D3DINSTRUCTION*)(ptr))->bSize = sizeof(D3DPROCESSVERTICES);\
1181 ((D3DINSTRUCTION*)(ptr))->wCount = 1;\
1182 ptr = ((D3DINSTRUCTION*)(ptr))+1;\
1183 ((D3DPROCESSVERTICES*)(ptr))->dwFlags = D3DPROCESSVERTICES_COPY;\
1184 ((D3DPROCESSVERTICES*)(ptr))->wStart = 0;\
1185 ((D3DPROCESSVERTICES*)(ptr))->wDest = 0;\
1186 ((D3DPROCESSVERTICES*)(ptr))->dwCount = nvertices;\
1187 ((D3DPROCESSVERTICES*)(ptr))->dwReserved = 0;\
1188 ptr = ((D3DPROCESSVERTICES*)(ptr))+1; } while (0)
1189
1190 #define EXEBUF_END(ptr) do {\
1191 ((D3DINSTRUCTION*)(ptr))->bOpcode = D3DOP_EXIT;\
1192 ((D3DINSTRUCTION*)(ptr))->bSize = 0;\
1193 ((D3DINSTRUCTION*)(ptr))->wCount = 0;\
1194 ptr = ((D3DINSTRUCTION*)(ptr))+1; } while (0)
1195
1196 #define EXEBUF_PUT_QUAD(base_idx, ptr) do {\
1197 ((D3DINSTRUCTION*)(ptr))->bOpcode = D3DOP_TRIANGLE;\
1198 ((D3DINSTRUCTION*)(ptr))->bSize = sizeof(D3DTRIANGLE);\
1199 ((D3DINSTRUCTION*)(ptr))->wCount = 2;\
1200 ptr = ((D3DINSTRUCTION*)(ptr))+1;\
1201 U1(*((D3DTRIANGLE*)(ptr))).v1 = base_idx;\
1202 U2(*((D3DTRIANGLE*)(ptr))).v2 = (base_idx) + 1; \
1203 U3(*((D3DTRIANGLE*)(ptr))).v3 = (base_idx) + 3; \
1204 ((D3DTRIANGLE*)(ptr))->wFlags = 0;\
1205 ptr = ((D3DTRIANGLE*)ptr)+1;\
1206 U1(*((D3DTRIANGLE*)(ptr))).v1 = (base_idx) + 1; \
1207 U2(*((D3DTRIANGLE*)(ptr))).v2 = (base_idx) + 2; \
1208 U3(*((D3DTRIANGLE*)(ptr))).v3 = (base_idx) + 3; \
1209 ((D3DTRIANGLE*)(ptr))->wFlags = 0;\
1210 ptr = ((D3DTRIANGLE*)(ptr))+1;\
1211 } while (0)
1212
1213 static HRESULT CALLBACK TextureFormatEnumCallback(LPDDSURFACEDESC lpDDSD, LPVOID lpContext)
1214 {
1215 if (lpDDSD->ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
1216 *(BOOL*)lpContext = TRUE;
1217 }
1218
1219 return DDENUMRET_OK;
1220 }
1221
1222 static void D3D1_TextureMapBlendTest(void)
1223 {
1224 HRESULT hr;
1225 DDSURFACEDESC ddsd;
1226 D3DEXECUTEBUFFERDESC exdesc;
1227 D3DEXECUTEDATA exdata;
1228 DDBLTFX ddbltfx;
1229 RECT rect = { 0, 0, 64, 128 };
1230 DWORD color, red, blue, green;
1231 void *exe_buffer_ptr;
1232 DWORD exe_length;
1233 D3DTEXTUREHANDLE htex;
1234 DDCOLORKEY clrKey;
1235 IDirectDrawSurface *TexSurface = NULL;
1236 IDirect3DTexture *Texture = NULL;
1237 IDirectDrawPalette *Palette = NULL;
1238 PALETTEENTRY table1[256];
1239 BOOL p8_textures_supported = FALSE;
1240
1241 struct {
1242 float x, y, z;
1243 float rhw;
1244 DWORD diffuse;
1245 DWORD specular;
1246 float tu, tv;
1247 } test1_quads[] =
1248 {
1249 {0.0f, 0.0f, 0.0f, 1.0f, 0xffffffff, 0, 0.0f, 0.0f},
1250 {640.0f, 0.0f, 0.0f, 1.0f, 0xffffffff, 0, 1.0f, 0.0f},
1251 {640.0f, 240.0f, 0.0f, 1.0f, 0xffffffff, 0, 1.0f, 1.0f},
1252 {0.0f, 240.0f, 0.0f, 1.0f, 0xffffffff, 0, 0.0f, 1.0f},
1253 {0.0f, 240.0f, 0.0f, 1.0f, 0x80ffffff, 0, 0.0f, 0.0f},
1254 {640.0f, 240.0f, 0.0f, 1.0f, 0x80ffffff, 0, 1.0f, 0.0f},
1255 {640.0f, 480.0f, 0.0f, 1.0f, 0x80ffffff, 0, 1.0f, 1.0f},
1256 {0.0f, 480.0f, 0.0f, 1.0f, 0x80ffffff, 0, 0.0f, 1.0f}
1257 }, test2_quads[] =
1258 {
1259 {0.0f, 0.0f, 0.0f, 1.0f, 0x00ff0080, 0, 0.0f, 0.0f},
1260 {640.0f, 0.0f, 0.0f, 1.0f, 0x00ff0080, 0, 1.0f, 0.0f},
1261 {640.0f, 240.0f, 0.0f, 1.0f, 0x00ff0080, 0, 1.0f, 1.0f},
1262 {0.0f, 240.0f, 0.0f, 1.0f, 0x00ff0080, 0, 0.0f, 1.0f},
1263 {0.0f, 240.0f, 0.0f, 1.0f, 0x008000ff, 0, 0.0f, 0.0f},
1264 {640.0f, 240.0f, 0.0f, 1.0f, 0x008000ff, 0, 1.0f, 0.0f},
1265 {640.0f, 480.0f, 0.0f, 1.0f, 0x008000ff, 0, 1.0f, 1.0f},
1266 {0.0f, 480.0f, 0.0f, 1.0f, 0x008000ff, 0, 0.0f, 1.0f}
1267 };
1268
1269 /* 1) Test alpha with DDPF_ALPHAPIXELS texture - should be taken from texture alpha channel*/
1270 memset (&ddsd, 0, sizeof (ddsd));
1271 ddsd.dwSize = sizeof (ddsd);
1272 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1273 ddsd.dwHeight = 128;
1274 ddsd.dwWidth = 128;
1275 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1276 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1277 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
1278 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
1279 U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1280 U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1281 U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff;
1282 U5(ddsd.ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000;
1283 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &TexSurface, NULL);
1284 ok(hr==D3D_OK, "CreateSurface returned: %x\n", hr);
1285 if (FAILED(hr)) {
1286 skip("IDirectDraw_CreateSurface failed; skipping further tests\n");
1287 goto out;
1288 }
1289
1290 hr = IDirectDrawSurface_QueryInterface(TexSurface, &IID_IDirect3DTexture,
1291 (void *)&Texture);
1292 ok(hr==D3D_OK, "IDirectDrawSurface_QueryInterface returned: %x\n", hr);
1293 if (FAILED(hr)) {
1294 skip("Can't get IDirect3DTexture interface; skipping further tests\n");
1295 goto out;
1296 }
1297
1298 memset(&ddbltfx, 0, sizeof(ddbltfx));
1299 ddbltfx.dwSize = sizeof(ddbltfx);
1300 U5(ddbltfx).dwFillColor = 0;
1301 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1302 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1303
1304 U5(ddbltfx).dwFillColor = 0xff0000ff;
1305 hr = IDirectDrawSurface_Blt(TexSurface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1306 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1307 U5(ddbltfx).dwFillColor = 0x800000ff;
1308 hr = IDirectDrawSurface_Blt(TexSurface, &rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1309 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1310
1311 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1312 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1313 hr = IDirect3DExecuteBuffer_Lock(ExecuteBuffer, &exdesc);
1314 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_Lock failed with %08x\n", hr);
1315 if (FAILED(hr)) {
1316 skip("IDirect3DExecuteBuffer_Lock failed; skipping further tests\n");
1317 goto out;
1318 }
1319
1320 memcpy(exdesc.lpData, test1_quads, sizeof(test1_quads));
1321
1322 exe_buffer_ptr = 256 + (char*)exdesc.lpData;
1323
1324 EXEBUF_PUT_PROCESSVERTICES(8, exe_buffer_ptr);
1325
1326 EXEBUF_START_RENDER_STATES(12, exe_buffer_ptr);
1327 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE, exe_buffer_ptr);
1328 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_ZENABLE, FALSE, exe_buffer_ptr);
1329 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_FOGENABLE, FALSE, exe_buffer_ptr);
1330 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_SPECULARENABLE, FALSE, exe_buffer_ptr);
1331 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREMAG, D3DFILTER_NEAREST, exe_buffer_ptr);
1332 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREMIN, D3DFILTER_NEAREST, exe_buffer_ptr);
1333 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_FILLMODE , D3DFILL_SOLID, exe_buffer_ptr);
1334 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_SRCBLEND, D3DBLEND_SRCALPHA, exe_buffer_ptr);
1335 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_DESTBLEND, D3DBLEND_INVSRCALPHA, exe_buffer_ptr);
1336 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE, exe_buffer_ptr);
1337 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREMAPBLEND, D3DTBLEND_MODULATE, exe_buffer_ptr);
1338 hr = IDirect3DTexture_GetHandle(Texture, Direct3DDevice1, &htex);
1339 ok(hr == D3D_OK, "IDirect3DTexture_GetHandle failed with %08x\n", hr);
1340 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREHANDLE, htex, exe_buffer_ptr);
1341
1342 EXEBUF_PUT_QUAD(0, exe_buffer_ptr);
1343 EXEBUF_PUT_QUAD(4, exe_buffer_ptr);
1344
1345 EXEBUF_END(exe_buffer_ptr);
1346
1347 exe_length = ((char*)exe_buffer_ptr - (char*)exdesc.lpData) - 256;
1348
1349 hr = IDirect3DExecuteBuffer_Unlock(ExecuteBuffer);
1350 if (FAILED(hr)) {
1351 trace("IDirect3DExecuteBuffer_Unlock failed with %08x\n", hr);
1352 }
1353
1354 memset(&exdata, 0, sizeof(D3DEXECUTEDATA));
1355 exdata.dwSize = sizeof(D3DEXECUTEDATA);
1356 exdata.dwVertexCount = 8;
1357 exdata.dwInstructionOffset = 256;
1358 exdata.dwInstructionLength = exe_length;
1359 hr = IDirect3DExecuteBuffer_SetExecuteData(ExecuteBuffer, &exdata);
1360 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_SetExecuteData failed with %08x\n", hr);
1361
1362 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1363 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1364
1365 if (SUCCEEDED(hr)) {
1366 hr = IDirect3DDevice_Execute(Direct3DDevice1, ExecuteBuffer, Viewport, D3DEXECUTE_UNCLIPPED);
1367 ok(hr == D3D_OK, "IDirect3DDevice_Execute failed, hr = %08x\n", hr);
1368 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1369 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1370 }
1371
1372 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1373 red = (color & 0x00ff0000) >> 16;
1374 green = (color & 0x0000ff00) >> 8;
1375 blue = (color & 0x000000ff);
1376 ok(red == 0 && green == 0 && blue >= 0x7e && blue <= 0x82, "Got color %08x, expected 00000080 or near\n", color);
1377
1378 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 5);
1379 red = (color & 0x00ff0000) >> 16;
1380 green = (color & 0x0000ff00) >> 8;
1381 blue = (color & 0x000000ff);
1382 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff or near\n", color);
1383
1384 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 245);
1385 red = (color & 0x00ff0000) >> 16;
1386 green = (color & 0x0000ff00) >> 8;
1387 blue = (color & 0x000000ff);
1388 ok(red == 0 && green == 0 && blue >= 0x7e && blue <= 0x82, "Got color %08x, expected 00000080 or near\n", color);
1389
1390 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 245);
1391 red = (color & 0x00ff0000) >> 16;
1392 green = (color & 0x0000ff00) >> 8;
1393 blue = (color & 0x000000ff);
1394 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff or near\n", color);
1395
1396 /* 2) Test alpha with texture that has no alpha channel - alpha should be taken from diffuse color */
1397 if(Texture) IDirect3DTexture_Release(Texture);
1398 Texture = NULL;
1399 if(TexSurface) IDirectDrawSurface_Release(TexSurface);
1400 TexSurface = NULL;
1401
1402 memset (&ddsd, 0, sizeof (ddsd));
1403 ddsd.dwSize = sizeof (ddsd);
1404 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1405 ddsd.dwHeight = 128;
1406 ddsd.dwWidth = 128;
1407 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1408 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1409 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
1410 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
1411 U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1412 U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1413 U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff;
1414
1415 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &TexSurface, NULL);
1416 ok(hr==D3D_OK, "CreateSurface returned: %x\n", hr);
1417 if (FAILED(hr)) {
1418 skip("IDirectDraw_CreateSurface failed; skipping further tests\n");
1419 goto out;
1420 }
1421
1422 hr = IDirectDrawSurface_QueryInterface(TexSurface, &IID_IDirect3DTexture,
1423 (void *)&Texture);
1424 ok(hr==D3D_OK, "IDirectDrawSurface_QueryInterface returned: %x\n", hr);
1425 if (FAILED(hr)) {
1426 skip("Can't get IDirect3DTexture interface; skipping further tests\n");
1427 goto out;
1428 }
1429
1430 memset(&ddbltfx, 0, sizeof(ddbltfx));
1431 ddbltfx.dwSize = sizeof(ddbltfx);
1432 U5(ddbltfx).dwFillColor = 0;
1433 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1434 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1435
1436 U5(ddbltfx).dwFillColor = 0xff0000ff;
1437 hr = IDirectDrawSurface_Blt(TexSurface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1438 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1439 U5(ddbltfx).dwFillColor = 0x800000ff;
1440 hr = IDirectDrawSurface_Blt(TexSurface, &rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1441 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1442
1443 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1444 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1445 hr = IDirect3DExecuteBuffer_Lock(ExecuteBuffer, &exdesc);
1446 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_Lock failed with %08x\n", hr);
1447 if (FAILED(hr)) {
1448 skip("IDirect3DExecuteBuffer_Lock failed; skipping further tests\n");
1449 goto out;
1450 }
1451
1452 memcpy(exdesc.lpData, test1_quads, sizeof(test1_quads));
1453
1454 exe_buffer_ptr = 256 + (char*)exdesc.lpData;
1455
1456 EXEBUF_PUT_PROCESSVERTICES(8, exe_buffer_ptr);
1457
1458 EXEBUF_START_RENDER_STATES(1, exe_buffer_ptr);
1459 hr = IDirect3DTexture_GetHandle(Texture, Direct3DDevice1, &htex);
1460 ok(hr == D3D_OK, "IDirect3DTexture_GetHandle failed with %08x\n", hr);
1461 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREHANDLE, htex, exe_buffer_ptr);
1462
1463 EXEBUF_PUT_QUAD(0, exe_buffer_ptr);
1464 EXEBUF_PUT_QUAD(4, exe_buffer_ptr);
1465
1466 EXEBUF_END(exe_buffer_ptr);
1467
1468 exe_length = ((char*)exe_buffer_ptr - (char*)exdesc.lpData) - 256;
1469
1470 hr = IDirect3DExecuteBuffer_Unlock(ExecuteBuffer);
1471 if (FAILED(hr)) {
1472 trace("IDirect3DExecuteBuffer_Unlock failed with %08x\n", hr);
1473 }
1474
1475 memset(&exdata, 0, sizeof(D3DEXECUTEDATA));
1476 exdata.dwSize = sizeof(D3DEXECUTEDATA);
1477 exdata.dwVertexCount = 8;
1478 exdata.dwInstructionOffset = 256;
1479 exdata.dwInstructionLength = exe_length;
1480 hr = IDirect3DExecuteBuffer_SetExecuteData(ExecuteBuffer, &exdata);
1481 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_SetExecuteData failed with %08x\n", hr);
1482
1483 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1484 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1485
1486 if (SUCCEEDED(hr)) {
1487 hr = IDirect3DDevice_Execute(Direct3DDevice1, ExecuteBuffer, Viewport, D3DEXECUTE_UNCLIPPED);
1488 ok(hr == D3D_OK, "IDirect3DDevice_Execute failed, hr = %08x\n", hr);
1489 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1490 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1491 }
1492
1493 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1494 red = (color & 0x00ff0000) >> 16;
1495 green = (color & 0x0000ff00) >> 8;
1496 blue = (color & 0x000000ff);
1497 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff or near\n", color);
1498
1499 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 5);
1500 red = (color & 0x00ff0000) >> 16;
1501 green = (color & 0x0000ff00) >> 8;
1502 blue = (color & 0x000000ff);
1503 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff or near\n", color);
1504
1505 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 245);
1506 red = (color & 0x00ff0000) >> 16;
1507 green = (color & 0x0000ff00) >> 8;
1508 blue = (color & 0x000000ff);
1509 ok(red == 0 && green == 0 && blue >= 0x7e && blue <= 0x82, "Got color %08x, expected 00000080 or near\n", color);
1510
1511 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 245);
1512 red = (color & 0x00ff0000) >> 16;
1513 green = (color & 0x0000ff00) >> 8;
1514 blue = (color & 0x000000ff);
1515 ok(red == 0 && green == 0 && blue >= 0x7e && blue <= 0x82, "Got color %08x, expected 00000080 or near\n", color);
1516
1517 /* 3) Test RGB - should multiply color components from diffuse color and texture */
1518 if(Texture) IDirect3DTexture_Release(Texture);
1519 Texture = NULL;
1520 if(TexSurface) IDirectDrawSurface_Release(TexSurface);
1521 TexSurface = NULL;
1522
1523 memset (&ddsd, 0, sizeof (ddsd));
1524 ddsd.dwSize = sizeof (ddsd);
1525 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1526 ddsd.dwHeight = 128;
1527 ddsd.dwWidth = 128;
1528 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1529 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1530 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS;
1531 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
1532 U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
1533 U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
1534 U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff;
1535 U5(ddsd.ddpfPixelFormat).dwRGBAlphaBitMask = 0xff000000;
1536 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &TexSurface, NULL);
1537 ok(hr==D3D_OK, "CreateSurface returned: %x\n", hr);
1538 if (FAILED(hr)) {
1539 skip("IDirectDraw_CreateSurface failed; skipping further tests\n");
1540 goto out;
1541 }
1542
1543 hr = IDirectDrawSurface_QueryInterface(TexSurface, &IID_IDirect3DTexture,
1544 (void *)&Texture);
1545 ok(hr==D3D_OK, "IDirectDrawSurface_QueryInterface returned: %x\n", hr);
1546 if (FAILED(hr)) {
1547 skip("Can't get IDirect3DTexture interface; skipping further tests\n");
1548 goto out;
1549 }
1550
1551 memset(&ddbltfx, 0, sizeof(ddbltfx));
1552 ddbltfx.dwSize = sizeof(ddbltfx);
1553 U5(ddbltfx).dwFillColor = 0;
1554 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1555 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1556
1557 U5(ddbltfx).dwFillColor = 0x00ffffff;
1558 hr = IDirectDrawSurface_Blt(TexSurface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1559 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1560 U5(ddbltfx).dwFillColor = 0x00ffff80;
1561 hr = IDirectDrawSurface_Blt(TexSurface, &rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1562 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1563
1564 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1565 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1566 hr = IDirect3DExecuteBuffer_Lock(ExecuteBuffer, &exdesc);
1567 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_Lock failed with %08x\n", hr);
1568 if (FAILED(hr)) {
1569 skip("IDirect3DExecuteBuffer_Lock failed; skipping further tests\n");
1570 goto out;
1571 }
1572
1573 memcpy(exdesc.lpData, test2_quads, sizeof(test2_quads));
1574
1575 exe_buffer_ptr = 256 + (char*)exdesc.lpData;
1576
1577 EXEBUF_PUT_PROCESSVERTICES(8, exe_buffer_ptr);
1578
1579 EXEBUF_START_RENDER_STATES(2, exe_buffer_ptr);
1580 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_ALPHABLENDENABLE, FALSE, exe_buffer_ptr);
1581 hr = IDirect3DTexture_GetHandle(Texture, Direct3DDevice1, &htex);
1582 ok(hr == D3D_OK, "IDirect3DTexture_GetHandle failed with %08x\n", hr);
1583 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREHANDLE, htex, exe_buffer_ptr);
1584
1585 EXEBUF_PUT_QUAD(0, exe_buffer_ptr);
1586 EXEBUF_PUT_QUAD(4, exe_buffer_ptr);
1587
1588 EXEBUF_END(exe_buffer_ptr);
1589
1590 exe_length = ((char*)exe_buffer_ptr - (char*)exdesc.lpData) - 256;
1591
1592 hr = IDirect3DExecuteBuffer_Unlock(ExecuteBuffer);
1593 if (FAILED(hr)) {
1594 trace("IDirect3DExecuteBuffer_Unlock failed with %08x\n", hr);
1595 }
1596
1597 memset(&exdata, 0, sizeof(D3DEXECUTEDATA));
1598 exdata.dwSize = sizeof(D3DEXECUTEDATA);
1599 exdata.dwVertexCount = 8;
1600 exdata.dwInstructionOffset = 256;
1601 exdata.dwInstructionLength = exe_length;
1602 hr = IDirect3DExecuteBuffer_SetExecuteData(ExecuteBuffer, &exdata);
1603 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_SetExecuteData failed with %08x\n", hr);
1604
1605 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1606 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1607
1608 if (SUCCEEDED(hr)) {
1609 hr = IDirect3DDevice_Execute(Direct3DDevice1, ExecuteBuffer, Viewport, D3DEXECUTE_UNCLIPPED);
1610 ok(hr == D3D_OK, "IDirect3DDevice_Execute failed, hr = %08x\n", hr);
1611 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1612 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1613 }
1614
1615 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1616 red = (color & 0x00ff0000) >> 16;
1617 green = (color & 0x0000ff00) >> 8;
1618 blue = (color & 0x000000ff);
1619 ok(red == 0xff && green == 0 && blue >= 0x3e && blue <= 0x42, "Got color %08x, expected 00ff0040 or near\n", color);
1620
1621 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 5);
1622 red = (color & 0x00ff0000) >> 16;
1623 green = (color & 0x0000ff00) >> 8;
1624 blue = (color & 0x000000ff);
1625 ok(red == 0xff && green == 0 && blue == 0x80, "Got color %08x, expected 00ff0080 or near\n", color);
1626
1627 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 245);
1628 red = (color & 0x00ff0000) >> 16;
1629 green = (color & 0x0000ff00) >> 8;
1630 blue = (color & 0x000000ff);
1631 ok(red >= 0x7e && red <= 0x82 && green == 0 && blue == 0x80, "Got color %08x, expected 00800080 or near\n", color);
1632
1633 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 245);
1634 red = (color & 0x00ff0000) >> 16;
1635 green = (color & 0x0000ff00) >> 8;
1636 blue = (color & 0x000000ff);
1637 ok(red >= 0x7e && red <= 0x82 && green == 0 && blue == 0xff, "Got color %08x, expected 008000ff or near\n", color);
1638
1639 /* 4) Test alpha again, now with color keyed texture (colorkey emulation in wine can interfere) */
1640 if(Texture) IDirect3DTexture_Release(Texture);
1641 Texture = NULL;
1642 if(TexSurface) IDirectDrawSurface_Release(TexSurface);
1643 TexSurface = NULL;
1644
1645 memset (&ddsd, 0, sizeof (ddsd));
1646 ddsd.dwSize = sizeof (ddsd);
1647 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1648 ddsd.dwHeight = 128;
1649 ddsd.dwWidth = 128;
1650 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1651 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1652 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
1653 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 16;
1654 U2(ddsd.ddpfPixelFormat).dwRBitMask = 0xf800;
1655 U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x07e0;
1656 U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x001f;
1657
1658 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &TexSurface, NULL);
1659 ok(hr==D3D_OK, "CreateSurface returned: %x\n", hr);
1660 if (FAILED(hr)) {
1661 skip("IDirectDraw_CreateSurface failed; skipping further tests\n");
1662 goto out;
1663 }
1664
1665 hr = IDirectDrawSurface_QueryInterface(TexSurface, &IID_IDirect3DTexture,
1666 (void *)&Texture);
1667 ok(hr==D3D_OK, "IDirectDrawSurface_QueryInterface returned: %x\n", hr);
1668 if (FAILED(hr)) {
1669 skip("Can't get IDirect3DTexture interface; skipping further tests\n");
1670 goto out;
1671 }
1672
1673 memset(&ddbltfx, 0, sizeof(ddbltfx));
1674 ddbltfx.dwSize = sizeof(ddbltfx);
1675 U5(ddbltfx).dwFillColor = 0;
1676 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1677 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1678 U5(ddbltfx).dwFillColor = 0xf800;
1679 hr = IDirectDrawSurface_Blt(TexSurface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1680 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1681 U5(ddbltfx).dwFillColor = 0x001f;
1682 hr = IDirectDrawSurface_Blt(TexSurface, &rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1683 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1684
1685 clrKey.dwColorSpaceLowValue = 0x001f;
1686 clrKey.dwColorSpaceHighValue = 0x001f;
1687 hr = IDirectDrawSurface_SetColorKey(TexSurface, DDCKEY_SRCBLT, &clrKey);
1688 ok(hr==D3D_OK, "IDirectDrawSurfac_SetColorKey returned: %x\n", hr);
1689
1690 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1691 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1692 hr = IDirect3DExecuteBuffer_Lock(ExecuteBuffer, &exdesc);
1693 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_Lock failed with %08x\n", hr);
1694 if (FAILED(hr)) {
1695 skip("IDirect3DExecuteBuffer_Lock failed; skipping further tests\n");
1696 goto out;
1697 }
1698
1699 memcpy(exdesc.lpData, test1_quads, sizeof(test1_quads));
1700
1701 exe_buffer_ptr = 256 + (char*)exdesc.lpData;
1702
1703 EXEBUF_PUT_PROCESSVERTICES(8, exe_buffer_ptr);
1704
1705 EXEBUF_START_RENDER_STATES(2, exe_buffer_ptr);
1706 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE, exe_buffer_ptr);
1707 hr = IDirect3DTexture_GetHandle(Texture, Direct3DDevice1, &htex);
1708 ok(hr == D3D_OK, "IDirect3DTexture_GetHandle failed with %08x\n", hr);
1709 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREHANDLE, htex, exe_buffer_ptr);
1710
1711 EXEBUF_PUT_QUAD(0, exe_buffer_ptr);
1712 EXEBUF_PUT_QUAD(4, exe_buffer_ptr);
1713
1714 EXEBUF_END(exe_buffer_ptr);
1715
1716 exe_length = ((char*)exe_buffer_ptr - (char*)exdesc.lpData) - 256;
1717
1718 hr = IDirect3DExecuteBuffer_Unlock(ExecuteBuffer);
1719 if (FAILED(hr)) {
1720 trace("IDirect3DExecuteBuffer_Unlock failed with %08x\n", hr);
1721 }
1722
1723 memset(&exdata, 0, sizeof(D3DEXECUTEDATA));
1724 exdata.dwSize = sizeof(D3DEXECUTEDATA);
1725 exdata.dwVertexCount = 8;
1726 exdata.dwInstructionOffset = 256;
1727 exdata.dwInstructionLength = exe_length;
1728 hr = IDirect3DExecuteBuffer_SetExecuteData(ExecuteBuffer, &exdata);
1729 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_SetExecuteData failed with %08x\n", hr);
1730
1731 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1732 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1733
1734 if (SUCCEEDED(hr)) {
1735 hr = IDirect3DDevice_Execute(Direct3DDevice1, ExecuteBuffer, Viewport, D3DEXECUTE_UNCLIPPED);
1736 ok(hr == D3D_OK, "IDirect3DDevice_Execute failed, hr = %08x\n", hr);
1737 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1738 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1739 }
1740
1741 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1742 ok(color == 0, "Got color %08x, expected 00000000\n", color);
1743
1744 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 5);
1745 red = (color & 0x00ff0000) >> 16;
1746 green = (color & 0x0000ff00) >> 8;
1747 blue = (color & 0x000000ff);
1748 ok(red == 0xff && green == 0 && blue == 0, "Got color %08x, expected 00ff0000 or near\n", color);
1749
1750 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 245);
1751 ok(color == 0, "Got color %08x, expected 00000000\n", color);
1752
1753 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 245);
1754 red = (color & 0x00ff0000) >> 16;
1755 green = (color & 0x0000ff00) >> 8;
1756 blue = (color & 0x000000ff);
1757 ok(red >= 0x7e && red <= 0x82 && green == 0 && blue == 0, "Got color %08x, expected 00800000 or near\n", color);
1758
1759 /* 5) Test alpha again, now with color keyed P8 texture */
1760 if(Texture) IDirect3DTexture_Release(Texture);
1761 Texture = NULL;
1762 if(TexSurface) IDirectDrawSurface_Release(TexSurface);
1763 TexSurface = NULL;
1764
1765 hr = IDirect3DDevice_EnumTextureFormats(Direct3DDevice1, TextureFormatEnumCallback,
1766 &p8_textures_supported);
1767 ok(hr == DD_OK, "IDirect3DDevice_EnumTextureFormats returned %08x\n", hr);
1768
1769 if (!p8_textures_supported) {
1770 skip("device has no P8 texture support, skipping test\n");
1771 } else {
1772 memset (&ddsd, 0, sizeof (ddsd));
1773 ddsd.dwSize = sizeof (ddsd);
1774 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
1775 ddsd.dwHeight = 128;
1776 ddsd.dwWidth = 128;
1777 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE;
1778 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
1779 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
1780 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 8;
1781
1782 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &TexSurface, NULL);
1783 ok(hr==D3D_OK, "CreateSurface returned: %x\n", hr);
1784 if (FAILED(hr)) {
1785 skip("IDirectDraw_CreateSurface failed; skipping further tests\n");
1786 goto out;
1787 }
1788
1789 memset(table1, 0, sizeof(table1));
1790 table1[0].peBlue = 0xff;
1791 table1[1].peRed = 0xff;
1792
1793 hr = IDirectDraw_CreatePalette(DirectDraw1, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, table1, &Palette, NULL);
1794 ok(hr == DD_OK, "CreatePalette returned %08x\n", hr);
1795 if (FAILED(hr)) {
1796 skip("IDirectDraw_CreatePalette failed; skipping further tests\n");
1797 goto out;
1798 }
1799
1800 hr = IDirectDrawSurface_SetPalette(TexSurface, Palette);
1801 ok(hr==D3D_OK, "IDirectDrawSurface_SetPalette returned: %x\n", hr);
1802
1803 hr = IDirectDrawSurface_QueryInterface(TexSurface, &IID_IDirect3DTexture,
1804 (void *)&Texture);
1805 ok(hr==D3D_OK, "IDirectDrawSurface_QueryInterface returned: %x\n", hr);
1806 if (FAILED(hr)) {
1807 skip("Can't get IDirect3DTexture interface; skipping further tests\n");
1808 goto out;
1809 }
1810
1811 memset(&ddbltfx, 0, sizeof(ddbltfx));
1812 ddbltfx.dwSize = sizeof(ddbltfx);
1813 U5(ddbltfx).dwFillColor = 0;
1814 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1815 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1816 U5(ddbltfx).dwFillColor = 0;
1817 hr = IDirectDrawSurface_Blt(TexSurface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1818 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1819 U5(ddbltfx).dwFillColor = 1;
1820 hr = IDirectDrawSurface_Blt(TexSurface, &rect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
1821 ok(hr == D3D_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
1822
1823 clrKey.dwColorSpaceLowValue = 1;
1824 clrKey.dwColorSpaceHighValue = 1;
1825 hr = IDirectDrawSurface_SetColorKey(TexSurface, DDCKEY_SRCBLT, &clrKey);
1826 ok(hr==D3D_OK, "IDirectDrawSurfac_SetColorKey returned: %x\n", hr);
1827
1828 memset(&exdesc, 0, sizeof(D3DEXECUTEBUFFERDESC));
1829 exdesc.dwSize = sizeof(D3DEXECUTEBUFFERDESC);
1830 hr = IDirect3DExecuteBuffer_Lock(ExecuteBuffer, &exdesc);
1831 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_Lock failed with %08x\n", hr);
1832 if (FAILED(hr)) {
1833 skip("IDirect3DExecuteBuffer_Lock failed; skipping further tests\n");
1834 goto out;
1835 }
1836
1837 memcpy(exdesc.lpData, test1_quads, sizeof(test1_quads));
1838
1839 exe_buffer_ptr = 256 + (char*)exdesc.lpData;
1840
1841 EXEBUF_PUT_PROCESSVERTICES(8, exe_buffer_ptr);
1842
1843 EXEBUF_START_RENDER_STATES(2, exe_buffer_ptr);
1844 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_ALPHABLENDENABLE, TRUE, exe_buffer_ptr);
1845 hr = IDirect3DTexture_GetHandle(Texture, Direct3DDevice1, &htex);
1846 ok(hr == D3D_OK, "IDirect3DTexture_GetHandle failed with %08x\n", hr);
1847 EXEBUF_PUT_RENDER_STATE(D3DRENDERSTATE_TEXTUREHANDLE, htex, exe_buffer_ptr);
1848
1849 EXEBUF_PUT_QUAD(0, exe_buffer_ptr);
1850 EXEBUF_PUT_QUAD(4, exe_buffer_ptr);
1851
1852 EXEBUF_END(exe_buffer_ptr);
1853
1854 exe_length = ((char*)exe_buffer_ptr - (char*)exdesc.lpData) - 256;
1855
1856 hr = IDirect3DExecuteBuffer_Unlock(ExecuteBuffer);
1857 if (FAILED(hr)) {
1858 trace("IDirect3DExecuteBuffer_Unlock failed with %08x\n", hr);
1859 }
1860
1861 memset(&exdata, 0, sizeof(D3DEXECUTEDATA));
1862 exdata.dwSize = sizeof(D3DEXECUTEDATA);
1863 exdata.dwVertexCount = 8;
1864 exdata.dwInstructionOffset = 256;
1865 exdata.dwInstructionLength = exe_length;
1866 hr = IDirect3DExecuteBuffer_SetExecuteData(ExecuteBuffer, &exdata);
1867 ok(hr == D3D_OK, "IDirect3DExecuteBuffer_SetExecuteData failed with %08x\n", hr);
1868
1869 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1870 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1871
1872 if (SUCCEEDED(hr)) {
1873 hr = IDirect3DDevice_Execute(Direct3DDevice1, ExecuteBuffer, Viewport, D3DEXECUTE_UNCLIPPED);
1874 ok(hr == D3D_OK, "IDirect3DDevice_Execute failed, hr = %08x\n", hr);
1875 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1876 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1877 }
1878
1879 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1880 ok(color == 0, "Got color %08x, expected 00000000\n", color);
1881
1882 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 5);
1883 red = (color & 0x00ff0000) >> 16;
1884 green = (color & 0x0000ff00) >> 8;
1885 blue = (color & 0x000000ff);
1886 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff or near\n", color);
1887
1888 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 245);
1889 ok(color == 0, "Got color %08x, expected 00000000\n", color);
1890
1891 color = D3D1_getPixelColor(DirectDraw1, Surface1, 400, 245);
1892 red = (color & 0x00ff0000) >> 16;
1893 green = (color & 0x0000ff00) >> 8;
1894 blue = (color & 0x000000ff);
1895 ok(red == 0 && green == 0 && blue >= 0x7e && blue <= 0x82, "Got color %08x, expected 00000080 or near\n", color);
1896 }
1897
1898 out:
1899
1900 if (Palette) IDirectDrawPalette_Release(Palette);
1901 if (TexSurface) IDirectDrawSurface_Release(TexSurface);
1902 if (Texture) IDirect3DTexture_Release(Texture);
1903 }
1904
1905 static void D3D1_ViewportClearTest(void)
1906 {
1907 HRESULT hr;
1908 IDirect3DMaterial *bgMaterial = NULL;
1909 D3DMATERIAL mat;
1910 D3DMATERIALHANDLE hMat;
1911 D3DVIEWPORT vp_data;
1912 IDirect3DViewport *Viewport2 = NULL;
1913 DWORD color, red, green, blue;
1914
1915 hr = IDirect3D_CreateMaterial(Direct3D1, &bgMaterial, NULL);
1916 ok(hr == D3D_OK, "IDirect3D_CreateMaterial failed: %08x\n", hr);
1917 if (FAILED(hr)) {
1918 goto out;
1919 }
1920
1921 hr = IDirect3D_CreateViewport(Direct3D1, &Viewport2, NULL);
1922 ok(hr == D3D_OK, "IDirect3D_CreateViewport failed: %08x\n", hr);
1923 if (FAILED(hr)) {
1924 goto out;
1925 }
1926
1927 hr = IDirect3DViewport_Initialize(Viewport2, Direct3D1);
1928 ok(hr == D3D_OK || hr == DDERR_ALREADYINITIALIZED, "IDirect3DViewport_Initialize returned %08x\n", hr);
1929 hr = IDirect3DDevice_AddViewport(Direct3DDevice1, Viewport2);
1930 ok(hr == D3D_OK, "IDirect3DDevice_AddViewport returned %08x\n", hr);
1931 vp_data.dwSize = sizeof(vp_data);
1932 vp_data.dwX = 200;
1933 vp_data.dwY = 200;
1934 vp_data.dwWidth = 100;
1935 vp_data.dwHeight = 100;
1936 vp_data.dvScaleX = 1;
1937 vp_data.dvScaleY = 1;
1938 vp_data.dvMaxX = 100;
1939 vp_data.dvMaxY = 100;
1940 vp_data.dvMinZ = 0;
1941 vp_data.dvMaxZ = 1;
1942 hr = IDirect3DViewport_SetViewport(Viewport2, &vp_data);
1943 ok(hr == D3D_OK, "IDirect3DViewport_SetViewport returned %08x\n", hr);
1944
1945 memset(&mat, 0, sizeof(mat));
1946 mat.dwSize = sizeof(mat);
1947 U1(U(mat).diffuse).r = 1.0f;
1948 hr = IDirect3DMaterial_SetMaterial(bgMaterial, &mat);
1949 ok(hr == D3D_OK, "IDirect3DMaterial_SetMaterial failed: %08x\n", hr);
1950
1951 hr = IDirect3DMaterial_GetHandle(bgMaterial, Direct3DDevice1, &hMat);
1952 ok(hr == D3D_OK, "IDirect3DMaterial_GetHandle failed: %08x\n", hr);
1953
1954 hr = IDirect3DViewport_SetBackground(Viewport, hMat);
1955 ok(hr == D3D_OK, "IDirect3DViewport_SetBackground failed: %08x\n", hr);
1956 hr = IDirect3DViewport_SetBackground(Viewport2, hMat);
1957 ok(hr == D3D_OK, "IDirect3DViewport_SetBackground failed: %08x\n", hr);
1958
1959 hr = IDirect3DDevice_BeginScene(Direct3DDevice1);
1960 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
1961
1962 if (SUCCEEDED(hr)) {
1963 D3DRECT rect;
1964
1965 U1(rect).x1 = U2(rect).y1 = 0;
1966 U3(rect).x2 = 640;
1967 U4(rect).y2 = 480;
1968
1969 hr = IDirect3DViewport_Clear(Viewport, 1, &rect, D3DCLEAR_TARGET);
1970 ok(hr == D3D_OK, "IDirect3DViewport_Clear failed: %08x\n", hr);
1971
1972 memset(&mat, 0, sizeof(mat));
1973 mat.dwSize = sizeof(mat);
1974 U3(U(mat).diffuse).b = 1.0f;
1975 hr = IDirect3DMaterial_SetMaterial(bgMaterial, &mat);
1976 ok(hr == D3D_OK, "IDirect3DMaterial_SetMaterial failed: %08x\n", hr);
1977
1978 hr = IDirect3DViewport_Clear(Viewport2, 1, &rect, D3DCLEAR_TARGET);
1979 ok(hr == D3D_OK, "IDirect3DViewport_Clear failed: %08x\n", hr);
1980
1981 hr = IDirect3DDevice_EndScene(Direct3DDevice1);
1982 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
1983 }
1984
1985 color = D3D1_getPixelColor(DirectDraw1, Surface1, 5, 5);
1986 red = (color & 0x00ff0000) >> 16;
1987 green = (color & 0x0000ff00) >> 8;
1988 blue = (color & 0x000000ff);
1989 ok((red == 0xff && green == 0 && blue == 0) ||
1990 broken(red == 0 && green == 0 && blue == 0xff), /* VMware and some native boxes */
1991 "Got color %08x, expected 00ff0000\n", color);
1992
1993 color = D3D1_getPixelColor(DirectDraw1, Surface1, 205, 205);
1994 red = (color & 0x00ff0000) >> 16;
1995 green = (color & 0x0000ff00) >> 8;
1996 blue = (color & 0x000000ff);
1997 ok(red == 0 && green == 0 && blue == 0xff, "Got color %08x, expected 000000ff\n", color);
1998
1999 out:
2000
2001 if (bgMaterial) IDirect3DMaterial_Release(bgMaterial);
2002 if (Viewport2) IDirect3DViewport_Release(Viewport2);
2003 }
2004
2005 static DWORD D3D3_getPixelColor(IDirectDraw4 *DirectDraw, IDirectDrawSurface4 *Surface, UINT x, UINT y)
2006 {
2007 DWORD ret;
2008 HRESULT hr;
2009 DDSURFACEDESC2 ddsd;
2010 RECT rectToLock = {x, y, x+1, y+1};
2011 IDirectDrawSurface4 *surf = NULL;
2012
2013 /* Some implementations seem to dislike direct locking on the front buffer. Thus copy the front buffer
2014 * to an offscreen surface and lock it instead of the front buffer
2015 */
2016 memset(&ddsd, 0, sizeof(ddsd));
2017 ddsd.dwSize = sizeof(ddsd);
2018 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
2019 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
2020 ddsd.dwWidth = 640;
2021 ddsd.dwHeight = 480;
2022 ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
2023 hr = IDirectDraw4_CreateSurface(DirectDraw, &ddsd, &surf, NULL);
2024 ok(hr == DD_OK, "IDirectDraw_CreateSurface failed with %08x\n", hr);
2025 if(!surf)
2026 {
2027 trace("cannot create helper surface\n");
2028 return 0xdeadbeef;
2029 }
2030
2031 memset(&ddsd, 0, sizeof(ddsd));
2032 ddsd.dwSize = sizeof(ddsd);
2033 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
2034
2035 hr = IDirectDrawSurface4_BltFast(surf, 0, 0, Surface, NULL, 0);
2036 ok(hr == DD_OK, "IDirectDrawSurface_BltFast returned %08x\n", hr);
2037 if(FAILED(hr))
2038 {
2039 trace("Cannot blit\n");
2040 ret = 0xdeadbee;
2041 goto out;
2042 }
2043
2044 hr = IDirectDrawSurface4_Lock(surf, &rectToLock, &ddsd, DDLOCK_READONLY | DDLOCK_WAIT, NULL);
2045 if(FAILED(hr))
2046 {
2047 trace("Can't lock the offscreen surface, hr=%08x\n", hr);
2048 ret = 0xdeadbeec;
2049 goto out;
2050 }
2051
2052 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
2053 * really important for these tests
2054 */
2055 ret = ((DWORD *) ddsd.lpSurface)[0] & 0x00ffffff;
2056 hr = IDirectDrawSurface4_Unlock(surf, NULL);
2057 if(FAILED(hr))
2058 {
2059 trace("Can't unlock the offscreen surface, hr=%08x\n", hr);
2060 }
2061
2062 out:
2063 IDirectDrawSurface4_Release(surf);
2064 return ret;
2065 }
2066
2067 static void D3D3_ViewportClearTest(void)
2068 {
2069 HRESULT hr;
2070 IDirectDraw *DirectDraw1 = NULL;
2071 IDirectDraw4 *DirectDraw4 = NULL;
2072 IDirectDrawSurface4 *Primary = NULL;
2073 IDirect3D3 *Direct3D3 = NULL;
2074 IDirect3DViewport3 *Viewport3 = NULL;
2075 IDirect3DViewport3 *SmallViewport3 = NULL;
2076 IDirect3DDevice3 *Direct3DDevice3 = NULL;
2077 WNDCLASS wc = {0};
2078 DDSURFACEDESC2 ddsd;
2079 D3DVIEWPORT2 vp_data;
2080 DWORD color, red, green, blue;
2081 D3DRECT rect;
2082 float mat[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
2083 0.0f, 1.0f, 0.0f, 0.0f,
2084 0.0f, 0.0f, 1.0f, 0.0f,
2085 0.0f, 0.0f, 0.0f, 1.0f };
2086 struct vertex quad[] =
2087 {
2088 {-1.0f, -1.0f, 0.1f, 0xffffffff},
2089 {-1.0f, 1.0f, 0.1f, 0xffffffff},
2090 { 1.0f, 1.0f, 0.1f, 0xffffffff},
2091 { 1.0f, -1.0f, 0.1f, 0xffffffff},
2092 };
2093
2094 WORD Indices[] = {0, 1, 2, 2, 3, 0};
2095 DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
2096
2097 wc.lpfnWndProc = DefWindowProc;
2098 wc.lpszClassName = "D3D3_ViewportClearTest_wc";
2099 RegisterClass(&wc);
2100 window = CreateWindow("D3D3_ViewportClearTest_wc", "D3D3_ViewportClearTest",
2101 WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
2102
2103 hr = DirectDrawCreate( NULL, &DirectDraw1, NULL );
2104 ok(hr==DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreate returned: %x\n", hr);
2105 if(FAILED(hr)) goto out;
2106
2107 hr = IDirectDraw_SetCooperativeLevel(DirectDraw1, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2108 ok(hr==DD_OK, "SetCooperativeLevel returned: %x\n", hr);
2109 if(FAILED(hr)) goto out;
2110
2111 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 32);
2112 if(FAILED(hr)) {
2113 /* 24 bit is fine too */
2114 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 24);
2115 }
2116 ok(hr==DD_OK || hr == DDERR_UNSUPPORTED, "SetDisplayMode returned: %x\n", hr);
2117 if (FAILED(hr)) goto out;
2118
2119 hr = IDirectDraw_QueryInterface(DirectDraw1, &IID_IDirectDraw4, (void**)&DirectDraw4);
2120 ok(hr==DD_OK, "QueryInterface returned: %08x\n", hr);
2121 if(FAILED(hr)) goto out;
2122
2123 memset(&ddsd, 0, sizeof(DDSURFACEDESC2));
2124 ddsd.dwSize = sizeof(DDSURFACEDESC2);
2125 ddsd.dwFlags = DDSD_CAPS;
2126 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;
2127
2128 hr = IDirectDraw_CreateSurface(DirectDraw4, &ddsd, &Primary, NULL);
2129 ok(hr==DD_OK, "IDirectDraw_CreateSurface returned: %08x\n", hr);
2130 if(FAILED(hr)) goto out;
2131
2132 hr = IDirectDraw4_QueryInterface(DirectDraw4, &IID_IDirect3D3, (void**)&Direct3D3);
2133 ok(hr==DD_OK, "IDirectDraw4_QueryInterface returned: %08x\n", hr);
2134 if(FAILED(hr)) goto out;
2135
2136 hr = IDirect3D3_CreateDevice(Direct3D3, &IID_IDirect3DHALDevice, Primary, &Direct3DDevice3, NULL);
2137 if(FAILED(hr)) {
2138 trace("Creating a HAL device failed, trying Ref\n");
2139 hr = IDirect3D3_CreateDevice(Direct3D3, &IID_IDirect3DRefDevice, Primary, &Direct3DDevice3, NULL);
2140 }
2141 ok(hr==D3D_OK, "Creating 3D device returned: %x\n", hr);
2142 if(FAILED(hr)) goto out;
2143
2144 hr = IDirect3D3_CreateViewport(Direct3D3, &Viewport3, NULL);
2145 ok(hr==DD_OK, "IDirect3D3_CreateViewport returned: %08x\n", hr);
2146 if(FAILED(hr)) goto out;
2147
2148 hr = IDirect3DDevice3_AddViewport(Direct3DDevice3, Viewport3);
2149 ok(hr==DD_OK, "IDirect3DDevice3_AddViewport returned: %08x\n", hr);
2150
2151 memset(&vp_data, 0, sizeof(D3DVIEWPORT2));
2152 vp_data.dwSize = sizeof(D3DVIEWPORT2);
2153 vp_data.dwWidth = 640;
2154 vp_data.dwHeight = 480;
2155 vp_data.dvClipX = -1.0f;
2156 vp_data.dvClipWidth = 2.0f;
2157 vp_data.dvClipY = 1.0f;
2158 vp_data.dvClipHeight = 2.0f;
2159 vp_data.dvMaxZ = 1.0f;
2160 hr = IDirect3DViewport3_SetViewport2(Viewport3, &vp_data);
2161 ok(hr==DD_OK, "IDirect3DViewport3_SetViewport2 returned: %08x\n", hr);
2162
2163 hr = IDirect3D3_CreateViewport(Direct3D3, &SmallViewport3, NULL);
2164 ok(hr==DD_OK, "IDirect3D3_CreateViewport returned: %08x\n", hr);
2165 if(FAILED(hr)) goto out;
2166
2167 hr = IDirect3DDevice3_AddViewport(Direct3DDevice3, SmallViewport3);
2168 ok(hr==DD_OK, "IDirect3DDevice3_AddViewport returned: %08x\n", hr);
2169
2170 memset(&vp_data, 0, sizeof(D3DVIEWPORT2));
2171 vp_data.dwSize = sizeof(D3DVIEWPORT2);
2172 vp_data.dwX = 400;
2173 vp_data.dwY = 100;
2174 vp_data.dwWidth = 100;
2175 vp_data.dwHeight = 100;
2176 vp_data.dvClipX = -1.0f;
2177 vp_data.dvClipWidth = 2.0f;
2178 vp_data.dvClipY = 1.0f;
2179 vp_data.dvClipHeight = 2.0f;
2180 vp_data.dvMaxZ = 1.0f;
2181 hr = IDirect3DViewport3_SetViewport2(SmallViewport3, &vp_data);
2182 ok(hr==DD_OK, "IDirect3DViewport3_SetViewport2 returned: %08x\n", hr);
2183
2184 hr = IDirect3DDevice3_BeginScene(Direct3DDevice3);
2185 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
2186
2187 hr = IDirect3DDevice3_SetTransform(Direct3DDevice3, D3DTRANSFORMSTATE_WORLD, (D3DMATRIX *) mat);
2188 ok(hr == D3D_OK, "IDirect3DDevice3_SetTransform returned %08x\n", hr);
2189 hr = IDirect3DDevice3_SetTransform(Direct3DDevice3, D3DTRANSFORMSTATE_VIEW, (D3DMATRIX *)mat);
2190 ok(hr == D3D_OK, "IDirect3DDevice3_SetTransform returned %08x\n", hr);
2191 hr = IDirect3DDevice3_SetTransform(Direct3DDevice3, D3DTRANSFORMSTATE_PROJECTION, (D3DMATRIX *) mat);
2192 ok(hr == D3D_OK, "IDirect3DDevice3_SetTransform returned %08x\n", hr);
2193 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_CLIPPING, FALSE);
2194 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2195 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_ZENABLE, FALSE);
2196 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2197 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_FOGENABLE, FALSE);
2198 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2199 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_STENCILENABLE, FALSE);
2200 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2201 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_ALPHATESTENABLE, FALSE);
2202 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2203 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_ALPHABLENDENABLE, FALSE);
2204 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2205 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE);
2206 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState failed with %08x\n", hr);
2207 hr = IDirect3DDevice3_SetRenderState(Direct3DDevice3, D3DRENDERSTATE_LIGHTING, FALSE);
2208 ok(hr == D3D_OK, "IDirect3DDevice3_SetRenderState returned %08x\n", hr);
2209
2210 if (SUCCEEDED(hr)) {
2211 U1(rect).x1 = U2(rect).y1 = 0;
2212 U3(rect).x2 = 640;
2213 U4(rect).y2 = 480;
2214
2215 hr = IDirect3DViewport3_Clear2(Viewport3, 1, &rect, D3DCLEAR_TARGET, 0x00ff00, 0.0f, 0);
2216 ok(hr == D3D_OK, "IDirect3DViewport3_Clear2 failed, hr = %08x\n", hr);
2217
2218 hr = IDirect3DViewport3_Clear2(SmallViewport3, 1, &rect, D3DCLEAR_TARGET, 0xff0000, 0.0f, 0);
2219 ok(hr == D3D_OK, "IDirect3DViewport3_Clear2 failed, hr = %08x\n", hr);
2220
2221 hr = IDirect3DDevice3_EndScene(Direct3DDevice3);
2222 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
2223 }
2224
2225 color = D3D3_getPixelColor(DirectDraw4, Primary, 5, 5);
2226 red = (color & 0x00ff0000) >> 16;
2227 green = (color & 0x0000ff00) >> 8;
2228 blue = (color & 0x000000ff);
2229 ok(red == 0 && green == 0xff && blue == 0, "Got color %08x, expected 0000ff00\n", color);
2230
2231 color = D3D3_getPixelColor(DirectDraw4, Primary, 405, 105);
2232 red = (color & 0x00ff0000) >> 16;
2233 green = (color & 0x0000ff00) >> 8;
2234 blue = (color & 0x000000ff);
2235 ok(red == 0xff && green == 0 && blue == 0, "Got color %08x, expected 00ff0000\n", color);
2236
2237 /* Test that clearing viewport doesn't interfere with rendering to previously active viewport. */
2238 hr = IDirect3DDevice3_BeginScene(Direct3DDevice3);
2239 ok(hr == D3D_OK, "IDirect3DDevice3_BeginScene failed with %08x\n", hr);
2240
2241 if (SUCCEEDED(hr)) {
2242 hr = IDirect3DDevice3_SetCurrentViewport(Direct3DDevice3, SmallViewport3);
2243 ok(hr == D3D_OK, "IDirect3DDevice3_SetCurrentViewport failed with %08x\n", hr);
2244
2245 hr = IDirect3DViewport3_Clear2(Viewport3, 1, &rect, D3DCLEAR_TARGET, 0x000000, 0.0f, 0);
2246 ok(hr == D3D_OK, "IDirect3DViewport3_Clear2 failed, hr = %08x\n", hr);
2247
2248 hr = IDirect3DDevice3_DrawIndexedPrimitive(Direct3DDevice3, D3DPT_TRIANGLELIST, fvf, quad, 4 /* NumVerts */,
2249 Indices, 6 /* Indexcount */, 0 /* flags */);
2250 ok(hr == D3D_OK, "IDirect3DDevice3_DrawIndexedPrimitive failed with %08x\n", hr);
2251
2252 hr = IDirect3DDevice3_EndScene(Direct3DDevice3);
2253 ok(hr == D3D_OK, "IDirect3DDevice3_EndScene failed, hr = %08x\n", hr);
2254 }
2255
2256 color = D3D3_getPixelColor(DirectDraw4, Primary, 5, 5);
2257 red = (color & 0x00ff0000) >> 16;
2258 green = (color & 0x0000ff00) >> 8;
2259 blue = (color & 0x000000ff);
2260 ok(red == 0 && green == 0 && blue == 0, "Got color %08x, expected 00000000\n", color);
2261
2262 color = D3D3_getPixelColor(DirectDraw4, Primary, 405, 105);
2263 red = (color & 0x00ff0000) >> 16;
2264 green = (color & 0x0000ff00) >> 8;
2265 blue = (color & 0x000000ff);
2266 ok(red == 0xff && green == 0xff && blue == 0xff, "Got color %08x, expected 00ffffff\n", color);
2267
2268 out:
2269
2270 if (SmallViewport3) IDirect3DViewport3_Release(SmallViewport3);
2271 if (Viewport3) IDirect3DViewport3_Release(Viewport3);
2272 if (Direct3DDevice3) IDirect3DDevice3_Release(Direct3DDevice3);
2273 if (Direct3D3) IDirect3D3_Release(Direct3D3);
2274 if (Primary) IDirectDrawSurface4_Release(Primary);
2275 if (DirectDraw1) IDirectDraw_Release(DirectDraw1);
2276 if (DirectDraw4) IDirectDraw4_Release(DirectDraw4);
2277 if(window) DestroyWindow(window);
2278 }
2279
2280 static void p8_surface_fill_rect(IDirectDrawSurface *dest, UINT x, UINT y, UINT w, UINT h, BYTE colorindex)
2281 {
2282 DDSURFACEDESC ddsd;
2283 HRESULT hr;
2284 UINT i, i1;
2285 BYTE *p;
2286
2287 memset(&ddsd, 0, sizeof(ddsd));
2288 ddsd.dwSize = sizeof(ddsd);
2289
2290 hr = IDirectDrawSurface_Lock(dest, NULL, &ddsd, DDLOCK_WRITEONLY | DDLOCK_WAIT, NULL);
2291 ok(hr==DD_OK, "IDirectDrawSurface_Lock returned: %x\n", hr);
2292
2293 p = (BYTE *)ddsd.lpSurface + U1(ddsd).lPitch * y + x;
2294
2295 for (i = 0; i < h; i++) {
2296 for (i1 = 0; i1 < w; i1++) {
2297 p[i1] = colorindex;
2298 }
2299 p += U1(ddsd).lPitch;
2300 }
2301
2302 hr = IDirectDrawSurface_Unlock(dest, NULL);
2303 ok(hr==DD_OK, "IDirectDrawSurface_UnLock returned: %x\n", hr);
2304 }
2305
2306 static COLORREF getPixelColor_GDI(IDirectDrawSurface *Surface, UINT x, UINT y)
2307 {
2308 COLORREF clr = CLR_INVALID;
2309 HDC hdc;
2310 HRESULT hr;
2311
2312 hr = IDirectDrawSurface_GetDC(Surface, &hdc);
2313 ok(hr==DD_OK, "IDirectDrawSurface_GetDC returned: %x\n", hr);
2314
2315 if (SUCCEEDED(hr)) {
2316 clr = GetPixel(hdc, x, y);
2317
2318 hr = IDirectDrawSurface_ReleaseDC(Surface, hdc);
2319 ok(hr==DD_OK, "IDirectDrawSurface_ReleaseDC returned: %x\n", hr);
2320 }
2321
2322 return clr;
2323 }
2324
2325 static BOOL colortables_check_equality(PALETTEENTRY table1[256], RGBQUAD table2[256])
2326 {
2327 int i;
2328
2329 for (i = 0; i < 256; i++) {
2330 if (table1[i].peRed != table2[i].rgbRed || table1[i].peGreen != table2[i].rgbGreen ||
2331 table1[i].peBlue != table2[i].rgbBlue) return FALSE;
2332 }
2333
2334 return TRUE;
2335 }
2336
2337 static void p8_primary_test(void)
2338 {
2339 /* Test 8bit mode used by games like StarCraft, C&C Red Alert I etc */
2340 DDSURFACEDESC ddsd;
2341 HDC hdc;
2342 HRESULT hr;
2343 PALETTEENTRY entries[256];
2344 RGBQUAD coltable[256];
2345 UINT i, i1, i2;
2346 IDirectDrawPalette *ddprimpal = NULL;
2347 IDirectDrawSurface *offscreen = NULL;
2348 WNDCLASS wc = {0};
2349 DDBLTFX ddbltfx;
2350 COLORREF color;
2351 RECT rect;
2352 DDCOLORKEY clrKey;
2353 unsigned differences;
2354
2355 /* An IDirect3DDevice cannot be queryInterfaced from an IDirect3DDevice7 on windows */
2356 hr = DirectDrawCreate(NULL, &DirectDraw1, NULL);
2357
2358 ok(hr==DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreate returned: %x\n", hr);
2359 if (FAILED(hr)) {
2360 goto out;
2361 }
2362
2363 wc.lpfnWndProc = DefWindowProc;
2364 wc.lpszClassName = "p8_primary_test_wc";
2365 RegisterClass(&wc);
2366 window = CreateWindow("p8_primary_test_wc", "p8_primary_test", WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
2367
2368 hr = IDirectDraw_SetCooperativeLevel(DirectDraw1, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2369 ok(hr==DD_OK, "SetCooperativeLevel returned: %x\n", hr);
2370 if(FAILED(hr)) {
2371 goto out;
2372 }
2373
2374 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 8);
2375 ok(hr==DD_OK || hr == DDERR_UNSUPPORTED, "SetDisplayMode returned: %x\n", hr);
2376 if (FAILED(hr)) {
2377 goto out;
2378 }
2379
2380 memset(&ddsd, 0, sizeof(ddsd));
2381 ddsd.dwSize = sizeof(ddsd);
2382 ddsd.dwFlags = DDSD_CAPS;
2383 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2384 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &Surface1, NULL);
2385 ok(hr==DD_OK, "CreateSurface returned: %x\n", hr);
2386 if (FAILED(hr)) {
2387 goto out;
2388 }
2389
2390 memset(entries, 0, sizeof(entries));
2391 entries[0].peRed = 0xff;
2392 entries[1].peGreen = 0xff;
2393 entries[2].peBlue = 0xff;
2394
2395 hr = IDirectDraw_CreatePalette(DirectDraw1, DDPCAPS_ALLOW256 | DDPCAPS_8BIT, entries, &ddprimpal, NULL);
2396 ok(hr == DD_OK, "CreatePalette returned %08x\n", hr);
2397 if (FAILED(hr)) {
2398 skip("IDirectDraw_CreatePalette failed; skipping further tests\n");
2399 goto out;
2400 }
2401
2402 hr = IDirectDrawSurface_SetPalette(Surface1, ddprimpal);
2403 ok(hr==DD_OK, "IDirectDrawSurface_SetPalette returned: %x\n", hr);
2404
2405 p8_surface_fill_rect(Surface1, 0, 0, 640, 480, 2);
2406
2407 color = getPixelColor_GDI(Surface1, 10, 10);
2408 ok(GetRValue(color) == 0 && GetGValue(color) == 0 && GetBValue(color) == 0xFF,
2409 "got R %02X G %02X B %02X, expected R 00 G 00 B FF\n",
2410 GetRValue(color), GetGValue(color), GetBValue(color));
2411
2412 memset(&ddbltfx, 0, sizeof(ddbltfx));
2413 ddbltfx.dwSize = sizeof(ddbltfx);
2414 U5(ddbltfx).dwFillColor = 0;
2415 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
2416 ok(hr == DD_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
2417
2418 color = getPixelColor_GDI(Surface1, 10, 10);
2419 ok(GetRValue(color) == 0xFF && GetGValue(color) == 0 && GetBValue(color) == 0,
2420 "got R %02X G %02X B %02X, expected R FF G 00 B 00\n",
2421 GetRValue(color), GetGValue(color), GetBValue(color));
2422
2423 memset(&ddbltfx, 0, sizeof(ddbltfx));
2424 ddbltfx.dwSize = sizeof(ddbltfx);
2425 U5(ddbltfx).dwFillColor = 1;
2426 hr = IDirectDrawSurface_Blt(Surface1, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
2427 ok(hr == DD_OK, "IDirectDrawSurface_Blt failed with %08x\n", hr);
2428
2429 color = getPixelColor_GDI(Surface1, 10, 10);
2430 ok(GetRValue(color) == 0 && GetGValue(color) == 0xFF && GetBValue(color) == 0,
2431 "got R %02X G %02X B %02X, expected R 00 G FF B 00\n",
2432 GetRValue(color), GetGValue(color), GetBValue(color));
2433
2434 memset (&ddsd, 0, sizeof (ddsd));
2435 ddsd.dwSize = sizeof (ddsd);
2436 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
2437 ddsd.dwWidth = 16;
2438 ddsd.dwHeight = 16;
2439 ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY;
2440 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
2441 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
2442 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 8;
2443 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &offscreen, NULL);
2444 ok(hr == DD_OK ||
2445 broken(hr == DDERR_INVALIDPIXELFORMAT) || /* VMware */
2446 broken(hr == DDERR_NODIRECTDRAWHW), /* VMware */
2447 "IDirectDraw_CreateSurface returned %08x\n", hr);
2448 if (FAILED(hr)) goto out;
2449
2450 memset(entries, 0, sizeof(entries));
2451 for (i = 0; i < 256; i++) {
2452 entries[i].peBlue = i;
2453 }
2454 hr = IDirectDrawPalette_SetEntries(ddprimpal, 0, 0, 256, entries);
2455 ok(hr == DD_OK, "IDirectDrawPalette_SetEntries failed with %08x\n", hr);
2456
2457 hr = IDirectDrawSurface_GetDC(offscreen, &hdc);
2458 ok(hr==DD_OK, "IDirectDrawSurface_GetDC returned: %x\n", hr);
2459 i = GetDIBColorTable(hdc, 0, 256, coltable);
2460 ok(i == 256, "GetDIBColorTable returned %u, last error: %x\n", i, GetLastError());
2461 hr = IDirectDrawSurface_ReleaseDC(offscreen, hdc);
2462 ok(hr==DD_OK, "IDirectDrawSurface_ReleaseDC returned: %x\n", hr);
2463
2464 ok(colortables_check_equality(entries, coltable), "unexpected colortable on offscreen surface\n");
2465
2466 p8_surface_fill_rect(offscreen, 0, 0, 16, 16, 2);
2467
2468 memset(entries, 0, sizeof(entries));
2469 entries[0].peRed = 0xff;
2470 entries[1].peGreen = 0xff;
2471 entries[2].peBlue = 0xff;
2472 entries[3].peRed = 0x80;
2473 hr = IDirectDrawPalette_SetEntries(ddprimpal, 0, 0, 256, entries);
2474 ok(hr == DD_OK, "IDirectDrawPalette_SetEntries failed with %08x\n", hr);
2475
2476 hr = IDirectDrawSurface_BltFast(Surface1, 0, 0, offscreen, NULL, 0);
2477 ok(hr==DD_OK, "IDirectDrawSurface_BltFast returned: %x\n", hr);
2478
2479 color = getPixelColor_GDI(Surface1, 1, 1);
2480 ok(GetRValue(color) == 0 && GetGValue(color) == 0x00 && GetBValue(color) == 0xFF,
2481 "got R %02X G %02X B %02X, expected R 00 G 00 B FF\n",
2482 GetRValue(color), GetGValue(color), GetBValue(color));
2483
2484 /* Color keyed blit. */
2485 p8_surface_fill_rect(offscreen, 0, 0, 8, 8, 3);
2486 clrKey.dwColorSpaceLowValue = 3;
2487 clrKey.dwColorSpaceHighValue = 3;
2488 hr = IDirectDrawSurface_SetColorKey(offscreen, DDCKEY_SRCBLT, &clrKey);
2489 ok(hr==D3D_OK, "IDirectDrawSurfac_SetColorKey returned: %x\n", hr);
2490
2491 hr = IDirectDrawSurface_BltFast(Surface1, 100, 100, offscreen, NULL, DDBLTFAST_SRCCOLORKEY);
2492 ok(hr==DD_OK, "IDirectDrawSurface_BltFast returned: %x\n", hr);
2493
2494 color = getPixelColor_GDI(Surface1, 105, 105);
2495 ok(GetRValue(color) == 0 && GetGValue(color) == 0xFF && GetBValue(color) == 0,
2496 "got R %02X G %02X B %02X, expected R 00 G FF B 00\n",
2497 GetRValue(color), GetGValue(color), GetBValue(color));
2498
2499 color = getPixelColor_GDI(Surface1, 112, 112);
2500 ok(GetRValue(color) == 0 && GetGValue(color) == 0x00 && GetBValue(color) == 0xFF,
2501 "got R %02X G %02X B %02X, expected R 00 G 00 B FF\n",
2502 GetRValue(color), GetGValue(color), GetBValue(color));
2503
2504 rect.left = 100;
2505 rect.top = 200;
2506 rect.right = 116;
2507 rect.bottom = 216;
2508
2509 memset(&ddbltfx, 0, sizeof(ddbltfx));
2510 ddbltfx.dwSize = sizeof(ddbltfx);
2511 ddbltfx.ddckSrcColorkey.dwColorSpaceLowValue = ddbltfx.ddckSrcColorkey.dwColorSpaceHighValue = 2;
2512 hr = IDirectDrawSurface_Blt(Surface1, &rect, offscreen, NULL,
2513 DDBLT_WAIT | DDBLT_KEYSRC | DDBLT_KEYSRCOVERRIDE, &ddbltfx);
2514 ok(hr==DDERR_INVALIDPARAMS, "IDirectDrawSurface_Blt returned: %x\n", hr);
2515 hr = IDirectDrawSurface_Blt(Surface1, &rect, offscreen, NULL,
2516 DDBLT_WAIT | DDBLT_KEYSRCOVERRIDE, &ddbltfx);
2517 ok(hr==DD_OK, "IDirectDrawSurface_Blt returned: %x\n", hr);
2518
2519 color = getPixelColor_GDI(Surface1, 105, 205);
2520 ok(GetRValue(color) == 0x80 && GetGValue(color) == 0 && GetBValue(color) == 0,
2521 "got R %02X G %02X B %02X, expected R 80 G 00 B 00\n",
2522 GetRValue(color), GetGValue(color), GetBValue(color));
2523
2524 color = getPixelColor_GDI(Surface1, 112, 212);
2525 ok(GetRValue(color) == 0 && GetGValue(color) == 0xFF && GetBValue(color) == 0,
2526 "got R %02X G %02X B %02X, expected R 00 G FF B 00\n",
2527 GetRValue(color), GetGValue(color), GetBValue(color));
2528
2529 /* Test blitting and locking patterns that are likely to trigger bugs in opengl renderer (p8
2530 surface conversion and uploading/downloading to/from opengl texture). Similar patterns (
2531 blitting front buffer areas to/from an offscreen surface mixed with locking) are used by C&C
2532 Red Alert I. */
2533 IDirectDrawSurface_Release(offscreen);
2534
2535 memset (&ddsd, 0, sizeof (ddsd));
2536 ddsd.dwSize = sizeof (ddsd);
2537 ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
2538 ddsd.dwWidth = 640;
2539 ddsd.dwHeight = 480;
2540 ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
2541 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
2542 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_PALETTEINDEXED8;
2543 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 8;
2544 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &offscreen, NULL);
2545 ok(hr == DD_OK, "IDirectDraw_CreateSurface returned %08x\n", hr);
2546
2547 if (FAILED(hr)) goto out;
2548
2549 /* Test two times, first time front buffer has a palette and second time front buffer
2550 has no palette; the latter is somewhat contrived example, but an app could set
2551 front buffer palette later. */
2552 for (i2 = 0; i2 < 2; i2++) {
2553 if (i2 == 1) {
2554 hr = IDirectDrawSurface_SetPalette(Surface1, NULL);
2555 ok(hr==DD_OK, "IDirectDrawSurface_SetPalette returned: %x\n", hr);
2556 }
2557
2558 memset(&ddsd, 0, sizeof(ddsd));
2559 ddsd.dwSize = sizeof(ddsd);
2560 hr = IDirectDrawSurface_Lock(Surface1, NULL, &ddsd, DDLOCK_WAIT, NULL);
2561 ok(hr==DD_OK, "IDirectDrawSurface_Lock returned: %x\n", hr);
2562
2563 for (i = 0; i < 256; i++) {
2564 unsigned x = (i % 128) * 4;
2565 unsigned y = (i / 128) * 4;
2566 BYTE *p = (BYTE *)ddsd.lpSurface + U1(ddsd).lPitch * y + x;
2567
2568 for (i1 = 0; i1 < 4; i1++) {
2569 p[0] = p[1] = p[2] = p[3] = i;
2570 p += U1(ddsd).lPitch;
2571 }
2572 }
2573
2574 hr = IDirectDrawSurface_Unlock(Surface1, NULL);
2575 ok(hr==DD_OK, "IDirectDrawSurface_UnLock returned: %x\n", hr);
2576
2577 hr = IDirectDrawSurface_BltFast(offscreen, 0, 0, Surface1, NULL, 0);
2578 ok(hr==DD_OK, "IDirectDrawSurface_BltFast returned: %x\n", hr);
2579
2580 /* This ensures offscreen surface contents will be downloaded to system memory. */
2581 memset(&ddsd, 0, sizeof(ddsd));
2582 ddsd.dwSize = sizeof(ddsd);
2583 hr = IDirectDrawSurface_Lock(offscreen, NULL, &ddsd, DDLOCK_WAIT, NULL);
2584 ok(hr==DD_OK, "IDirectDrawSurface_Lock returned: %x\n", hr);
2585 hr = IDirectDrawSurface_Unlock(offscreen, NULL);
2586 ok(hr==DD_OK, "IDirectDrawSurface_UnLock returned: %x\n", hr);
2587
2588 /* Offscreen surface data will have to be converted and uploaded to texture. */
2589 rect.left = 0;
2590 rect.top = 0;
2591 rect.right = 16;
2592 rect.bottom = 16;
2593 hr = IDirectDrawSurface_BltFast(offscreen, 600, 400, Surface1, &rect, 0);
2594 ok(hr==DD_OK, "IDirectDrawSurface_BltFast returned: %x\n", hr);
2595
2596 /* This ensures offscreen surface contents will be downloaded to system memory. */
2597 memset(&ddsd, 0, sizeof(ddsd));
2598 ddsd.dwSize = sizeof(ddsd);
2599 hr = IDirectDrawSurface_Lock(offscreen, NULL, &ddsd, DDLOCK_WAIT, NULL);
2600 ok(hr==DD_OK, "IDirectDrawSurface_Lock returned: %x\n", hr);
2601 hr = IDirectDrawSurface_Unlock(offscreen, NULL);
2602 ok(hr==DD_OK, "IDirectDrawSurface_UnLock returned: %x\n", hr);
2603
2604 hr = IDirectDrawSurface_BltFast(Surface1, 0, 0, offscreen, NULL, 0);
2605 ok(hr==DD_OK, "IDirectDrawSurface_BltFast returned: %x\n", hr);
2606
2607 memset(&ddsd, 0, sizeof(ddsd));
2608 ddsd.dwSize = sizeof(ddsd);
2609 hr = IDirectDrawSurface_Lock(Surface1, NULL, &ddsd, DDLOCK_WAIT, NULL);
2610 ok(hr==DD_OK, "IDirectDrawSurface_Lock returned: %x\n", hr);
2611
2612 differences = 0;
2613
2614 for (i = 0; i < 256; i++) {
2615 unsigned x = (i % 128) * 4 + 1;
2616 unsigned y = (i / 128) * 4 + 1;
2617 BYTE *p = (BYTE *)ddsd.lpSurface + U1(ddsd).lPitch * y + x;
2618
2619 if (*p != i) differences++;
2620 }
2621
2622 hr = IDirectDrawSurface_Unlock(Surface1, NULL);
2623 ok(hr==DD_OK, "IDirectDrawSurface_UnLock returned: %x\n", hr);
2624
2625 ok(differences == 0, i2 == 0 ? "Pass 1. Unexpected front buffer contents after blit (%u differences)\n" :
2626 "Pass 2 (with NULL front buffer palette). Unexpected front buffer contents after blit (%u differences)\n",
2627 differences);
2628 }
2629
2630 out:
2631
2632 if(ddprimpal) IDirectDrawPalette_Release(ddprimpal);
2633 if(offscreen) IDirectDrawSurface_Release(offscreen);
2634 if(Surface1) IDirectDrawSurface_Release(Surface1);
2635 if(DirectDraw1) IDirectDraw_Release(DirectDraw1);
2636 if(window) DestroyWindow(window);
2637 }
2638
2639 static void cubemap_test(IDirect3DDevice7 *device)
2640 {
2641 IDirect3D7 *d3d;
2642 IDirectDraw7 *ddraw;
2643 IDirectDrawSurface7 *cubemap, *surface;
2644 D3DDEVICEDESC7 d3dcaps;
2645 HRESULT hr;
2646 DWORD color;
2647 DDSURFACEDESC2 ddsd;
2648 DDBLTFX DDBltFx;
2649 DDSCAPS2 caps;
2650 static float quad[] = {
2651 -1.0, -1.0, 0.1, 1.0, 0.0, 0.0, /* Lower left */
2652 0.0, -1.0, 0.1, 1.0, 0.0, 0.0,
2653 -1.0, 0.0, 0.1, 1.0, 0.0, 0.0,
2654 0.0, 0.0, 0.1, 1.0, 0.0, 0.0,
2655
2656 0.0, -1.0, 0.1, 0.0, 1.0, 0.0, /* Lower right */
2657 1.0, -1.0, 0.1, 0.0, 1.0, 0.0,
2658 0.0, 0.0, 0.1, 0.0, 1.0, 0.0,
2659 1.0, 0.0, 0.1, 0.0, 1.0, 0.0,
2660
2661 0.0, 0.0, 0.1, 0.0, 0.0, 1.0, /* upper right */
2662 1.0, 0.0, 0.1, 0.0, 0.0, 1.0,
2663 0.0, 1.0, 0.1, 0.0, 0.0, 1.0,
2664 1.0, 1.0, 0.1, 0.0, 0.0, 1.0,
2665
2666 -1.0, 0.0, 0.1, -1.0, 0.0, 0.0, /* Upper left */
2667 0.0, 0.0, 0.1, -1.0, 0.0, 0.0,
2668 -1.0, 1.0, 0.1, -1.0, 0.0, 0.0,
2669 0.0, 1.0, 0.1, -1.0, 0.0, 0.0,
2670 };
2671
2672 memset(&DDBltFx, 0, sizeof(DDBltFx));
2673 DDBltFx.dwSize = sizeof(DDBltFx);
2674
2675 memset(&d3dcaps, 0, sizeof(d3dcaps));
2676 hr = IDirect3DDevice7_GetCaps(device, &d3dcaps);
2677 ok(hr == D3D_OK, "IDirect3DDevice7_GetCaps returned %08x\n", hr);
2678 if(!(d3dcaps.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_CUBEMAP))
2679 {
2680 skip("No cubemap support\n");
2681 return;
2682 }
2683
2684 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
2685 ok(hr == D3D_OK, "IDirect3DDevice7_Clear failed with %08x\n", hr);
2686
2687 hr = IDirect3DDevice7_GetDirect3D(device, &d3d);
2688 ok(hr == D3D_OK, "IDirect3DDevice7_GetDirect3D returned %08x\n", hr);
2689 hr = IDirect3D7_QueryInterface(d3d, &IID_IDirectDraw7, (void **) &ddraw);
2690 ok(hr == D3D_OK, "IDirect3D7_QueryInterface returned %08x\n", hr);
2691 IDirect3D7_Release(d3d);
2692
2693
2694 memset(&ddsd, 0, sizeof(ddsd));
2695 ddsd.dwSize = sizeof(ddsd);
2696 U4(ddsd).ddpfPixelFormat.dwSize = sizeof(U4(ddsd).ddpfPixelFormat);
2697 ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT | DDSD_CAPS;
2698 ddsd.dwWidth = 16;
2699 ddsd.dwHeight = 16;
2700 ddsd.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX;
2701 ddsd.ddsCaps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_ALLFACES | DDSCAPS2_TEXTUREMANAGE;
2702 U4(ddsd).ddpfPixelFormat.dwFlags = DDPF_RGB;
2703 U1(U4(ddsd).ddpfPixelFormat).dwRGBBitCount = 32;
2704 U2(U4(ddsd).ddpfPixelFormat).dwRBitMask = 0x00FF0000;
2705 U3(U4(ddsd).ddpfPixelFormat).dwGBitMask = 0x0000FF00;
2706 U4(U4(ddsd).ddpfPixelFormat).dwBBitMask = 0x000000FF;
2707
2708 hr = IDirectDraw7_CreateSurface(ddraw, &ddsd, &cubemap, NULL);
2709 ok(hr == DD_OK, "IDirectDraw7_CreateSurface returned %08x\n", hr);
2710 IDirectDraw7_Release(ddraw);
2711
2712 /* Positive X */
2713 U5(DDBltFx).dwFillColor = 0x00ff0000;
2714 hr = IDirectDrawSurface7_Blt(cubemap, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2715 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2716
2717 memset(&caps, 0, sizeof(caps));
2718 caps.dwCaps = DDSCAPS_TEXTURE;
2719 caps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX;
2720 hr = IDirectDrawSurface_GetAttachedSurface(cubemap, &caps, &surface);
2721 ok(hr == DD_OK, "IDirectDrawSurface7_Lock returned %08x\n", hr);
2722 U5(DDBltFx).dwFillColor = 0x0000ffff;
2723 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2724 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2725
2726 caps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ;
2727 hr = IDirectDrawSurface_GetAttachedSurface(cubemap, &caps, &surface);
2728 ok(hr == DD_OK, "IDirectDrawSurface7_Lock returned %08x\n", hr);
2729 U5(DDBltFx).dwFillColor = 0x0000ff00;
2730 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2731 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2732
2733 caps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ;
2734 hr = IDirectDrawSurface_GetAttachedSurface(cubemap, &caps, &surface);
2735 ok(hr == DD_OK, "IDirectDrawSurface7_Lock returned %08x\n", hr);
2736 U5(DDBltFx).dwFillColor = 0x000000ff;
2737 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2738 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2739
2740 caps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY;
2741 hr = IDirectDrawSurface_GetAttachedSurface(cubemap, &caps, &surface);
2742 ok(hr == DD_OK, "IDirectDrawSurface7_Lock returned %08x\n", hr);
2743 U5(DDBltFx).dwFillColor = 0x00ffff00;
2744 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2745 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2746
2747 caps.dwCaps2 = DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY;
2748 hr = IDirectDrawSurface_GetAttachedSurface(cubemap, &caps, &surface);
2749 ok(hr == DD_OK, "IDirectDrawSurface7_Lock returned %08x\n", hr);
2750 U5(DDBltFx).dwFillColor = 0x00ff00ff;
2751 hr = IDirectDrawSurface7_Blt(surface, NULL, NULL, NULL, DDBLT_COLORFILL, &DDBltFx);
2752 ok(hr == DD_OK, "IDirectDrawSurface7_Blt returned %08x\n", hr);
2753
2754 hr = IDirect3DDevice7_SetTexture(device, 0, cubemap);
2755 ok(hr == DD_OK, "IDirect3DDevice7_SetTexture returned %08x\n", hr);
2756 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
2757 ok(hr == DD_OK, "IDirect3DDevice7_SetTextureStageState returned %08x\n", hr);
2758 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
2759 ok(hr == DD_OK, "IDirect3DDevice7_SetTextureStageState returned %08x\n", hr);
2760
2761 hr = IDirect3DDevice7_BeginScene(device);
2762 ok(hr == DD_OK, "IDirect3DDevice7_BeginScene returned %08x\n", hr);
2763 if(SUCCEEDED(hr))
2764 {
2765 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE3(0) | D3DFVF_TEX1, quad + 0 * 6, 4, 0);
2766 if (hr == DDERR_UNSUPPORTED || hr == DDERR_NODIRECTDRAWHW)
2767 {
2768 /* VMware */
2769 win_skip("IDirect3DDevice7_DrawPrimitive is not completely implemented, colors won't be tested\n");
2770 hr = IDirect3DDevice7_EndScene(device);
2771 ok(hr == DD_OK, "IDirect3DDevice7_EndScene returned %08x\n", hr);
2772 goto out;
2773 }
2774 ok(hr == DD_OK, "IDirect3DDevice7_DrawPrimitive returned %08x\n", hr);
2775 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE3(0) | D3DFVF_TEX1, quad + 4 * 6, 4, 0);
2776 ok(hr == DD_OK, "IDirect3DDevice7_DrawPrimitive returned %08x\n", hr);
2777 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE3(0) | D3DFVF_TEX1, quad + 8 * 6, 4, 0);
2778 ok(hr == DD_OK, "IDirect3DDevice7_DrawPrimitive returned %08x\n", hr);
2779 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE3(0) | D3DFVF_TEX1, quad + 12* 6, 4, 0);
2780 ok(hr == DD_OK, "IDirect3DDevice7_DrawPrimitive returned %08x\n", hr);
2781
2782 hr = IDirect3DDevice7_EndScene(device);
2783 ok(hr == DD_OK, "IDirect3DDevice7_EndScene returned %08x\n", hr);
2784 }
2785 hr = IDirect3DDevice7_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
2786 ok(hr == DD_OK, "IDirect3DDevice7_SetTextureStageState returned %08x\n", hr);
2787
2788 color = getPixelColor(device, 160, 360); /* lower left quad - positivex */
2789 ok(color == 0x00ff0000, "DDSCAPS2_CUBEMAP_POSITIVEX has color 0x%08x, expected 0x00ff0000\n", color);
2790 color = getPixelColor(device, 160, 120); /* upper left quad - negativex */
2791 ok(color == 0x0000ffff, "DDSCAPS2_CUBEMAP_NEGATIVEX has color 0x%08x, expected 0x0000ffff\n", color);
2792 color = getPixelColor(device, 480, 360); /* lower right quad - positivey */
2793 ok(color == 0x00ff00ff, "DDSCAPS2_CUBEMAP_POSITIVEY has color 0x%08x, expected 0x00ff00ff\n", color);
2794 color = getPixelColor(device, 480, 120); /* upper right quad - positivez */
2795 ok(color == 0x000000ff, "DDSCAPS2_CUBEMAP_POSITIVEZ has color 0x%08x, expected 0x000000ff\n", color);
2796
2797 out:
2798 hr = IDirect3DDevice7_SetTexture(device, 0, NULL);
2799 ok(hr == DD_OK, "IDirect3DDevice7_SetTexture returned %08x\n", hr);
2800 IDirectDrawSurface7_Release(cubemap);
2801 }
2802
2803 /* This test tests depth clamping / clipping behaviour:
2804 * - When D3DRS_CLIPPING is disabled depth values are *clamped* to the
2805 * minimum/maximum z value.
2806 * - The viewport's MinZ/MaxZ is irrelevant for this.
2807 * - When D3DRS_CLIPPING is enabled depth values are clipped.
2808 * - Pretransformed vertices behave the same as regular vertices.
2809 */
2810 static void depth_clamp_test(IDirect3DDevice7 *device)
2811 {
2812 struct tvertex quad1[] =
2813 {
2814 { 0, 0, 5.0f, 1.0, 0xff002b7f},
2815 { 640, 0, 5.0f, 1.0, 0xff002b7f},
2816 { 0, 480, 5.0f, 1.0, 0xff002b7f},
2817 { 640, 480, 5.0f, 1.0, 0xff002b7f},
2818 };
2819 struct tvertex quad2[] =
2820 {
2821 { 0, 300, 10.0f, 1.0, 0xfff9e814},
2822 { 640, 300, 10.0f, 1.0, 0xfff9e814},
2823 { 0, 360, 10.0f, 1.0, 0xfff9e814},
2824 { 640, 360, 10.0f, 1.0, 0xfff9e814},
2825 };
2826 struct vertex quad3[] =
2827 {
2828 {-0.65, 0.55, 5.0f, 0xffffffff},
2829 {-0.35, 0.55, 5.0f, 0xffffffff},
2830 {-0.65, 0.15, 5.0f, 0xffffffff},
2831 {-0.35, 0.15, 5.0f, 0xffffffff},
2832 };
2833 struct vertex quad4[] =
2834 {
2835 {-0.87, 0.83, 10.0f, 0xffffffff},
2836 {-0.65, 0.83, 10.0f, 0xffffffff},
2837 {-0.87, 0.55, 10.0f, 0xffffffff},
2838 {-0.65, 0.55, 10.0f, 0xffffffff},
2839 };
2840 struct vertex quad5[] =
2841 {
2842 { -0.5, 0.5, 10.0f, 0xff14f914},
2843 { 0.5, 0.5, 10.0f, 0xff14f914},
2844 { -0.5, -0.5, 10.0f, 0xff14f914},
2845 { 0.5, -0.5, 10.0f, 0xff14f914},
2846 };
2847 struct tvertex quad6[] =
2848 {
2849 { 0, 120, 10.0f, 1.0, 0xfff91414},
2850 { 640, 120, 10.0f, 1.0, 0xfff91414},
2851 { 0, 180, 10.0f, 1.0, 0xfff91414},
2852 { 640, 180, 10.0f, 1.0, 0xfff91414},
2853 };
2854
2855 D3DVIEWPORT7 vp;
2856 D3DCOLOR color;
2857 HRESULT hr;
2858
2859 vp.dwX = 0;
2860 vp.dwY = 0;
2861 vp.dwWidth = 640;
2862 vp.dwHeight = 480;
2863 vp.dvMinZ = 0.0;
2864 vp.dvMaxZ = 7.5;
2865
2866 hr = IDirect3DDevice7_SetViewport(device, &vp);
2867 ok(SUCCEEDED(hr), "SetViewport failed, hr %#x.\n", hr);
2868
2869 hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0, 0);
2870 ok(SUCCEEDED(hr), "Clear failed, hr %#x.\n", hr);
2871
2872 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CLIPPING, FALSE);
2873 ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
2874 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE);
2875 ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
2876 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZWRITEENABLE, TRUE);
2877 ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
2878 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZFUNC, D3DCMP_LESSEQUAL);
2879 ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
2880
2881 hr = IDirect3DDevice7_BeginScene(device);
2882 ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
2883
2884 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, quad1, 4, 0);
2885 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2886 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, quad2, 4, 0);
2887 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2888 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad3, 4, 0);
2889 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2890 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad4, 4, 0);
2891 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2892
2893 hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_CLIPPING, TRUE);
2894 ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
2895
2896 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZ | D3DFVF_DIFFUSE, quad5, 4, 0);
2897 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2898 hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, quad6, 4, 0);
2899 ok(SUCCEEDED(hr), "DrawPrimitive failed, hr %#x.\n", hr);
2900
2901 hr = IDirect3DDevice7_EndScene(device);
2902 ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
2903
2904 color = getPixelColor(device, 75, 75);
2905 ok(color_match(color, 0x00ffffff, 1), "color 0x%08x.\n", color);
2906 color = getPixelColor(device, 150, 150);
2907 ok(color_match(color, 0x00ffffff, 1) ||
2908 broken(color == 0x00f91414), /* Reference rasterizer */
2909 "color 0x%08x.\n", color);
2910 color = getPixelColor(device, 320, 240);
2911 ok(color_match(color, 0x00002b7f, 1), "color 0x%08x.\n", color);
2912 color = getPixelColor(device, 320, 330);
2913 ok(color_match(color, 0x00f9e814, 1), "color 0x%08x.\n", color);
2914 color = getPixelColor(device, 320, 330);
2915 ok(color_match(color, 0x00f9e814, 1), "color 0x%08x.\n", color);
2916
2917 vp.dvMinZ = 0.0;
2918 vp.dvMaxZ = 1.0;
2919 hr = IDirect3DDevice7_SetViewport(device, &vp);
2920 ok(SUCCEEDED(hr), "SetViewport failed, hr %#x.\n", hr);
2921 }
2922
2923 static void DX1_BackBufferFlipTest(void)
2924 {
2925 HRESULT hr;
2926 IDirectDraw *DirectDraw1 = NULL;
2927 IDirectDrawSurface *Primary = NULL;
2928 IDirectDrawSurface *Backbuffer = NULL;
2929 WNDCLASS wc = {0};
2930 DDSURFACEDESC ddsd;
2931 DDBLTFX ddbltfx;
2932 COLORREF color;
2933 const DWORD white = 0xffffff;
2934 const DWORD red = 0xff0000;
2935 BOOL attached = FALSE;
2936
2937 wc.lpfnWndProc = DefWindowProc;
2938 wc.lpszClassName = "DX1_BackBufferFlipTest_wc";
2939 RegisterClass(&wc);
2940 window = CreateWindow("DX1_BackBufferFlipTest_wc", "DX1_BackBufferFlipTest",
2941 WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
2942
2943 hr = DirectDrawCreate( NULL, &DirectDraw1, NULL );
2944 ok(hr==DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreate returned: %x\n", hr);
2945 if(FAILED(hr)) goto out;
2946
2947 hr = IDirectDraw_SetCooperativeLevel(DirectDraw1, window, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
2948 ok(hr==DD_OK, "SetCooperativeLevel returned: %x\n", hr);
2949 if(FAILED(hr)) goto out;
2950
2951 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 32);
2952 if(FAILED(hr)) {
2953 /* 24 bit is fine too */
2954 hr = IDirectDraw_SetDisplayMode(DirectDraw1, 640, 480, 24);
2955 }
2956 ok(hr==DD_OK || hr == DDERR_UNSUPPORTED, "SetDisplayMode returned: %x\n", hr);
2957 if (FAILED(hr)) {
2958 goto out;
2959 }
2960
2961 memset(&ddsd, 0, sizeof(DDSURFACEDESC));
2962 ddsd.dwSize = sizeof(DDSURFACEDESC);
2963 ddsd.dwFlags = DDSD_CAPS;
2964 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
2965
2966 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &Primary, NULL);
2967 ok(hr==DD_OK, "IDirectDraw_CreateSurface returned: %08x\n", hr);
2968
2969 memset(&ddsd, 0, sizeof(DDSURFACEDESC));
2970 ddsd.dwSize = sizeof(DDSURFACEDESC);
2971 ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
2972 ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
2973 ddsd.dwWidth = 640;
2974 ddsd.dwHeight = 480;
2975 ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
2976 ddsd.ddpfPixelFormat.dwFlags = DDPF_RGB;
2977 U1(ddsd.ddpfPixelFormat).dwRGBBitCount = 32;
2978 U2(ddsd.ddpfPixelFormat).dwRBitMask = 0x00ff0000;
2979 U3(ddsd.ddpfPixelFormat).dwGBitMask = 0x0000ff00;
2980 U4(ddsd.ddpfPixelFormat).dwBBitMask = 0x000000ff;
2981
2982 hr = IDirectDraw_CreateSurface(DirectDraw1, &ddsd, &Backbuffer, NULL);
2983 ok(hr==DD_OK, "IDirectDraw_CreateSurface returned: %08x\n", hr);
2984 if(FAILED(hr)) goto out;
2985
2986 hr = IDirectDrawSurface_AddAttachedSurface(Primary, Backbuffer);
2987 todo_wine ok(hr == DD_OK || broken(hr == DDERR_CANNOTATTACHSURFACE),
2988 "Attaching a back buffer to a front buffer returned %08x\n", hr);
2989 if (FAILED(hr)) goto out;
2990
2991 attached = TRUE;
2992
2993 memset(&ddbltfx, 0, sizeof(ddbltfx));
2994 ddbltfx.dwSize = sizeof(ddbltfx);
2995 U5(ddbltfx).dwFillColor = red;
2996 hr = IDirectDrawSurface_Blt(Backbuffer, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
2997 ok(hr == DD_OK, "IDirectDrawSurface_Blt returned: %x\n", hr);
2998
2999 U5(ddbltfx).dwFillColor = white;
3000 hr = IDirectDrawSurface_Blt(Primary, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
3001 ok(hr == DD_OK, "IDirectDrawSurface_Blt returned: %x\n", hr);
3002
3003 /* Check it out */
3004 color = getPixelColor_GDI(Primary, 5, 5);
3005 ok(GetRValue(color) == 0xFF && GetGValue(color) == 0xFF && GetBValue(color) == 0xFF,
3006 "got R %02X G %02X B %02X, expected R FF G FF B FF\n",
3007 GetRValue(color), GetGValue(color), GetBValue(color));
3008
3009 color = getPixelColor_GDI(Backbuffer, 5, 5);
3010 ok(GetRValue(color) == 0xFF && GetGValue(color) == 0 && GetBValue(color) == 0,
3011 "got R %02X G %02X B %02X, expected R FF G 00 B 00\n",
3012 GetRValue(color), GetGValue(color), GetBValue(color));
3013
3014 hr = IDirectDrawSurface_Flip(Primary, NULL, DDFLIP_WAIT);
3015 todo_wine ok(hr == DD_OK, "IDirectDrawSurface_Flip returned 0x%08x\n", hr);
3016
3017 if (hr == DD_OK)
3018 {
3019 color = getPixelColor_GDI(Primary, 5, 5);
3020 ok(GetRValue(color) == 0xFF && GetGValue(color) == 0 && GetBValue(color) == 0,
3021 "got R %02X G %02X B %02X, expected R FF G 00 B 00\n",
3022 GetRValue(color), GetGValue(color), GetBValue(color));
3023
3024 color = getPixelColor_GDI(Backbuffer, 5, 5);
3025 ok((GetRValue(color) == 0xFF && GetGValue(color) == 0xFF && GetBValue(color) == 0xFF) ||
3026 broken(GetRValue(color) == 0xFF && GetGValue(color) == 0 && GetBValue(color) == 0), /* broken driver */
3027 "got R %02X G %02X B %02X, expected R FF G FF B FF\n",
3028 GetRValue(color), GetGValue(color), GetBValue(color));
3029 }
3030
3031 out:
3032
3033 if (Backbuffer)
3034 {
3035 if (attached)
3036 IDirectDrawSurface_DeleteAttachedSurface(Primary, 0, Backbuffer);
3037 IDirectDrawSurface_Release(Backbuffer);
3038 }
3039 if (Primary) IDirectDrawSurface_Release(Primary);
3040 if (DirectDraw1) IDirectDraw_Release(DirectDraw1);
3041 if (window) DestroyWindow(window);
3042 }
3043
3044 START_TEST(visual)
3045 {
3046 HRESULT hr;
3047 DWORD color;
3048 if(!createObjects())
3049 {
3050 skip("Cannot initialize DirectDraw and Direct3D, skipping\n");
3051 return;
3052 }
3053
3054 /* Check for the reliability of the returned data */
3055 hr = IDirect3DDevice7_Clear(Direct3DDevice, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3056 if(FAILED(hr))
3057 {
3058 skip("Clear failed, can't assure correctness of the test results, skipping\n");
3059 goto cleanup;
3060 }
3061
3062 color = getPixelColor(Direct3DDevice, 1, 1);
3063 if(color !=0x00ff0000)
3064 {
3065 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
3066 goto cleanup;
3067 }
3068
3069 hr = IDirect3DDevice7_Clear(Direct3DDevice, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
3070 if(FAILED(hr))
3071 {
3072 skip("Clear failed, can't assure correctness of the test results, skipping\n");
3073 goto cleanup;
3074 }
3075
3076 color = getPixelColor(Direct3DDevice, 639, 479);
3077 if(color != 0x0000ddee)
3078 {
3079 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
3080 goto cleanup;
3081 }
3082
3083 /* Now run the tests */
3084 blt_test(Direct3DDevice);
3085 depth_clamp_test(Direct3DDevice);
3086 lighting_test(Direct3DDevice);
3087 clear_test(Direct3DDevice);
3088 fog_test(Direct3DDevice);
3089 offscreen_test(Direct3DDevice);
3090 alpha_test(Direct3DDevice);
3091 rhw_zero_test(Direct3DDevice);
3092 cubemap_test(Direct3DDevice);
3093
3094 releaseObjects(); /* release DX7 interfaces to test D3D1 */
3095
3096 if(!D3D1_createObjects()) {
3097 skip("Cannot initialize D3D1, skipping\n");
3098 }
3099 else {
3100 D3D1_TextureMapBlendTest();
3101 D3D1_ViewportClearTest();
3102 }
3103 D3D1_releaseObjects();
3104
3105 D3D3_ViewportClearTest();
3106 p8_primary_test();
3107 DX1_BackBufferFlipTest();
3108
3109 return ;
3110
3111 cleanup:
3112 releaseObjects();
3113 }
GSOC 2012 project to enhance the control panel