2 * Copyright 2005, 2007 Henri Verbeet
3 * Copyright (C) 2007 Stefan Dösinger(for CodeWeavers)
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.
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.
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
20 /* This test framework allows limited testing of rendering results. Things are rendered, shown on
21 * the framebuffer, read back from there and compared to expected colors.
23 * However, neither d3d nor opengl is guaranteed to be pixel exact, and thus the capability of this test
24 * is rather limited. As a general guideline for adding tests, do not rely on corner pixels. Draw a big enough
25 * area which shows specific behavior(like a quad on the whole screen), and try to get resulting colos with
26 * all bits set or unset in all channels(like pure red, green, blue, white, black). Hopefully everything that
27 * causes visible results in games can be tested in a way that does not depend on pixel exactness
33 #include "wine/test.h"
35 static HMODULE d3d9_handle
= 0;
37 static HWND
create_window(void)
41 wc
.lpfnWndProc
= &DefWindowProc
;
42 wc
.lpszClassName
= "d3d9_test_wc";
45 ret
= CreateWindow("d3d9_test_wc", "d3d9_test",
46 WS_MAXIMIZE
| WS_VISIBLE
| WS_CAPTION
, 0, 0, 640, 480, 0, 0, 0, 0);
50 static DWORD
getPixelColor(IDirect3DDevice9
*device
, UINT x
, UINT y
)
53 IDirect3DSurface9
*surf
;
55 D3DLOCKED_RECT lockedRect
;
56 RECT rectToLock
= {x
, y
, x
+1, y
+1};
58 hr
= IDirect3DDevice9_CreateOffscreenPlainSurface(device
, 640, 480, D3DFMT_A8R8G8B8
, D3DPOOL_SYSTEMMEM
, &surf
, NULL
);
59 if(FAILED(hr
) || !surf
) /* This is not a test */
61 trace("Can't create an offscreen plain surface to read the render target data, hr=%s\n", DXGetErrorString9(hr
));
65 hr
= IDirect3DDevice9_GetFrontBufferData(device
, 0, surf
);
68 trace("Can't read the front buffer data, hr=%s\n", DXGetErrorString9(hr
));
73 hr
= IDirect3DSurface9_LockRect(surf
, &lockedRect
, &rectToLock
, D3DLOCK_READONLY
);
76 trace("Can't lock the offscreen surface, hr=%s\n", DXGetErrorString9(hr
));
81 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
82 * really important for these tests
84 ret
= ((DWORD
*) lockedRect
.pBits
)[0] & 0x00ffffff;
85 hr
= IDirect3DSurface9_UnlockRect(surf
);
88 trace("Can't unlock the offscreen surface, hr=%s\n", DXGetErrorString9(hr
));
92 if(surf
) IDirect3DSurface9_Release(surf
);
96 static IDirect3DDevice9
*init_d3d9(void)
98 IDirect3D9
* (__stdcall
* d3d9_create
)(UINT SDKVersion
) = 0;
99 IDirect3D9
*d3d9_ptr
= 0;
100 IDirect3DDevice9
*device_ptr
= 0;
101 D3DPRESENT_PARAMETERS present_parameters
;
104 d3d9_create
= (void *)GetProcAddress(d3d9_handle
, "Direct3DCreate9");
105 ok(d3d9_create
!= NULL
, "Failed to get address of Direct3DCreate9\n");
106 if (!d3d9_create
) return NULL
;
108 d3d9_ptr
= d3d9_create(D3D_SDK_VERSION
);
109 ok(d3d9_ptr
!= NULL
, "Failed to create IDirect3D9 object\n");
110 if (!d3d9_ptr
) return NULL
;
112 ZeroMemory(&present_parameters
, sizeof(present_parameters
));
113 present_parameters
.Windowed
= FALSE
;
114 present_parameters
.hDeviceWindow
= create_window();
115 present_parameters
.SwapEffect
= D3DSWAPEFFECT_DISCARD
;
116 present_parameters
.BackBufferWidth
= 640;
117 present_parameters
.BackBufferHeight
= 480;
118 present_parameters
.BackBufferFormat
= D3DFMT_X8R8G8B8
;
119 present_parameters
.EnableAutoDepthStencil
= TRUE
;
120 present_parameters
.AutoDepthStencilFormat
= D3DFMT_D16
;
122 hr
= IDirect3D9_CreateDevice(d3d9_ptr
, D3DADAPTER_DEFAULT
, D3DDEVTYPE_HAL
, present_parameters
.hDeviceWindow
, D3DCREATE_SOFTWARE_VERTEXPROCESSING
, &present_parameters
, &device_ptr
);
123 ok(hr
== D3D_OK
, "IDirect3D_CreateDevice returned: %s\n", DXGetErrorString9(hr
));
141 static void lighting_test(IDirect3DDevice9
*device
)
144 DWORD fvf
= D3DFVF_XYZ
| D3DFVF_DIFFUSE
;
145 DWORD nfvf
= D3DFVF_XYZ
| D3DFVF_DIFFUSE
| D3DFVF_NORMAL
;
148 float mat
[16] = { 1.0f
, 0.0f
, 0.0f
, 0.0f
,
149 0.0f
, 1.0f
, 0.0f
, 0.0f
,
150 0.0f
, 0.0f
, 1.0f
, 0.0f
,
151 0.0f
, 0.0f
, 0.0f
, 1.0f
};
153 struct vertex unlitquad
[] =
155 {-1.0f
, -1.0f
, 0.1f
, 0xffff0000},
156 {-1.0f
, 0.0f
, 0.1f
, 0xffff0000},
157 { 0.0f
, 0.0f
, 0.1f
, 0xffff0000},
158 { 0.0f
, -1.0f
, 0.1f
, 0xffff0000},
160 struct vertex litquad
[] =
162 {-1.0f
, 0.0f
, 0.1f
, 0xff00ff00},
163 {-1.0f
, 1.0f
, 0.1f
, 0xff00ff00},
164 { 0.0f
, 1.0f
, 0.1f
, 0xff00ff00},
165 { 0.0f
, 0.0f
, 0.1f
, 0xff00ff00},
167 struct nvertex unlitnquad
[] =
169 { 0.0f
, -1.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xff0000ff},
170 { 0.0f
, 0.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xff0000ff},
171 { 1.0f
, 0.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xff0000ff},
172 { 1.0f
, -1.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xff0000ff},
174 struct nvertex litnquad
[] =
176 { 0.0f
, 0.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xffffff00},
177 { 0.0f
, 1.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xffffff00},
178 { 1.0f
, 1.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xffffff00},
179 { 1.0f
, 0.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 0xffffff00},
181 WORD Indices
[] = {0, 1, 2, 2, 3, 0};
183 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffffffff, 0.0, 0);
184 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr
));
186 /* Setup some states that may cause issues */
187 hr
= IDirect3DDevice9_SetTransform(device
, D3DTS_WORLDMATRIX(0), (D3DMATRIX
*) mat
);
188 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr
));
189 hr
= IDirect3DDevice9_SetTransform(device
, D3DTS_VIEW
, (D3DMATRIX
*)mat
);
190 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr
));
191 hr
= IDirect3DDevice9_SetTransform(device
, D3DTS_PROJECTION
, (D3DMATRIX
*) mat
);
192 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr
));
193 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_CLIPPING
, FALSE
);
194 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
195 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ZENABLE
, FALSE
);
196 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
197 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGENABLE
, FALSE
);
198 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
199 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_STENCILENABLE
, FALSE
);
200 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
201 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ALPHATESTENABLE
, FALSE
);
202 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
203 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ALPHABLENDENABLE
, FALSE
);
204 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
205 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_SCISSORTESTENABLE
, FALSE
);
206 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
207 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_CULLMODE
, D3DCULL_NONE
);
208 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr
));
209 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_COLORWRITEENABLE
, D3DCOLORWRITEENABLE_RED
| D3DCOLORWRITEENABLE_GREEN
| D3DCOLORWRITEENABLE_BLUE
);
210 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr
));
212 hr
= IDirect3DDevice9_SetFVF(device
, fvf
);
213 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr
));
215 hr
= IDirect3DDevice9_BeginScene(device
);
216 ok(hr
== D3D_OK
, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr
));
219 /* No lights are defined... That means, lit vertices should be entirely black */
220 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
221 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
222 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
223 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, unlitquad
, sizeof(unlitquad
[0]));
224 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr
));
226 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, TRUE
);
227 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
228 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
229 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, litquad
, sizeof(litquad
[0]));
230 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr
));
232 hr
= IDirect3DDevice9_SetFVF(device
, nfvf
);
233 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr
));
235 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
236 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
237 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
238 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, unlitnquad
, sizeof(unlitnquad
[0]));
239 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr
));
241 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, TRUE
);
242 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
243 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
244 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, litnquad
, sizeof(litnquad
[0]));
245 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr
));
247 IDirect3DDevice9_EndScene(device
);
248 ok(hr
== D3D_OK
, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr
));
251 IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
253 color
= getPixelColor(device
, 160, 360); /* lower left quad - unlit without normals */
254 ok(color
== 0x00ff0000, "Unlit quad without normals has color %08x\n", color
);
255 color
= getPixelColor(device
, 160, 120); /* upper left quad - lit without normals */
256 ok(color
== 0x00000000, "Lit quad without normals has color %08x\n", color
);
257 color
= getPixelColor(device
, 480, 360); /* lower left quad - unlit width normals */
258 ok(color
== 0x000000ff, "Unlit quad width normals has color %08x\n", color
);
259 color
= getPixelColor(device
, 480, 120); /* upper left quad - lit width normals */
260 ok(color
== 0x00000000, "Lit quad width normals has color %08x\n", color
);
262 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
263 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
266 static void clear_test(IDirect3DDevice9
*device
)
268 /* Tests the correctness of clearing parameters */
274 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffffffff, 0.0, 0);
275 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr
));
277 /* Positive x, negative y */
283 /* Positive x, positive y */
288 /* Clear 2 rectangles with one call. Shows that a positive value is returned, but the negative rectangle
289 * is ignored, the positive is still cleared afterwards
291 hr
= IDirect3DDevice9_Clear(device
, 2, rect
, D3DCLEAR_TARGET
, 0xffff0000, 0.0, 0);
292 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr
));
294 /* negative x, negative y */
295 rect_negneg
.x1
= 640;
296 rect_negneg
.x1
= 240;
297 rect_negneg
.x2
= 320;
299 hr
= IDirect3DDevice9_Clear(device
, 1, &rect_negneg
, D3DCLEAR_TARGET
, 0xff00ff00, 0.0, 0);
300 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr
));
302 IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
304 color
= getPixelColor(device
, 160, 360); /* lower left quad */
305 ok(color
== 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color
);
306 color
= getPixelColor(device
, 160, 120); /* upper left quad */
307 ok(color
== 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color
);
308 color
= getPixelColor(device
, 480, 360); /* lower right quad */
309 ok(color
== 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color
);
310 color
= getPixelColor(device
, 480, 120); /* upper right quad */
311 ok(color
== 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color
);
328 static void test_mova(IDirect3DDevice9
*device
)
330 static const DWORD mova_test
[] = {
331 0xfffe0200, /* vs_2_0 */
332 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
333 0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
334 0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
335 0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
336 0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
337 0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
338 0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
339 0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
340 0x0200002e, 0xb0010000, 0xa0000007, /* mova a0.x, c7.x */
341 0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000, /* mov oD0, c[a0.x + 3] */
342 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
346 static const test_data_t test_data
[] = {
347 {{-2.4f
, 0.0f
, 0.0f
, 0.0f
}, 0x00ffff00},
348 {{-1.6f
, 0.0f
, 0.0f
, 0.0f
}, 0x00ffff00},
349 {{-0.4f
, 0.0f
, 0.0f
, 0.0f
}, 0x0000ffff},
350 {{ 0.4f
, 0.0f
, 0.0f
, 0.0f
}, 0x0000ffff},
351 {{ 1.6f
, 0.0f
, 0.0f
, 0.0f
}, 0x00ff00ff},
352 {{ 2.4f
, 0.0f
, 0.0f
, 0.0f
}, 0x00ff00ff}
355 static const float quad
[][3] = {
356 {-1.0f
, -1.0f
, 0.0f
},
358 { 1.0f
, -1.0f
, 0.0f
},
362 static const D3DVERTEXELEMENT9 decl_elements
[] = {
363 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
367 IDirect3DVertexDeclaration9
*vertex_declaration
= NULL
;
368 IDirect3DVertexShader9
*mova_shader
= NULL
;
372 hr
= IDirect3DDevice9_CreateVertexShader(device
, mova_test
, &mova_shader
);
373 ok(SUCCEEDED(hr
), "CreateVertexShader failed (%08x)\n", hr
);
374 hr
= IDirect3DDevice9_SetVertexShader(device
, mova_shader
);
375 ok(SUCCEEDED(hr
), "SetVertexShader failed (%08x)\n", hr
);
377 hr
= IDirect3DDevice9_CreateVertexDeclaration(device
, decl_elements
, &vertex_declaration
);
378 ok(SUCCEEDED(hr
), "CreateVertexDeclaration failed (%08x)\n", hr
);
379 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, vertex_declaration
);
380 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (%08x)\n", hr
);
382 for (i
= 0; i
< (sizeof(test_data
) / sizeof(test_data_t
)); ++i
)
386 hr
= IDirect3DDevice9_SetVertexShaderConstantF(device
, 7, test_data
[i
].in
, 1);
387 ok(SUCCEEDED(hr
), "SetVertexShaderConstantF failed (%08x)\n", hr
);
389 hr
= IDirect3DDevice9_BeginScene(device
);
390 ok(SUCCEEDED(hr
), "BeginScene failed (%08x)\n", hr
);
392 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2, &quad
[0], 3 * sizeof(float));
393 ok(SUCCEEDED(hr
), "DrawPrimitiveUP failed (%08x)\n", hr
);
395 hr
= IDirect3DDevice9_EndScene(device
);
396 ok(SUCCEEDED(hr
), "EndScene failed (%08x)\n", hr
);
398 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
399 ok(SUCCEEDED(hr
), "Present failed (%08x)\n", hr
);
401 color
= getPixelColor(device
, 320, 240);
402 ok(color
== test_data
[i
].out
, "Expected color %08x, got %08x (for input %f)\n", test_data
[i
].out
, color
, test_data
[i
].in
[0]);
404 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0, 0.0f
, 0);
405 ok(SUCCEEDED(hr
), "Clear failed (%08x)\n", hr
);
408 hr
= IDirect3DDevice9_SetVertexShader(device
, NULL
);
409 ok(SUCCEEDED(hr
), "SetVertexShader failed (%08x)\n", hr
);
411 IDirect3DVertexDeclaration9_Release(vertex_declaration
);
412 IDirect3DVertexShader9_Release(mova_shader
);
427 static void fog_test(IDirect3DDevice9
*device
)
431 float start
= 0.0f
, end
= 1.0f
;
434 /* Gets full z based fog with linear fog, no fog with specular color */
435 struct sVertex unstransformed_1
[] = {
436 {-1, -1, 0.1f
, 0xFFFF0000, 0xFF000000 },
437 {-1, 0, 0.1f
, 0xFFFF0000, 0xFF000000 },
438 { 0, 0, 0.1f
, 0xFFFF0000, 0xFF000000 },
439 { 0, -1, 0.1f
, 0xFFFF0000, 0xFF000000 },
441 /* Ok, I am too lazy to deal with transform matrices */
442 struct sVertex unstransformed_2
[] = {
443 {-1, 0, 1.0f
, 0xFFFF0000, 0xFF000000 },
444 {-1, 1, 1.0f
, 0xFFFF0000, 0xFF000000 },
445 { 0, 1, 1.0f
, 0xFFFF0000, 0xFF000000 },
446 { 0, 0, 1.0f
, 0xFFFF0000, 0xFF000000 },
448 /* Untransformed ones. Give them a different diffuse color to make the test look
449 * nicer. It also makes making sure that they are drawn correctly easier.
451 struct sVertexT transformed_1
[] = {
452 {320, 0, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
453 {640, 0, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
454 {640, 240, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
455 {320, 240, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
457 struct sVertexT transformed_2
[] = {
458 {320, 240, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
459 {640, 240, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
460 {640, 480, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
461 {320, 480, 1.0f
, 1.0f
, 0xFFFFFF00, 0xFF000000 },
463 WORD Indices
[] = {0, 1, 2, 2, 3, 0};
465 memset(&caps
, 0, sizeof(caps
));
466 hr
= IDirect3DDevice9_GetDeviceCaps(device
, &caps
);
467 ok(hr
== D3D_OK
, "IDirect3DDevice9_GetDeviceCaps returned %s\n", DXGetErrorString9(hr
));
468 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffff00ff, 0.0, 0);
469 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr
));
471 /* Setup initial states: No lighting, fog on, fog color */
472 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
473 ok(hr
== D3D_OK
, "Turning off lighting returned %s\n", DXGetErrorString9(hr
));
474 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGENABLE
, TRUE
);
475 ok(hr
== D3D_OK
, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr
));
476 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGCOLOR
, 0xFF00FF00 /* A nice green */);
477 ok(hr
== D3D_OK
, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr
));
479 /* First test: Both table fog and vertex fog off */
480 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGTABLEMODE
, D3DFOG_NONE
);
481 ok(hr
== D3D_OK
, "Turning off table fog returned %s\n", DXGetErrorString9(hr
));
482 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGVERTEXMODE
, D3DFOG_NONE
);
483 ok(hr
== D3D_OK
, "Turning off table fog returned %s\n", DXGetErrorString9(hr
));
485 /* Start = 0, end = 1. Should be default, but set them */
486 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGSTART
, *((DWORD
*) &start
));
487 ok(hr
== D3D_OK
, "Setting fog start returned %s\n", DXGetErrorString9(hr
));
488 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGEND
, *((DWORD
*) &end
));
489 ok(hr
== D3D_OK
, "Setting fog start returned %s\n", DXGetErrorString9(hr
));
491 if(IDirect3DDevice9_BeginScene(device
) == D3D_OK
)
493 hr
= IDirect3DDevice9_SetFVF(device
, D3DFVF_XYZ
| D3DFVF_DIFFUSE
| D3DFVF_SPECULAR
);
494 ok( hr
== D3D_OK
, "SetFVF returned %s\n", DXGetErrorString9(hr
));
495 /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
496 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
497 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, unstransformed_1
,
498 sizeof(unstransformed_1
[0]));
499 ok(hr
== D3D_OK
, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr
));
501 /* That makes it use the Z value */
502 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGVERTEXMODE
, D3DFOG_LINEAR
);
503 ok(hr
== D3D_OK
, "Turning off table fog returned %s\n", DXGetErrorString9(hr
));
504 /* Untransformed, vertex fog != none (or table fog != none):
505 * Use the Z value as input into the equation
507 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
508 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, unstransformed_2
,
509 sizeof(unstransformed_1
[0]));
510 ok(hr
== D3D_OK
, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr
));
512 /* transformed verts */
513 hr
= IDirect3DDevice9_SetFVF(device
, D3DFVF_XYZRHW
| D3DFVF_DIFFUSE
| D3DFVF_SPECULAR
);
514 ok( hr
== D3D_OK
, "SetFVF returned %s\n", DXGetErrorString9(hr
));
515 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
516 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
517 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, transformed_1
,
518 sizeof(transformed_1
[0]));
519 ok(hr
== D3D_OK
, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr
));
521 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGTABLEMODE
, D3DFOG_LINEAR
);
522 ok( hr
== D3D_OK
, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr
));
523 /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
526 hr
= IDirect3DDevice9_DrawIndexedPrimitiveUP(device
, D3DPT_TRIANGLELIST
, 0 /* MinIndex */, 4 /* NumVerts */,
527 2 /*PrimCount */, Indices
, D3DFMT_INDEX16
, transformed_2
,
528 sizeof(transformed_2
[0]));
530 hr
= IDirect3DDevice9_EndScene(device
);
531 ok(hr
== D3D_OK
, "EndScene returned %s\n", DXGetErrorString9(hr
));
535 ok(FALSE
, "BeginScene failed\n");
538 IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
539 color
= getPixelColor(device
, 160, 360);
540 ok(color
== 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color
);
541 color
= getPixelColor(device
, 160, 120);
542 ok(color
== 0x0000FF00, "Untransformed vertex with linear vertex fog has color %08x\n", color
);
543 color
= getPixelColor(device
, 480, 120);
544 ok(color
== 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color
);
545 if(caps
.RasterCaps
& D3DPRASTERCAPS_FOGTABLE
)
547 color
= getPixelColor(device
, 480, 360);
548 ok(color
== 0x0000FF00, "Transformed vertex with linear table fog has color %08x\n", color
);
552 /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
553 * The settings above result in no fogging with vertex fog
555 color
= getPixelColor(device
, 480, 120);
556 ok(color
== 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color
);
557 trace("Info: Table fog not supported by this device\n");
560 /* Turn off the fog master switch to avoid confusing other tests */
561 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGENABLE
, FALSE
);
562 ok(hr
== D3D_OK
, "Turning off fog calculations returned %s\n", DXGetErrorString9(hr
));
565 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
566 * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
567 * regardless of the actual addressing mode set. */
568 static void test_cube_wrap(IDirect3DDevice9
*device
)
570 static const float quad
[][6] = {
571 {-1.0f
, -1.0f
, 0.0f
, 1.0f
, 1.0f
, 1.0f
},
572 {-1.0f
, 1.0f
, 0.0f
, 1.0f
, 1.0f
, 1.0f
},
573 { 1.0f
, -1.0f
, 0.0f
, 1.0f
, 1.0f
, 1.0f
},
574 { 1.0f
, 1.0f
, 0.0f
, 1.0f
, 1.0f
, 1.0f
},
577 static const D3DVERTEXELEMENT9 decl_elements
[] = {
578 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
579 {0, 12, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 0},
583 static const struct {
584 D3DTEXTUREADDRESS mode
;
586 } address_modes
[] = {
587 {D3DTADDRESS_WRAP
, "D3DTADDRESS_WRAP"},
588 {D3DTADDRESS_MIRROR
, "D3DTADDRESS_MIRROR"},
589 {D3DTADDRESS_CLAMP
, "D3DTADDRESS_CLAMP"},
590 {D3DTADDRESS_BORDER
, "D3DTADDRESS_BORDER"},
591 {D3DTADDRESS_MIRRORONCE
, "D3DTADDRESS_MIRRORONCE"},
594 IDirect3DVertexDeclaration9
*vertex_declaration
= NULL
;
595 IDirect3DCubeTexture9
*texture
= NULL
;
596 IDirect3DSurface9
*surface
= NULL
;
597 D3DLOCKED_RECT locked_rect
;
601 hr
= IDirect3DDevice9_CreateVertexDeclaration(device
, decl_elements
, &vertex_declaration
);
602 ok(SUCCEEDED(hr
), "CreateVertexDeclaration failed (0x%08x)\n", hr
);
603 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, vertex_declaration
);
604 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (0x%08x)\n", hr
);
606 hr
= IDirect3DDevice9_CreateOffscreenPlainSurface(device
, 128, 128,
607 D3DFMT_A8R8G8B8
, D3DPOOL_SYSTEMMEM
, &surface
, NULL
);
608 ok(SUCCEEDED(hr
), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr
);
610 hr
= IDirect3DSurface9_LockRect(surface
, &locked_rect
, NULL
, D3DLOCK_DISCARD
);
611 ok(SUCCEEDED(hr
), "LockRect failed (0x%08x)\n", hr
);
613 for (y
= 0; y
< 128; ++y
)
615 DWORD
*ptr
= (DWORD
*)(((BYTE
*)locked_rect
.pBits
) + (y
* locked_rect
.Pitch
));
616 for (x
= 0; x
< 64; ++x
)
620 for (x
= 64; x
< 128; ++x
)
626 hr
= IDirect3DSurface9_UnlockRect(surface
);
627 ok(SUCCEEDED(hr
), "UnlockRect failed (0x%08x)\n", hr
);
629 hr
= IDirect3DDevice9_CreateCubeTexture(device
, 128, 1, 0, D3DFMT_A8R8G8B8
,
630 D3DPOOL_DEFAULT
, &texture
, NULL
);
631 ok(SUCCEEDED(hr
), "CreateCubeTexture failed (0x%08x)\n", hr
);
633 /* Create cube faces */
634 for (face
= 0; face
< 6; ++face
)
636 IDirect3DSurface9
*face_surface
= NULL
;
638 hr
= IDirect3DCubeTexture9_GetCubeMapSurface(texture
, face
, 0, &face_surface
);
639 ok(SUCCEEDED(hr
), "GetCubeMapSurface failed (0x%08x)\n", hr
);
641 hr
= IDirect3DDevice9_UpdateSurface(device
, surface
, NULL
, face_surface
, NULL
);
642 ok(SUCCEEDED(hr
), "UpdateSurface failed (0x%08x)\n", hr
);
644 IDirect3DSurface9_Release(face_surface
);
647 hr
= IDirect3DDevice9_SetTexture(device
, 0, (IDirect3DBaseTexture9
*)texture
);
648 ok(SUCCEEDED(hr
), "SetTexture failed (0x%08x)\n", hr
);
650 hr
= IDirect3DDevice9_SetSamplerState(device
, 0, D3DSAMP_MINFILTER
, D3DTEXF_LINEAR
);
651 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr
);
652 hr
= IDirect3DDevice9_SetSamplerState(device
, 0, D3DSAMP_MAGFILTER
, D3DTEXF_LINEAR
);
653 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr
);
654 hr
= IDirect3DDevice9_SetSamplerState(device
, 0, D3DSAMP_BORDERCOLOR
, 0xff00ff00);
655 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr
);
657 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
658 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
660 for (x
= 0; x
< (sizeof(address_modes
) / sizeof(*address_modes
)); ++x
)
664 hr
= IDirect3DDevice9_SetSamplerState(device
, 0, D3DSAMP_ADDRESSU
, address_modes
[x
].mode
);
665 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes
[x
].name
, hr
);
666 hr
= IDirect3DDevice9_SetSamplerState(device
, 0, D3DSAMP_ADDRESSV
, address_modes
[x
].mode
);
667 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes
[x
].name
, hr
);
669 hr
= IDirect3DDevice9_BeginScene(device
);
670 ok(SUCCEEDED(hr
), "BeginScene failed (0x%08x)\n", hr
);
672 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2, &quad
[0], sizeof(quad
[0]));
673 ok(SUCCEEDED(hr
), "DrawPrimitiveUP failed (0x%08x)\n", hr
);
675 hr
= IDirect3DDevice9_EndScene(device
);
676 ok(SUCCEEDED(hr
), "EndScene failed (0x%08x)\n", hr
);
678 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
679 ok(SUCCEEDED(hr
), "Present failed (0x%08x)\n", hr
);
681 /* Due to the nature of this test, we sample essentially at the edge
682 * between two faces. Because of this it's undefined from which face
683 * the driver will sample. Furtunately that's not important for this
684 * test, since all we care about is that it doesn't sample from the
685 * other side of the surface or from the border. */
686 color
= getPixelColor(device
, 320, 240);
687 ok(color
== 0x00ff0000 || color
== 0x000000ff,
688 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
689 color
, address_modes
[x
].name
);
691 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0, 0.0f
, 0);
692 ok(SUCCEEDED(hr
), "Clear failed (0x%08x)\n", hr
);
695 hr
= IDirect3DDevice9_SetTexture(device
, 0, NULL
);
696 ok(SUCCEEDED(hr
), "SetTexture failed (0x%08x)\n", hr
);
698 IDirect3DVertexDeclaration9_Release(vertex_declaration
);
699 IDirect3DCubeTexture9_Release(texture
);
700 IDirect3DSurface9_Release(surface
);
703 /* This test tests fog in combination with shaders.
704 * What's tested: linear fog (vertex and table) with pixel shader
705 * linear table fog with non foggy vertex shader
706 * vertex fog with foggy vertex shader
707 * What's not tested: non linear fog with shader
708 * table fog with foggy vertex shader
710 static void fog_with_shader_test(IDirect3DDevice9
*device
)
720 /* basic vertex shader without fog computation ("non foggy") */
721 static const DWORD vertex_shader_code1
[] = {
722 0xfffe0101, /* vs_1_1 */
723 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
724 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
725 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
726 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
729 /* basic vertex shader with reversed fog computation ("foggy") */
730 static const DWORD vertex_shader_code2
[] = {
731 0xfffe0101, /* vs_1_1 */
732 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
733 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
734 0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
735 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
736 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
737 0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000, /* add r0, v0.z, c0.z */
738 0x00000005, 0xc00f0001, 0x80000000, 0xa0000000, /* mul oFog, r0.x, c0.x */
741 /* basic pixel shader */
742 static const DWORD pixel_shader_code
[] = {
743 0xffff0101, /* ps_1_1 */
744 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, vo */
748 static struct vertex quad
[] = {
749 {-1.0f
, -1.0f
, 0.0f
, 0xFFFF0000 },
750 {-1.0f
, 1.0f
, 0.0f
, 0xFFFF0000 },
751 { 1.0f
, -1.0f
, 0.0f
, 0xFFFF0000 },
752 { 1.0f
, 1.0f
, 0.0f
, 0xFFFF0000 },
755 static const D3DVERTEXELEMENT9 decl_elements
[] = {
756 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
757 {0, 12, D3DDECLTYPE_D3DCOLOR
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_COLOR
, 0},
761 IDirect3DVertexDeclaration9
*vertex_declaration
= NULL
;
762 IDirect3DVertexShader9
*vertex_shader
[3] = {NULL
, NULL
, NULL
};
763 IDirect3DPixelShader9
*pixel_shader
[2] = {NULL
, NULL
};
765 /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
766 static const struct test_data_t
{
771 unsigned int color
[11];
773 /* only pixel shader: */
775 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
776 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
778 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
779 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
781 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
782 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
784 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
785 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
787 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
788 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
792 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
793 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
795 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
796 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
798 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
799 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
801 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
802 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
804 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
805 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
807 /* vertex shader and pixel shader */
809 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
810 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
812 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
813 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
815 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
816 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
818 {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
819 0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00ff0000}},
821 /* foggy vertex shader */
823 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
824 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
826 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
827 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
829 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
830 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
832 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
833 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
835 /* foggy vertex shader and pixel shader */
837 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
838 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
840 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
841 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
843 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
844 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
846 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
847 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
851 /* NOTE: changing these values will not affect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
855 hr
= IDirect3DDevice9_CreateVertexShader(device
, vertex_shader_code1
, &vertex_shader
[1]);
856 ok(SUCCEEDED(hr
), "CreateVertexShader failed (%08x)\n", hr
);
857 hr
= IDirect3DDevice9_CreateVertexShader(device
, vertex_shader_code2
, &vertex_shader
[2]);
858 ok(SUCCEEDED(hr
), "CreateVertexShader failed (%08x)\n", hr
);
859 hr
= IDirect3DDevice9_CreatePixelShader(device
, pixel_shader_code
, &pixel_shader
[1]);
860 ok(SUCCEEDED(hr
), "CreatePixelShader failed (%08x)\n", hr
);
861 hr
= IDirect3DDevice9_CreateVertexDeclaration(device
, decl_elements
, &vertex_declaration
);
862 ok(SUCCEEDED(hr
), "CreateVertexDeclaration failed (%08x)\n", hr
);
864 /* Setup initial states: No lighting, fog on, fog color */
865 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_LIGHTING
, FALSE
);
866 ok(hr
== D3D_OK
, "Turning off lighting failed (%08x)\n", hr
);
867 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGENABLE
, TRUE
);
868 ok(hr
== D3D_OK
, "Turning on fog calculations failed (%08x)\n", hr
);
869 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGCOLOR
, 0xFF00FF00 /* A nice green */);
870 ok(hr
== D3D_OK
, "Setting fog color failed (%08x)\n", hr
);
871 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, vertex_declaration
);
872 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (%08x)\n", hr
);
874 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGTABLEMODE
, D3DFOG_NONE
);
875 ok(hr
== D3D_OK
, "Turning off table fog failed (%08x)\n", hr
);
876 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGVERTEXMODE
, D3DFOG_NONE
);
877 ok(hr
== D3D_OK
, "Turning off vertex fog failed (%08x)\n", hr
);
879 /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
880 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGSTART
, start
.i
);
881 ok(hr
== D3D_OK
, "Setting fog start failed (%08x)\n", hr
);
882 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGEND
, end
.i
);
883 ok(hr
== D3D_OK
, "Setting fog end failed (%08x)\n", hr
);
885 for (i
= 0; i
< 22; i
++)
887 hr
= IDirect3DDevice9_SetVertexShader(device
, vertex_shader
[test_data
[i
].vshader
]);
888 ok(SUCCEEDED(hr
), "SetVertexShader failed (%08x)\n", hr
);
889 hr
= IDirect3DDevice9_SetPixelShader(device
, pixel_shader
[test_data
[i
].pshader
]);
890 ok(SUCCEEDED(hr
), "SetPixelShader failed (%08x)\n", hr
);
891 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGVERTEXMODE
, test_data
[i
].vfog
);
892 ok( hr
== D3D_OK
, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr
);
893 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGTABLEMODE
, test_data
[i
].tfog
);
894 ok( hr
== D3D_OK
, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr
);
896 for(j
=0; j
< 11; j
++)
898 /* Don't use the whole zrange to prevent rounding errors */
899 quad
[0].z
= 0.001f
+ (float)j
/ 10.02f
;
900 quad
[1].z
= 0.001f
+ (float)j
/ 10.02f
;
901 quad
[2].z
= 0.001f
+ (float)j
/ 10.02f
;
902 quad
[3].z
= 0.001f
+ (float)j
/ 10.02f
;
904 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffff00ff, 0.0, 0);
905 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed (%08x)\n", hr
);
907 hr
= IDirect3DDevice9_BeginScene(device
);
908 ok( hr
== D3D_OK
, "BeginScene returned failed (%08x)\n", hr
);
910 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2, &quad
[0], sizeof(quad
[0]));
911 ok(SUCCEEDED(hr
), "DrawPrimitiveUP failed (%08x)\n", hr
);
913 hr
= IDirect3DDevice9_EndScene(device
);
914 ok(hr
== D3D_OK
, "EndScene failed (%08x)\n", hr
);
916 IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
918 /* As the red and green component are the result of blending use 5% tolerance on the expected value */
919 color
= getPixelColor(device
, 128, 240);
920 ok((unsigned char)(color
) == ((unsigned char)test_data
[i
].color
[j
])
921 && abs( ((unsigned char)(color
>>8)) - (unsigned char)(test_data
[i
].color
[j
]>>8) ) < 13
922 && abs( ((unsigned char)(color
>>16)) - (unsigned char)(test_data
[i
].color
[j
]>>16) ) < 13,
923 "fog ps%i vs%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%\n", test_data
[i
].vshader
, test_data
[i
].pshader
, test_data
[i
].vfog
, test_data
[i
].tfog
, j
, color
, test_data
[i
].color
[j
]);
928 hr
= IDirect3DDevice9_SetVertexShader(device
, NULL
);
929 ok(SUCCEEDED(hr
), "SetVertexShader failed (%08x)\n", hr
);
930 hr
= IDirect3DDevice9_SetPixelShader(device
, NULL
);
931 ok(SUCCEEDED(hr
), "SetPixelShader failed (%08x)\n", hr
);
932 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, NULL
);
933 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (%08x)\n", hr
);
934 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_FOGENABLE
, FALSE
);
935 ok(hr
== D3D_OK
, "Turning off fog calculations failed (%08x)\n", hr
);
937 IDirect3DVertexShader9_Release(vertex_shader
[1]);
938 IDirect3DVertexShader9_Release(vertex_shader
[2]);
939 IDirect3DPixelShader9_Release(pixel_shader
[1]);
940 IDirect3DVertexDeclaration9_Release(vertex_declaration
);
943 /* test the behavior of the texbem instruction
944 * with normal 2D and projective 2D textures
946 static void texbem_test(IDirect3DDevice9
*device
)
950 unsigned int i
, x
, y
;
952 static const DWORD pixel_shader_code
[] = {
953 0xffff0101, /* ps_1_1*/
954 0x00000042, 0xb00f0000, /* tex t0*/
955 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
956 0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
960 static const float quad
[][7] = {
961 {-128.0f
/640.0f
, -128.0f
/480.0f
, 0.1f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
},
962 {-128.0f
/640.0f
, 128.0f
/480.0f
, 0.1f
, 0.0f
, 1.0f
, 0.0f
, 1.0f
},
963 { 128.0f
/640.0f
, -128.0f
/480.0f
, 0.1f
, 1.0f
, 0.0f
, 1.0f
, 0.0f
},
964 { 128.0f
/640.0f
, 128.0f
/480.0f
, 0.1f
, 1.0f
, 1.0f
, 1.0f
, 1.0f
},
966 static const float quad_proj
[][9] = {
967 {-128.0f
/640.0f
, -128.0f
/480.0f
, 0.1f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
, 0.0f
, 128.0f
},
968 {-128.0f
/640.0f
, 128.0f
/480.0f
, 0.1f
, 0.0f
, 1.0f
, 0.0f
, 128.0f
, 0.0f
, 128.0f
},
969 { 128.0f
/640.0f
, -128.0f
/480.0f
, 0.1f
, 1.0f
, 0.0f
, 128.0f
, 0.0f
, 0.0f
, 128.0f
},
970 { 128.0f
/640.0f
, 128.0f
/480.0f
, 0.1f
, 1.0f
, 1.0f
, 128.0f
, 128.0f
, 0.0f
, 128.0f
},
973 static const D3DVERTEXELEMENT9 decl_elements
[][4] = { {
974 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
975 {0, 12, D3DDECLTYPE_FLOAT2
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 0},
976 {0, 20, D3DDECLTYPE_FLOAT2
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 1},
979 {0, 0, D3DDECLTYPE_FLOAT3
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_POSITION
, 0},
980 {0, 12, D3DDECLTYPE_FLOAT2
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 0},
981 {0, 20, D3DDECLTYPE_FLOAT4
, D3DDECLMETHOD_DEFAULT
, D3DDECLUSAGE_TEXCOORD
, 1},
985 /* use assymetric matrix to test loading */
986 float bumpenvmat
[4] = {0.0,0.5,-0.5,0.0};
988 IDirect3DVertexDeclaration9
*vertex_declaration
= NULL
;
989 IDirect3DPixelShader9
*pixel_shader
= NULL
;
990 IDirect3DTexture9
*texture
[2] = {NULL
, NULL
};
991 D3DLOCKED_RECT locked_rect
;
993 /* Generate the textures */
996 hr
= IDirect3DDevice9_CreateTexture(device
, 128, 128, 1, 0, i
?D3DFMT_A8R8G8B8
:D3DFMT_V8U8
,
997 D3DPOOL_MANAGED
, &texture
[i
], NULL
);
998 ok(SUCCEEDED(hr
), "CreateTexture failed (0x%08x)\n", hr
);
1000 hr
= IDirect3DTexture9_LockRect(texture
[i
], 0, &locked_rect
, NULL
, D3DLOCK_DISCARD
);
1001 ok(SUCCEEDED(hr
), "LockRect failed (0x%08x)\n", hr
);
1002 for (y
= 0; y
< 128; ++y
)
1005 { /* Set up black texture with 2x2 texel white spot in the middle */
1006 DWORD
*ptr
= (DWORD
*)(((BYTE
*)locked_rect
.pBits
) + (y
* locked_rect
.Pitch
));
1007 for (x
= 0; x
< 128; ++x
)
1009 if(y
>62 && y
<66 && x
>62 && x
<66)
1010 *ptr
++ = 0xffffffff;
1012 *ptr
++ = 0xff000000;
1016 { /* Set up a displacement map which points away from the center parallel to the closest axis.
1017 * (if multiplied with bumpenvmat)
1019 WORD
*ptr
= (WORD
*)(((BYTE
*)locked_rect
.pBits
) + (y
* locked_rect
.Pitch
));
1020 for (x
= 0; x
< 128; ++x
)
1022 if(abs(x
-64)>abs(y
-64))
1039 hr
= IDirect3DTexture9_UnlockRect(texture
[i
], 0);
1040 ok(SUCCEEDED(hr
), "UnlockRect failed (0x%08x)\n", hr
);
1042 hr
= IDirect3DDevice9_SetTexture(device
, i
, (IDirect3DBaseTexture9
*)texture
[i
]);
1043 ok(SUCCEEDED(hr
), "SetTexture failed (0x%08x)\n", hr
);
1045 /* Disable texture filtering */
1046 hr
= IDirect3DDevice9_SetSamplerState(device
, i
, D3DSAMP_MINFILTER
, D3DTEXF_POINT
);
1047 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr
);
1048 hr
= IDirect3DDevice9_SetSamplerState(device
, i
, D3DSAMP_MAGFILTER
, D3DTEXF_POINT
);
1049 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr
);
1051 hr
= IDirect3DDevice9_SetSamplerState(device
, i
, D3DSAMP_ADDRESSU
, D3DTADDRESS_CLAMP
);
1052 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr
);
1053 hr
= IDirect3DDevice9_SetSamplerState(device
, i
, D3DSAMP_ADDRESSV
, D3DTADDRESS_CLAMP
);
1054 ok(SUCCEEDED(hr
), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr
);
1057 IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_BUMPENVMAT00
, *(LPDWORD
)&bumpenvmat
[0]);
1058 IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_BUMPENVMAT01
, *(LPDWORD
)&bumpenvmat
[1]);
1059 IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_BUMPENVMAT10
, *(LPDWORD
)&bumpenvmat
[2]);
1060 hr
= IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_BUMPENVMAT11
, *(LPDWORD
)&bumpenvmat
[3]);
1061 ok(SUCCEEDED(hr
), "SetTextureStageState failed (%08x)\n", hr
);
1063 hr
= IDirect3DDevice9_SetVertexShader(device
, NULL
);
1064 ok(SUCCEEDED(hr
), "SetVertexShader failed (%08x)\n", hr
);
1066 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffff00ff, 0.0, 0);
1067 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear failed (%08x)\n", hr
);
1073 hr
= IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_TEXTURETRANSFORMFLAGS
, D3DTTFF_COUNT4
|D3DTTFF_PROJECTED
);
1074 ok(SUCCEEDED(hr
), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr
);
1077 hr
= IDirect3DDevice9_CreateVertexDeclaration(device
, decl_elements
[i
], &vertex_declaration
);
1078 ok(SUCCEEDED(hr
), "CreateVertexDeclaration failed (0x%08x)\n", hr
);
1079 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, vertex_declaration
);
1080 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (0x%08x)\n", hr
);
1082 hr
= IDirect3DDevice9_CreatePixelShader(device
, pixel_shader_code
, &pixel_shader
);
1083 ok(SUCCEEDED(hr
), "CreatePixelShader failed (%08x)\n", hr
);
1084 hr
= IDirect3DDevice9_SetPixelShader(device
, pixel_shader
);
1085 ok(SUCCEEDED(hr
), "SetPixelShader failed (%08x)\n", hr
);
1087 hr
= IDirect3DDevice9_BeginScene(device
);
1088 ok(SUCCEEDED(hr
), "BeginScene failed (0x%08x)\n", hr
);
1091 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2, &quad
[0], sizeof(quad
[0]));
1093 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2, &quad_proj
[0], sizeof(quad_proj
[0]));
1094 ok(SUCCEEDED(hr
), "DrawPrimitiveUP failed (0x%08x)\n", hr
);
1096 hr
= IDirect3DDevice9_EndScene(device
);
1097 ok(SUCCEEDED(hr
), "EndScene failed (0x%08x)\n", hr
);
1099 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
1100 ok(SUCCEEDED(hr
), "Present failed (0x%08x)\n", hr
);
1102 color
= getPixelColor(device
, 320-32, 240);
1103 ok(color
== 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color
);
1104 color
= getPixelColor(device
, 320+32, 240);
1105 ok(color
== 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color
);
1106 color
= getPixelColor(device
, 320, 240-32);
1107 ok(color
== 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color
);
1108 color
= getPixelColor(device
, 320, 240+32);
1109 ok(color
== 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color
);
1111 hr
= IDirect3DDevice9_SetPixelShader(device
, NULL
);
1112 ok(SUCCEEDED(hr
), "SetPixelShader failed (%08x)\n", hr
);
1113 IDirect3DPixelShader9_Release(pixel_shader
);
1115 hr
= IDirect3DDevice9_SetVertexDeclaration(device
, NULL
);
1116 ok(SUCCEEDED(hr
), "SetVertexDeclaration failed (%08x)\n", hr
);
1117 IDirect3DVertexDeclaration9_Release(vertex_declaration
);
1121 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0, 0.0f
, 0);
1122 ok(SUCCEEDED(hr
), "Clear failed (0x%08x)\n", hr
);
1124 hr
= IDirect3DDevice9_SetTextureStageState(device
, 1, D3DTSS_TEXTURETRANSFORMFLAGS
, D3DTTFF_COUNT2
);
1125 ok(SUCCEEDED(hr
), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr
);
1129 hr
= IDirect3DDevice9_SetTexture(device
, i
, NULL
);
1130 ok(SUCCEEDED(hr
), "SetTexture failed (0x%08x)\n", hr
);
1131 IDirect3DCubeTexture9_Release(texture
[i
]);
1135 static void present_test(IDirect3DDevice9
*device
)
1137 struct vertex quad
[] =
1139 {-1.0f
, -1.0f
, 0.9f
, 0xffff0000},
1140 {-1.0f
, 1.0f
, 0.9f
, 0xffff0000},
1141 { 1.0f
, -1.0f
, 0.1f
, 0xffff0000},
1142 { 1.0f
, 1.0f
, 0.1f
, 0xffff0000},
1147 /* Does the Present clear the depth stencil? Clear the depth buffer with some value != 0,
1148 * then call Present. Then clear the color buffer to make sure it has some defined content
1149 * after the Present with D3DSWAPEFFECT_DISCARD. After that draw a plane that is somewhere cut
1150 * by the depth value.
1152 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
| D3DCLEAR_ZBUFFER
, 0xffffffff, 0.75, 0);
1153 ok(hr
== D3D_OK
, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr
));
1154 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
1155 hr
= IDirect3DDevice9_Clear(device
, 0, NULL
, D3DCLEAR_TARGET
, 0xffffffff, 0.4, 0);
1157 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ZENABLE
, D3DZB_TRUE
);
1158 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
1159 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ZFUNC
, D3DCMP_GREATER
);
1160 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
1161 hr
= IDirect3DDevice9_SetFVF(device
, D3DFVF_XYZ
| D3DFVF_DIFFUSE
);
1162 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr
));
1164 hr
= IDirect3DDevice9_BeginScene(device
);
1165 ok(hr
== D3D_OK
, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr
));
1168 /* No lights are defined... That means, lit vertices should be entirely black */
1169 hr
= IDirect3DDevice9_DrawPrimitiveUP(device
, D3DPT_TRIANGLESTRIP
, 2 /*PrimCount */, quad
, sizeof(quad
[0]));
1170 ok(hr
== D3D_OK
, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr
));
1172 hr
= IDirect3DDevice9_EndScene(device
);
1173 ok(hr
== D3D_OK
, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr
));
1176 hr
= IDirect3DDevice9_SetRenderState(device
, D3DRS_ZENABLE
, D3DZB_FALSE
);
1177 ok(hr
== D3D_OK
, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr
));
1179 hr
= IDirect3DDevice9_Present(device
, NULL
, NULL
, NULL
, NULL
);
1180 ok(SUCCEEDED(hr
), "Present failed (0x%08x)\n", hr
);
1181 color
= getPixelColor(device
, 512, 240);
1182 ok(color
== 0x00ffffff, "Present failed: Got color 0x%08x, expected 0x00ffffff.\n", color
);
1183 color
= getPixelColor(device
, 64, 240);
1184 ok(color
== 0x00ff0000, "Present failed: Got color 0x%08x, expected 0x00ff0000.\n", color
);
1189 IDirect3DDevice9
*device_ptr
;
1194 d3d9_handle
= LoadLibraryA("d3d9.dll");
1197 skip("Could not load d3d9.dll\n");
1201 device_ptr
= init_d3d9();
1202 if (!device_ptr
) return;
1204 IDirect3DDevice9_GetDeviceCaps(device_ptr
, &caps
);
1206 /* Check for the reliability of the returned data */
1207 hr
= IDirect3DDevice9_Clear(device_ptr
, 0, NULL
, D3DCLEAR_TARGET
, 0xffff0000, 0.0, 0);
1210 trace("Clear failed, can't assure correctness of the test results, skipping\n");
1213 IDirect3DDevice9_Present(device_ptr
, NULL
, NULL
, NULL
, NULL
);
1215 color
= getPixelColor(device_ptr
, 1, 1);
1216 if(color
!=0x00ff0000)
1218 trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color
);
1222 hr
= IDirect3DDevice9_Clear(device_ptr
, 0, NULL
, D3DCLEAR_TARGET
, 0xff00ddee, 0.0, 0);
1225 trace("Clear failed, can't assure correctness of the test results, skipping\n");
1228 IDirect3DDevice9_Present(device_ptr
, NULL
, NULL
, NULL
, NULL
);
1230 color
= getPixelColor(device_ptr
, 639, 479);
1231 if(color
!= 0x0000ddee)
1233 trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color
);
1237 /* Now execute the real tests */
1238 lighting_test(device_ptr
);
1239 clear_test(device_ptr
);
1240 fog_test(device_ptr
);
1241 if(caps
.TextureCaps
& D3DPTEXTURECAPS_CUBEMAP
)
1243 test_cube_wrap(device_ptr
);
1245 skip("No cube texture support\n");
1247 present_test(device_ptr
);
1249 if (caps
.VertexShaderVersion
>= D3DVS_VERSION(2, 0))
1251 test_mova(device_ptr
);
1253 else skip("No vs_2_0 support\n");
1255 if (caps
.VertexShaderVersion
>= D3DVS_VERSION(1, 1) && caps
.PixelShaderVersion
>= D3DPS_VERSION(1, 1))
1257 fog_with_shader_test(device_ptr
);
1259 else skip("No vs_1_1 and ps_1_1 support\n");
1261 if (caps
.PixelShaderVersion
>= D3DPS_VERSION(1, 1))
1263 texbem_test(device_ptr
);
1265 else skip("No ps_1_1 support\n");
1268 if(device_ptr
) IDirect3DDevice9_Release(device_ptr
);