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