?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d9: Avoid a not needed address-of operator.
[wine/hacks.git] / dlls / d3d9 / tests / visual.c
bloba328123ef874707d8a00482e7065affa99d11251
1 /*
2 * Copyright 2005, 2007 Henri Verbeet
3 * Copyright (C) 2007-2008 Stefan Dösinger(for CodeWeavers)
4 * Copyright (C) 2008 Jason Green(for TransGaming)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 /* This test framework allows limited testing of rendering results. Things are rendered, shown on
22 * the framebuffer, read back from there and compared to expected colors.
23 *
24 * However, neither d3d nor opengl is guaranteed to be pixel exact, and thus the capability of this test
25 * is rather limited. As a general guideline for adding tests, do not rely on corner pixels. Draw a big enough
26 * area which shows specific behavior(like a quad on the whole screen), and try to get resulting colors with
27 * all bits set or unset in all channels(like pure red, green, blue, white, black). Hopefully everything that
28 * causes visible results in games can be tested in a way that does not depend on pixel exactness
29 */
30
31 #define COBJMACROS
32 #include <d3d9.h>
33 #include <dxerr9.h>
34 #include "wine/test.h"
35
36 static HMODULE d3d9_handle = 0;
37
38 static HWND create_window(void)
39 {
40 WNDCLASS wc = {0};
41 HWND ret;
42 wc.lpfnWndProc = DefWindowProc;
43 wc.lpszClassName = "d3d9_test_wc";
44 RegisterClass(&wc);
45
46 ret = CreateWindow("d3d9_test_wc", "d3d9_test",
47 WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
48 return ret;
49 }
50
51 static BOOL color_match(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff)
52 {
53 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
54 c1 >>= 8; c2 >>= 8;
55 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
56 c1 >>= 8; c2 >>= 8;
57 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
58 c1 >>= 8; c2 >>= 8;
59 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
60 return TRUE;
61 }
62
63 /* Locks a given surface and returns the color at (x,y). It's the caller's
64 * responsibility to only pass in lockable surfaces and valid x,y coordinates */
65 static DWORD getPixelColorFromSurface(IDirect3DSurface9 *surface, UINT x, UINT y)
66 {
67 DWORD color;
68 HRESULT hr;
69 D3DSURFACE_DESC desc;
70 RECT rectToLock = {x, y, x+1, y+1};
71 D3DLOCKED_RECT lockedRect;
72
73 hr = IDirect3DSurface9_GetDesc(surface, &desc);
74 if(FAILED(hr)) /* This is not a test */
75 {
76 trace("Can't get the surface description, hr=%s\n", DXGetErrorString9(hr));
77 return 0xdeadbeef;
78 }
79
80 hr = IDirect3DSurface9_LockRect(surface, &lockedRect, &rectToLock, D3DLOCK_READONLY);
81 if(FAILED(hr)) /* This is not a test */
82 {
83 trace("Can't lock the surface, hr=%s\n", DXGetErrorString9(hr));
84 return 0xdeadbeef;
85 }
86 switch(desc.Format) {
87 case D3DFMT_A8R8G8B8:
88 {
89 color = ((DWORD *) lockedRect.pBits)[0] & 0xffffffff;
90 break;
91 }
92 default:
93 trace("Error: unknown surface format: %d\n", desc.Format);
94 color = 0xdeadbeef;
95 break;
96 }
97 hr = IDirect3DSurface9_UnlockRect(surface);
98 if(FAILED(hr))
99 {
100 trace("Can't unlock the surface, hr=%s\n", DXGetErrorString9(hr));
101 }
102 return color;
103 }
104
105 static DWORD getPixelColor(IDirect3DDevice9 *device, UINT x, UINT y)
106 {
107 DWORD ret;
108 IDirect3DSurface9 *surf;
109 HRESULT hr;
110 D3DLOCKED_RECT lockedRect;
111 RECT rectToLock = {x, y, x+1, y+1};
112
113 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 640, 480, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf, NULL);
114 if(FAILED(hr) || !surf ) /* This is not a test */
115 {
116 trace("Can't create an offscreen plain surface to read the render target data, hr=%s\n", DXGetErrorString9(hr));
117 return 0xdeadbeef;
118 }
119
120 hr = IDirect3DDevice9_GetFrontBufferData(device, 0, surf);
121 if(FAILED(hr))
122 {
123 trace("Can't read the front buffer data, hr=%s\n", DXGetErrorString9(hr));
124 ret = 0xdeadbeed;
125 goto out;
126 }
127
128 hr = IDirect3DSurface9_LockRect(surf, &lockedRect, &rectToLock, D3DLOCK_READONLY);
129 if(FAILED(hr))
130 {
131 trace("Can't lock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
132 ret = 0xdeadbeec;
133 goto out;
134 }
135
136 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
137 * really important for these tests
138 */
139 ret = ((DWORD *) lockedRect.pBits)[0] & 0x00ffffff;
140 hr = IDirect3DSurface9_UnlockRect(surf);
141 if(FAILED(hr))
142 {
143 trace("Can't unlock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
144 }
145
146 out:
147 if(surf) IDirect3DSurface9_Release(surf);
148 return ret;
149 }
150
151 static IDirect3DDevice9 *init_d3d9(void)
152 {
153 IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
154 IDirect3D9 *d3d9_ptr = 0;
155 IDirect3DDevice9 *device_ptr = 0;
156 D3DPRESENT_PARAMETERS present_parameters;
157 HRESULT hr;
158 D3DADAPTER_IDENTIFIER9 identifier;
159
160 d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
161 ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
162 if (!d3d9_create) return NULL;
163
164 d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
165 ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
166 if (!d3d9_ptr) return NULL;
167
168 ZeroMemory(&present_parameters, sizeof(present_parameters));
169 present_parameters.Windowed = FALSE;
170 present_parameters.hDeviceWindow = create_window();
171 present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
172 present_parameters.BackBufferWidth = 640;
173 present_parameters.BackBufferHeight = 480;
174 present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
175 present_parameters.EnableAutoDepthStencil = TRUE;
176 present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
177
178 memset(&identifier, 0, sizeof(identifier));
179 hr = IDirect3D9_GetAdapterIdentifier(d3d9_ptr, 0, 0, &identifier);
180 ok(hr == D3D_OK, "Failed to get adapter identifier description\n");
181 trace("Driver string: \"%s\"\n", identifier.Driver);
182 trace("Description string: \"%s\"\n", identifier.Description);
183 trace("Device name string: \"%s\"\n", identifier.DeviceName);
184 trace("Driver version %d.%d.%d.%d\n",
185 HIWORD(U(identifier.DriverVersion).HighPart), LOWORD(U(identifier.DriverVersion).HighPart),
186 HIWORD(U(identifier.DriverVersion).LowPart), LOWORD(U(identifier.DriverVersion).LowPart));
187
188 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
189 if(FAILED(hr)) {
190 present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
191 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
192 if(FAILED(hr)) {
193 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
194 }
195 }
196 ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D_CreateDevice returned: %s\n", DXGetErrorString9(hr));
197
198 return device_ptr;
199 }
200
201 struct vertex
202 {
203 float x, y, z;
204 DWORD diffuse;
205 };
206
207 struct tvertex
208 {
209 float x, y, z, rhw;
210 DWORD diffuse;
211 };
212
213 struct nvertex
214 {
215 float x, y, z;
216 float nx, ny, nz;
217 DWORD diffuse;
218 };
219
220 static void lighting_test(IDirect3DDevice9 *device)
221 {
222 HRESULT hr;
223 DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
224 DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
225 DWORD color;
226
227 float mat[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
228 0.0f, 1.0f, 0.0f, 0.0f,
229 0.0f, 0.0f, 1.0f, 0.0f,
230 0.0f, 0.0f, 0.0f, 1.0f };
231
232 struct vertex unlitquad[] =
233 {
234 {-1.0f, -1.0f, 0.1f, 0xffff0000},
235 {-1.0f, 0.0f, 0.1f, 0xffff0000},
236 { 0.0f, 0.0f, 0.1f, 0xffff0000},
237 { 0.0f, -1.0f, 0.1f, 0xffff0000},
238 };
239 struct vertex litquad[] =
240 {
241 {-1.0f, 0.0f, 0.1f, 0xff00ff00},
242 {-1.0f, 1.0f, 0.1f, 0xff00ff00},
243 { 0.0f, 1.0f, 0.1f, 0xff00ff00},
244 { 0.0f, 0.0f, 0.1f, 0xff00ff00},
245 };
246 struct nvertex unlitnquad[] =
247 {
248 { 0.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
249 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
250 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
251 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
252 };
253 struct nvertex litnquad[] =
254 {
255 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
256 { 0.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
257 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
258 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
259 };
260 WORD Indices[] = {0, 1, 2, 2, 3, 0};
261
262 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
263 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
264
265 /* Setup some states that may cause issues */
266 hr = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(0), (D3DMATRIX *) mat);
267 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
268 hr = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, (D3DMATRIX *)mat);
269 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
270 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, (D3DMATRIX *) mat);
271 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
272 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
273 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
274 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE);
275 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
276 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
277 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
278 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
279 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
280 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHATESTENABLE, FALSE);
281 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
282 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
283 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
284 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
285 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
286 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
287 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
288 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
289 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
290
291 hr = IDirect3DDevice9_SetFVF(device, fvf);
292 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
293
294 hr = IDirect3DDevice9_BeginScene(device);
295 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
296 if(hr == D3D_OK)
297 {
298 /* No lights are defined... That means, lit vertices should be entirely black */
299 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
300 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
301 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
302 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitquad, sizeof(unlitquad[0]));
303 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
304
305 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
306 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
307 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
308 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litquad, sizeof(litquad[0]));
309 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
310
311 hr = IDirect3DDevice9_SetFVF(device, nfvf);
312 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
313
314 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
315 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
316 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
317 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitnquad, sizeof(unlitnquad[0]));
318 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
319
320 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
321 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
322 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
323 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litnquad, sizeof(litnquad[0]));
324 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
325
326 IDirect3DDevice9_EndScene(device);
327 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
328 }
329
330 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
331
332 color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
333 ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
334 color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
335 ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
336 color = getPixelColor(device, 480, 360); /* lower left quad - unlit with normals */
337 ok(color == 0x000000ff, "Unlit quad with normals has color %08x\n", color);
338 color = getPixelColor(device, 480, 120); /* upper left quad - lit with normals */
339 ok(color == 0x00000000, "Lit quad with normals has color %08x\n", color);
340
341 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
342 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
343 }
344
345 static void clear_test(IDirect3DDevice9 *device)
346 {
347 /* Tests the correctness of clearing parameters */
348 HRESULT hr;
349 D3DRECT rect[2];
350 D3DRECT rect_negneg;
351 DWORD color;
352 D3DVIEWPORT9 old_vp, vp;
353 RECT scissor;
354 DWORD oldColorWrite;
355 BOOL invalid_clear_failed = FALSE;
356
357 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
358 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
359
360 /* Positive x, negative y */
361 rect[0].x1 = 0;
362 rect[0].y1 = 480;
363 rect[0].x2 = 320;
364 rect[0].y2 = 240;
365
366 /* Positive x, positive y */
367 rect[1].x1 = 0;
368 rect[1].y1 = 0;
369 rect[1].x2 = 320;
370 rect[1].y2 = 240;
371 /* Clear 2 rectangles with one call. The refrast returns an error in this case, every real driver tested so far
372 * returns D3D_OK, but ignores the rectangle silently
373 */
374 hr = IDirect3DDevice9_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
375 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
376 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
377
378 /* negative x, negative y */
379 rect_negneg.x1 = 640;
380 rect_negneg.y1 = 240;
381 rect_negneg.x2 = 320;
382 rect_negneg.y2 = 0;
383 hr = IDirect3DDevice9_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
384 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
385 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
386
387 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
388
389 color = getPixelColor(device, 160, 360); /* lower left quad */
390 ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
391 color = getPixelColor(device, 160, 120); /* upper left quad */
392 if(invalid_clear_failed) {
393 /* If the negative rectangle was refused, the other rectangles in the list shouldn't be cleared either */
394 ok(color == 0x00ffffff, "Clear rectangle 1(pos, pos) has color %08x\n", color);
395 } else {
396 /* If the negative rectangle was dropped silently, the correct ones are cleared */
397 ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
398 }
399 color = getPixelColor(device, 480, 360); /* lower right quad */
400 ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
401 color = getPixelColor(device, 480, 120); /* upper right quad */
402 ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
403
404 /* Test how the viewport affects clears */
405 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
406 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
407 hr = IDirect3DDevice9_GetViewport(device, &old_vp);
408 ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %s\n", DXGetErrorString9(hr));
409
410 vp.X = 160;
411 vp.Y = 120;
412 vp.Width = 160;
413 vp.Height = 120;
414 vp.MinZ = 0.0;
415 vp.MaxZ = 1.0;
416 hr = IDirect3DDevice9_SetViewport(device, &vp);
417 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
418 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
419 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
420
421 vp.X = 320;
422 vp.Y = 240;
423 vp.Width = 320;
424 vp.Height = 240;
425 vp.MinZ = 0.0;
426 vp.MaxZ = 1.0;
427 hr = IDirect3DDevice9_SetViewport(device, &vp);
428 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
429 rect[0].x1 = 160;
430 rect[0].y1 = 120;
431 rect[0].x2 = 480;
432 rect[0].y2 = 360;
433 hr = IDirect3DDevice9_Clear(device, 1, &rect[0], D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
434 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
435
436 hr = IDirect3DDevice9_SetViewport(device, &old_vp);
437 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
438
439 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
440 color = getPixelColor(device, 158, 118);
441 ok(color == 0x00ffffff, "(158,118) has color %08x\n", color);
442 color = getPixelColor(device, 162, 118);
443 ok(color == 0x00ffffff, "(162,118) has color %08x\n", color);
444 color = getPixelColor(device, 158, 122);
445 ok(color == 0x00ffffff, "(158,122) has color %08x\n", color);
446 color = getPixelColor(device, 162, 122);
447 ok(color == 0x000000ff, "(162,122) has color %08x\n", color);
448
449 color = getPixelColor(device, 318, 238);
450 ok(color == 0x000000ff, "(318,238) has color %08x\n", color);
451 color = getPixelColor(device, 322, 238);
452 ok(color == 0x00ffffff, "(322,328) has color %08x\n", color);
453 color = getPixelColor(device, 318, 242);
454 ok(color == 0x00ffffff, "(318,242) has color %08x\n", color);
455 color = getPixelColor(device, 322, 242);
456 ok(color == 0x0000ff00, "(322,242) has color %08x\n", color);
457
458 color = getPixelColor(device, 478, 358);
459 ok(color == 0x0000ff00, "(478,358 has color %08x\n", color);
460 color = getPixelColor(device, 482, 358);
461 ok(color == 0x00ffffff, "(482,358) has color %08x\n", color);
462 color = getPixelColor(device, 478, 362);
463 ok(color == 0x00ffffff, "(478,362) has color %08x\n", color);
464 color = getPixelColor(device, 482, 362);
465 ok(color == 0x00ffffff, "(482,362) has color %08x\n", color);
466
467 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
468 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
469
470 scissor.left = 160;
471 scissor.right = 480;
472 scissor.top = 120;
473 scissor.bottom = 360;
474 hr = IDirect3DDevice9_SetScissorRect(device, &scissor);
475 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
476 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, TRUE);
477 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
478
479 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
480 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
481 hr = IDirect3DDevice9_Clear(device, 1, &rect[1], D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
482 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
483
484 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
485 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
486
487 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
488 color = getPixelColor(device, 158, 118);
489 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
490 color = getPixelColor(device, 162, 118);
491 ok(color == 0x00ffffff, "Pixel 162/118 has color %08x\n", color);
492 color = getPixelColor(device, 158, 122);
493 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
494 color = getPixelColor(device, 162, 122);
495 ok(color == 0x00ff0000, "Pixel 162/122 has color %08x\n", color);
496
497 color = getPixelColor(device, 158, 358);
498 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
499 color = getPixelColor(device, 162, 358);
500 ok(color == 0x0000ff00, "Pixel 162/358 has color %08x\n", color);
501 color = getPixelColor(device, 158, 358);
502 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
503 color = getPixelColor(device, 162, 362);
504 ok(color == 0x00ffffff, "Pixel 162/362 has color %08x\n", color);
505
506 color = getPixelColor(device, 478, 118);
507 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
508 color = getPixelColor(device, 478, 122);
509 ok(color == 0x0000ff00, "Pixel 162/118 has color %08x\n", color);
510 color = getPixelColor(device, 482, 122);
511 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
512 color = getPixelColor(device, 482, 358);
513 ok(color == 0x00ffffff, "Pixel 162/122 has color %08x\n", color);
514
515 color = getPixelColor(device, 478, 358);
516 ok(color == 0x0000ff00, "Pixel 478/358 has color %08x\n", color);
517 color = getPixelColor(device, 478, 362);
518 ok(color == 0x00ffffff, "Pixel 478/118 has color %08x\n", color);
519 color = getPixelColor(device, 482, 358);
520 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
521 color = getPixelColor(device, 482, 362);
522 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
523
524 color = getPixelColor(device, 318, 238);
525 ok(color == 0x00ff0000, "Pixel 318/238 has color %08x\n", color);
526 color = getPixelColor(device, 318, 242);
527 ok(color == 0x0000ff00, "Pixel 318/242 has color %08x\n", color);
528 color = getPixelColor(device, 322, 238);
529 ok(color == 0x0000ff00, "Pixel 322/238 has color %08x\n", color);
530 color = getPixelColor(device, 322, 242);
531 ok(color == 0x0000ff00, "Pixel 322/242 has color %08x\n", color);
532
533 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_COLORWRITEENABLE, &oldColorWrite);
534 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %s\n", DXGetErrorString9(hr));
535 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
536 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
537
538 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
539 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
540
541 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, oldColorWrite);
542 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
543
544 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
545
546 /* Colorwriteenable does not affect the clear */
547 color = getPixelColor(device, 320, 240);
548 ok(color == 0x00ffffff, "Color write protected clear returned color %08x\n", color);
549 }
550
551 typedef struct {
552 float in[4];
553 DWORD out;
554 } test_data_t;
555
556 /*
557 * c7 mova ARGB mov ARGB
558 * -2.4 -2 0x00ffff00 -3 0x00ff0000
559 * -1.6 -2 0x00ffff00 -2 0x00ffff00
560 * -0.4 0 0x0000ffff -1 0x0000ff00
561 * 0.4 0 0x0000ffff 0 0x0000ffff
562 * 1.6 2 0x00ff00ff 1 0x000000ff
563 * 2.4 2 0x00ff00ff 2 0x00ff00ff
564 */
565 static void test_mova(IDirect3DDevice9 *device)
566 {
567 static const DWORD mova_test[] = {
568 0xfffe0200, /* vs_2_0 */
569 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
570 0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
571 0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
572 0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
573 0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
574 0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
575 0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
576 0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
577 0x0200002e, 0xb0010000, 0xa0000007, /* mova a0.x, c7.x */
578 0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000, /* mov oD0, c[a0.x + 3] */
579 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
580 0x0000ffff /* END */
581 };
582 static const DWORD mov_test[] = {
583 0xfffe0101, /* vs_1_1 */
584 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
585 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
586 0x00000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
587 0x00000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
588 0x00000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
589 0x00000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
590 0x00000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
591 0x00000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
592 0x00000001, 0xb0010000, 0xa0000007, /* mov a0.x, c7.x */
593 0x00000001, 0xd00f0000, 0xa0e42003, /* mov oD0, c[a0.x + 3] */
594 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
595 0x0000ffff /* END */
596 };
597
598 static const test_data_t test_data[2][6] = {
599 {
600 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff0000},
601 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
602 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ff00},
603 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
604 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x000000ff},
605 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
606 },
607 {
608 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
609 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
610 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
611 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
612 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff},
613 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
614 }
615 };
616
617 static const float quad[][3] = {
618 {-1.0f, -1.0f, 0.0f},
619 {-1.0f, 1.0f, 0.0f},
620 { 1.0f, -1.0f, 0.0f},
621 { 1.0f, 1.0f, 0.0f},
622 };
623
624 static const D3DVERTEXELEMENT9 decl_elements[] = {
625 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
626 D3DDECL_END()
627 };
628
629 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
630 IDirect3DVertexShader9 *mova_shader = NULL;
631 IDirect3DVertexShader9 *mov_shader = NULL;
632 HRESULT hr;
633 UINT i, j;
634
635 hr = IDirect3DDevice9_CreateVertexShader(device, mova_test, &mova_shader);
636 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
637 hr = IDirect3DDevice9_CreateVertexShader(device, mov_test, &mov_shader);
638 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
639 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
640 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
641 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
642 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
643
644 hr = IDirect3DDevice9_SetVertexShader(device, mov_shader);
645 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
646 for(j = 0; j < 2; ++j)
647 {
648 for (i = 0; i < (sizeof(test_data[0]) / sizeof(test_data_t)); ++i)
649 {
650 DWORD color;
651
652 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 7, test_data[j][i].in, 1);
653 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
654
655 hr = IDirect3DDevice9_BeginScene(device);
656 ok(SUCCEEDED(hr), "BeginScene failed (%08x)\n", hr);
657
658 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], 3 * sizeof(float));
659 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
660
661 hr = IDirect3DDevice9_EndScene(device);
662 ok(SUCCEEDED(hr), "EndScene failed (%08x)\n", hr);
663
664 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
665 ok(SUCCEEDED(hr), "Present failed (%08x)\n", hr);
666
667 color = getPixelColor(device, 320, 240);
668 ok(color == test_data[j][i].out, "Expected color %08x, got %08x (for input %f, instruction %s)\n",
669 test_data[j][i].out, color, test_data[j][i].in[0], j == 0 ? "mov" : "mova");
670
671 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
672 ok(SUCCEEDED(hr), "Clear failed (%08x)\n", hr);
673 }
674 hr = IDirect3DDevice9_SetVertexShader(device, mova_shader);
675 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
676 }
677
678 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
679 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
680
681 IDirect3DVertexDeclaration9_Release(vertex_declaration);
682 IDirect3DVertexShader9_Release(mova_shader);
683 IDirect3DVertexShader9_Release(mov_shader);
684 }
685
686 struct sVertex {
687 float x, y, z;
688 DWORD diffuse;
689 DWORD specular;
690 };
691
692 struct sVertexT {
693 float x, y, z, rhw;
694 DWORD diffuse;
695 DWORD specular;
696 };
697
698 static void fog_test(IDirect3DDevice9 *device)
699 {
700 HRESULT hr;
701 DWORD color;
702 BYTE r, g, b;
703 float start = 0.0f, end = 1.0f;
704 D3DCAPS9 caps;
705 int i;
706
707 /* Gets full z based fog with linear fog, no fog with specular color */
708 struct sVertex unstransformed_1[] = {
709 {-1, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
710 {-1, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
711 { 0, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
712 { 0, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
713 };
714 /* Ok, I am too lazy to deal with transform matrices */
715 struct sVertex unstransformed_2[] = {
716 {-1, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
717 {-1, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
718 { 0, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
719 { 0, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
720 };
721 /* Untransformed ones. Give them a different diffuse color to make the test look
722 * nicer. It also makes making sure that they are drawn correctly easier.
723 */
724 struct sVertexT transformed_1[] = {
725 {320, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
726 {640, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
727 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
728 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
729 };
730 struct sVertexT transformed_2[] = {
731 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
732 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
733 {640, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
734 {320, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
735 };
736 struct vertex rev_fog_quads[] = {
737 {-1.0, -1.0, 0.1, 0x000000ff},
738 {-1.0, 0.0, 0.1, 0x000000ff},
739 { 0.0, 0.0, 0.1, 0x000000ff},
740 { 0.0, -1.0, 0.1, 0x000000ff},
741
742 { 0.0, -1.0, 0.9, 0x000000ff},
743 { 0.0, 0.0, 0.9, 0x000000ff},
744 { 1.0, 0.0, 0.9, 0x000000ff},
745 { 1.0, -1.0, 0.9, 0x000000ff},
746
747 { 0.0, 0.0, 0.4, 0x000000ff},
748 { 0.0, 1.0, 0.4, 0x000000ff},
749 { 1.0, 1.0, 0.4, 0x000000ff},
750 { 1.0, 0.0, 0.4, 0x000000ff},
751
752 {-1.0, 0.0, 0.7, 0x000000ff},
753 {-1.0, 1.0, 0.7, 0x000000ff},
754 { 0.0, 1.0, 0.7, 0x000000ff},
755 { 0.0, 0.0, 0.7, 0x000000ff},
756 };
757 WORD Indices[] = {0, 1, 2, 2, 3, 0};
758
759 memset(&caps, 0, sizeof(caps));
760 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
761 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %s\n", DXGetErrorString9(hr));
762 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
763 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
764
765 /* Setup initial states: No lighting, fog on, fog color */
766 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
767 ok(hr == D3D_OK, "Turning off lighting returned %s\n", DXGetErrorString9(hr));
768 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
769 ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
770 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
771 ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
772
773 /* First test: Both table fog and vertex fog off */
774 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
775 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
776 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
777 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
778
779 /* Start = 0, end = 1. Should be default, but set them */
780 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
781 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
782 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
783 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
784
785 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
786 {
787 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
788 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
789 /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
790 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
791 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
792 sizeof(unstransformed_1[0]));
793 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
794
795 /* That makes it use the Z value */
796 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
797 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
798 /* Untransformed, vertex fog != none (or table fog != none):
799 * Use the Z value as input into the equation
800 */
801 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
802 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
803 sizeof(unstransformed_1[0]));
804 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
805
806 /* transformed verts */
807 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
808 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
809 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
810 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
811 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
812 sizeof(transformed_1[0]));
813 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
814
815 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
816 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
817 /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
818 * equation
819 */
820 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
821 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_2,
822 sizeof(transformed_2[0]));
823
824 hr = IDirect3DDevice9_EndScene(device);
825 ok(hr == D3D_OK, "EndScene returned %s\n", DXGetErrorString9(hr));
826 }
827 else
828 {
829 ok(FALSE, "BeginScene failed\n");
830 }
831
832 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
833 color = getPixelColor(device, 160, 360);
834 ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
835 color = getPixelColor(device, 160, 120);
836 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
837 color = getPixelColor(device, 480, 120);
838 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
839 if(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
840 {
841 color = getPixelColor(device, 480, 360);
842 ok(color == 0x0000FF00 || color == 0x0000FE00, "Transformed vertex with linear table fog has color %08x\n", color);
843 }
844 else
845 {
846 /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
847 * The settings above result in no fogging with vertex fog
848 */
849 color = getPixelColor(device, 480, 120);
850 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
851 trace("Info: Table fog not supported by this device\n");
852 }
853
854 /* Now test the special case fogstart == fogend */
855 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
856 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
857
858 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
859 {
860 start = 512;
861 end = 512;
862 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
863 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
864 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
865 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
866
867 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
868 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
869 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
870 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %s\n", DXGetErrorString9(hr));
871 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
872 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
873
874 /* Untransformed vertex, z coord = 0.1, fogstart = 512, fogend = 512. Would result in
875 * a completely fog-free primitive because start > zcoord, but because start == end, the primitive
876 * is fully covered by fog. The same happens to the 2nd untransformed quad with z = 1.0.
877 * The third transformed quad remains unfogged because the fogcoords are read from the specular
878 * color and has fixed fogstart and fogend.
879 */
880 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
881 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
882 sizeof(unstransformed_1[0]));
883 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
884 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
885 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
886 sizeof(unstransformed_1[0]));
887 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
888
889 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
890 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
891 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
892 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
893 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
894 sizeof(transformed_1[0]));
895 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
896
897 hr = IDirect3DDevice9_EndScene(device);
898 ok(hr == D3D_OK, "EndScene returned %s\n", DXGetErrorString9(hr));
899 }
900 else
901 {
902 ok(FALSE, "BeginScene failed\n");
903 }
904 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
905 color = getPixelColor(device, 160, 360);
906 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 0.1 has color %08x\n", color);
907 color = getPixelColor(device, 160, 120);
908 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 1.0 has color %08x\n", color);
909 color = getPixelColor(device, 480, 120);
910 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
911
912 /* Test "reversed" fog without shaders. With shaders this fails on a few Windows D3D implementations,
913 * but without shaders it seems to work everywhere
914 */
915 end = 0.2;
916 start = 0.8;
917 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
918 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
919 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
920 ok(hr == D3D_OK, "Setting fog end returned %s\n", DXGetErrorString9(hr));
921 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
922 ok( hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
923
924 /* Test reversed fog without shaders. ATI cards have problems with reversed fog and shaders, so
925 * it doesn't seem very important for games. ATI cards also have problems with reversed table fog,
926 * so skip this for now
927 */
928 for(i = 0; i < 1 /*2 - Table fog test disabled, fails on ATI */; i++) {
929 const char *mode = (i ? "table" : "vertex");
930 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
931 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
932 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, i == 0 ? D3DFOG_LINEAR : D3DFOG_NONE);
933 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
934 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, i == 0 ? D3DFOG_NONE : D3DFOG_LINEAR);
935 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
936 hr = IDirect3DDevice9_BeginScene(device);
937 ok( hr == D3D_OK, "IDirect3DDDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
938 if(SUCCEEDED(hr)) {
939 WORD Indices2[] = { 0, 1, 2, 2, 3, 0,
940 4, 5, 6, 6, 7, 4,
941 8, 9, 10, 10, 11, 8,
942 12, 13, 14, 14, 15, 12};
943
944 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */,
945 16 /* NumVerts */, 8 /*PrimCount */, Indices2, D3DFMT_INDEX16, rev_fog_quads,
946 sizeof(rev_fog_quads[0]));
947
948 hr = IDirect3DDevice9_EndScene(device);
949 ok( hr == D3D_OK, "IDirect3DDDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
950 }
951 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
952 color = getPixelColor(device, 160, 360);
953 ok(color == 0x0000FF00 || color == 0x0000FE00, "Reversed %s fog: z=0.1 has color 0x%08x, expected 0x0000ff00\n", mode, color);
954
955 color = getPixelColor(device, 160, 120);
956 r = (color & 0x00ff0000) >> 16;
957 g = (color & 0x0000ff00) >> 8;
958 b = (color & 0x000000ff);
959 ok(r == 0x00 && g >= 0x29 && g <= 0x2d && b >= 0xd2 && b <= 0xd6,
960 "Reversed %s fog: z=0.7 has color 0x%08x, expected\n", mode, color);
961
962 color = getPixelColor(device, 480, 120);
963 r = (color & 0x00ff0000) >> 16;
964 g = (color & 0x0000ff00) >> 8;
965 b = (color & 0x000000ff);
966 ok(r == 0x00 && g >= 0xa8 && g <= 0xac && b >= 0x53 && b <= 0x57,
967 "Reversed %s fog: z=0.4 has color 0x%08x, expected\n", mode, color);
968
969 color = getPixelColor(device, 480, 360);
970 ok(color == 0x000000ff, "Reversed %s fog: z=0.9 has color 0x%08x, expected 0x000000ff\n", mode, color);
971
972 if(!(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)) {
973 skip("D3DPRASTERCAPS_FOGTABLE not supported, skipping reversed table fog test\n");
974 break;
975 }
976 }
977 /* Turn off the fog master switch to avoid confusing other tests */
978 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
979 ok(hr == D3D_OK, "Turning off fog calculations returned %s\n", DXGetErrorString9(hr));
980 start = 0.0;
981 end = 1.0;
982 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
983 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
984 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
985 ok(hr == D3D_OK, "Setting fog end returned %s\n", DXGetErrorString9(hr));
986 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
987 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %s\n", DXGetErrorString9(hr));
988 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
989 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
990 }
991
992 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
993 * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
994 * regardless of the actual addressing mode set. */
995 static void test_cube_wrap(IDirect3DDevice9 *device)
996 {
997 static const float quad[][6] = {
998 {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
999 {-1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1000 { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1001 { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1002 };
1003
1004 static const D3DVERTEXELEMENT9 decl_elements[] = {
1005 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1006 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1007 D3DDECL_END()
1008 };
1009
1010 static const struct {
1011 D3DTEXTUREADDRESS mode;
1012 const char *name;
1013 } address_modes[] = {
1014 {D3DTADDRESS_WRAP, "D3DTADDRESS_WRAP"},
1015 {D3DTADDRESS_MIRROR, "D3DTADDRESS_MIRROR"},
1016 {D3DTADDRESS_CLAMP, "D3DTADDRESS_CLAMP"},
1017 {D3DTADDRESS_BORDER, "D3DTADDRESS_BORDER"},
1018 {D3DTADDRESS_MIRRORONCE, "D3DTADDRESS_MIRRORONCE"},
1019 };
1020
1021 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1022 IDirect3DCubeTexture9 *texture = NULL;
1023 IDirect3DSurface9 *surface = NULL;
1024 D3DLOCKED_RECT locked_rect;
1025 HRESULT hr;
1026 UINT x;
1027 INT y, face;
1028
1029 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1030 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1031 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1032 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1033
1034 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 128, 128,
1035 D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
1036 ok(SUCCEEDED(hr), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr);
1037
1038 hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, 0);
1039 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1040
1041 for (y = 0; y < 128; ++y)
1042 {
1043 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1044 for (x = 0; x < 64; ++x)
1045 {
1046 *ptr++ = 0xffff0000;
1047 }
1048 for (x = 64; x < 128; ++x)
1049 {
1050 *ptr++ = 0xff0000ff;
1051 }
1052 }
1053
1054 hr = IDirect3DSurface9_UnlockRect(surface);
1055 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1056
1057 hr = IDirect3DDevice9_CreateCubeTexture(device, 128, 1, 0, D3DFMT_A8R8G8B8,
1058 D3DPOOL_DEFAULT, &texture, NULL);
1059 ok(SUCCEEDED(hr), "CreateCubeTexture failed (0x%08x)\n", hr);
1060
1061 /* Create cube faces */
1062 for (face = 0; face < 6; ++face)
1063 {
1064 IDirect3DSurface9 *face_surface = NULL;
1065
1066 hr= IDirect3DCubeTexture9_GetCubeMapSurface(texture, face, 0, &face_surface);
1067 ok(SUCCEEDED(hr), "GetCubeMapSurface failed (0x%08x)\n", hr);
1068
1069 hr = IDirect3DDevice9_UpdateSurface(device, surface, NULL, face_surface, NULL);
1070 ok(SUCCEEDED(hr), "UpdateSurface failed (0x%08x)\n", hr);
1071
1072 IDirect3DSurface9_Release(face_surface);
1073 }
1074
1075 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
1076 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1077
1078 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1079 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1080 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1081 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1082 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_BORDERCOLOR, 0xff00ff00);
1083 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr);
1084
1085 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1086 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1087
1088 for (x = 0; x < (sizeof(address_modes) / sizeof(*address_modes)); ++x)
1089 {
1090 DWORD color;
1091
1092 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, address_modes[x].mode);
1093 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1094 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, address_modes[x].mode);
1095 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1096
1097 hr = IDirect3DDevice9_BeginScene(device);
1098 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1099
1100 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1101 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1102
1103 hr = IDirect3DDevice9_EndScene(device);
1104 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1105
1106 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1107 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1108
1109 /* Due to the nature of this test, we sample essentially at the edge
1110 * between two faces. Because of this it's undefined from which face
1111 * the driver will sample. Fortunately that's not important for this
1112 * test, since all we care about is that it doesn't sample from the
1113 * other side of the surface or from the border. */
1114 color = getPixelColor(device, 320, 240);
1115 ok(color == 0x00ff0000 || color == 0x000000ff,
1116 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
1117 color, address_modes[x].name);
1118
1119 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1120 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1121 }
1122
1123 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1124 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1125
1126 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1127 IDirect3DCubeTexture9_Release(texture);
1128 IDirect3DSurface9_Release(surface);
1129 }
1130
1131 static void offscreen_test(IDirect3DDevice9 *device)
1132 {
1133 HRESULT hr;
1134 IDirect3DTexture9 *offscreenTexture = NULL;
1135 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
1136 DWORD color;
1137
1138 static const float quad[][5] = {
1139 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
1140 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
1141 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
1142 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
1143 };
1144
1145 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1146 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
1147
1148 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1149 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
1150 if(!offscreenTexture) {
1151 trace("Failed to create an X8R8G8B8 offscreen texture, trying R5G6B5\n");
1152 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1153 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
1154 if(!offscreenTexture) {
1155 skip("Cannot create an offscreen render target\n");
1156 goto out;
1157 }
1158 }
1159
1160 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
1161 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
1162 if(!backbuffer) {
1163 goto out;
1164 }
1165
1166 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
1167 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
1168 if(!offscreen) {
1169 goto out;
1170 }
1171
1172 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
1173 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
1174
1175 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1176 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
1177 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
1178 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
1179 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1180 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1181 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1182 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1183 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1184 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1185
1186 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
1187 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
1188 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
1189 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1190 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
1191
1192 /* Draw without textures - Should result in a white quad */
1193 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1194 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
1195
1196 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1197 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
1198 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
1199 ok(hr == D3D_OK, "SetTexture failed, %s\n", DXGetErrorString9(hr));
1200
1201 /* This time with the texture */
1202 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1203 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
1204
1205 IDirect3DDevice9_EndScene(device);
1206 }
1207
1208 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1209
1210 /* Center quad - should be white */
1211 color = getPixelColor(device, 320, 240);
1212 ok(color == 0x00ffffff, "Offscreen failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1213 /* Some quad in the cleared part of the texture */
1214 color = getPixelColor(device, 170, 240);
1215 ok(color == 0x00ff00ff, "Offscreen failed: Got color 0x%08x, expected 0x00ff00ff.\n", color);
1216 /* Part of the originally cleared back buffer */
1217 color = getPixelColor(device, 10, 10);
1218 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1219 if(0) {
1220 /* Lower left corner of the screen, where back buffer offscreen rendering draws the offscreen texture.
1221 * It should be red, but the offscreen texture may leave some junk there. Not tested yet. Depending on
1222 * the offscreen rendering mode this test would succeed or fail
1223 */
1224 color = getPixelColor(device, 10, 470);
1225 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1226 }
1227
1228 out:
1229 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1230
1231 /* restore things */
1232 if(backbuffer) {
1233 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1234 IDirect3DSurface9_Release(backbuffer);
1235 }
1236 if(offscreenTexture) {
1237 IDirect3DTexture9_Release(offscreenTexture);
1238 }
1239 if(offscreen) {
1240 IDirect3DSurface9_Release(offscreen);
1241 }
1242 }
1243
1244 /* This test tests fog in combination with shaders.
1245 * What's tested: linear fog (vertex and table) with pixel shader
1246 * linear table fog with non foggy vertex shader
1247 * vertex fog with foggy vertex shader
1248 * What's not tested: non linear fog with shader
1249 * table fog with foggy vertex shader
1250 */
1251 static void fog_with_shader_test(IDirect3DDevice9 *device)
1252 {
1253 HRESULT hr;
1254 DWORD color;
1255 union {
1256 float f;
1257 DWORD i;
1258 } start, end;
1259 unsigned int i, j;
1260
1261 /* basic vertex shader without fog computation ("non foggy") */
1262 static const DWORD vertex_shader_code1[] = {
1263 0xfffe0101, /* vs_1_1 */
1264 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1265 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1266 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1267 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1268 0x0000ffff
1269 };
1270 /* basic vertex shader with reversed fog computation ("foggy") */
1271 static const DWORD vertex_shader_code2[] = {
1272 0xfffe0101, /* vs_1_1 */
1273 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1274 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1275 0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
1276 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1277 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1278 0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000, /* add r0, v0.z, c0.z */
1279 0x00000005, 0xc00f0001, 0x80000000, 0xa0000000, /* mul oFog, r0.x, c0.x */
1280 0x0000ffff
1281 };
1282 /* basic pixel shader */
1283 static const DWORD pixel_shader_code[] = {
1284 0xffff0101, /* ps_1_1 */
1285 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, vo */
1286 0x0000ffff
1287 };
1288
1289 static struct vertex quad[] = {
1290 {-1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1291 {-1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1292 { 1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1293 { 1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1294 };
1295
1296 static const D3DVERTEXELEMENT9 decl_elements[] = {
1297 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1298 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
1299 D3DDECL_END()
1300 };
1301
1302 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1303 IDirect3DVertexShader9 *vertex_shader[3] = {NULL, NULL, NULL};
1304 IDirect3DPixelShader9 *pixel_shader[2] = {NULL, NULL};
1305
1306 /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
1307 static const struct test_data_t {
1308 int vshader;
1309 int pshader;
1310 D3DFOGMODE vfog;
1311 D3DFOGMODE tfog;
1312 unsigned int color[11];
1313 } test_data[] = {
1314 /* only pixel shader: */
1315 {0, 1, 0, 3,
1316 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1317 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1318 {0, 1, 1, 3,
1319 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1320 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1321 {0, 1, 2, 3,
1322 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1323 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1324 {0, 1, 3, 0,
1325 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1326 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1327 {0, 1, 3, 3,
1328 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1329 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1330
1331 /* vertex shader */
1332 {1, 0, 0, 0,
1333 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
1334 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
1335 {1, 0, 0, 3,
1336 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1337 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1338 {1, 0, 1, 3,
1339 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1340 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1341
1342 {1, 0, 2, 3,
1343 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1344 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1345 {1, 0, 3, 3,
1346 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1347 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1348
1349 /* vertex shader and pixel shader */
1350 {1, 1, 0, 3,
1351 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1352 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1353 {1, 1, 1, 3,
1354 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1355 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1356 {1, 1, 2, 3,
1357 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1358 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1359
1360 {1, 1, 3, 3,
1361 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1362 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1363
1364
1365 #if 0 /* FIXME: these fail on GeForce 8500 */
1366 /* foggy vertex shader */
1367 {2, 0, 0, 0,
1368 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1369 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1370 {2, 0, 1, 0,
1371 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1372 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1373 {2, 0, 2, 0,
1374 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1375 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1376 {2, 0, 3, 0,
1377 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1378 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1379 #endif
1380
1381 /* foggy vertex shader and pixel shader */
1382 {2, 1, 0, 0,
1383 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1384 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1385 {2, 1, 1, 0,
1386 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1387 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1388 {2, 1, 2, 0,
1389 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1390 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1391 {2, 1, 3, 0,
1392 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1393 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1394
1395 };
1396
1397 /* NOTE: changing these values will not affect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
1398 start.f=0.1f;
1399 end.f=0.9f;
1400
1401 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]);
1402 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1403 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]);
1404 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1405 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]);
1406 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1407 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1408 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
1409
1410 /* Setup initial states: No lighting, fog on, fog color */
1411 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1412 ok(hr == D3D_OK, "Turning off lighting failed (%08x)\n", hr);
1413 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
1414 ok(hr == D3D_OK, "Turning on fog calculations failed (%08x)\n", hr);
1415 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
1416 ok(hr == D3D_OK, "Setting fog color failed (%08x)\n", hr);
1417 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1418 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1419
1420 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
1421 ok(hr == D3D_OK, "Turning off table fog failed (%08x)\n", hr);
1422 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
1423 ok(hr == D3D_OK, "Turning off vertex fog failed (%08x)\n", hr);
1424
1425 /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
1426 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i);
1427 ok(hr == D3D_OK, "Setting fog start failed (%08x)\n", hr);
1428 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i);
1429 ok(hr == D3D_OK, "Setting fog end failed (%08x)\n", hr);
1430
1431 for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++)
1432 {
1433 hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]);
1434 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1435 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[test_data[i].pshader]);
1436 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1437 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog);
1438 ok( hr == D3D_OK, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1439 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog);
1440 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1441
1442 for(j=0; j < 11; j++)
1443 {
1444 /* Don't use the whole zrange to prevent rounding errors */
1445 quad[0].z = 0.001f + (float)j / 10.02f;
1446 quad[1].z = 0.001f + (float)j / 10.02f;
1447 quad[2].z = 0.001f + (float)j / 10.02f;
1448 quad[3].z = 0.001f + (float)j / 10.02f;
1449
1450 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1451 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1452
1453 hr = IDirect3DDevice9_BeginScene(device);
1454 ok( hr == D3D_OK, "BeginScene returned failed (%08x)\n", hr);
1455
1456 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1457 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
1458
1459 hr = IDirect3DDevice9_EndScene(device);
1460 ok(hr == D3D_OK, "EndScene failed (%08x)\n", hr);
1461
1462 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1463
1464 /* As the red and green component are the result of blending use 5% tolerance on the expected value */
1465 color = getPixelColor(device, 128, 240);
1466 ok((unsigned char)(color) == ((unsigned char)test_data[i].color[j])
1467 && abs( ((unsigned char)(color>>8)) - (unsigned char)(test_data[i].color[j]>>8) ) < 13
1468 && abs( ((unsigned char)(color>>16)) - (unsigned char)(test_data[i].color[j]>>16) ) < 13,
1469 "fog vs%i ps%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%\n",
1470 test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, j, color, test_data[i].color[j]);
1471 }
1472 }
1473
1474 /* reset states */
1475 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1476 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1477 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1478 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1479 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1480 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1481 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1482 ok(hr == D3D_OK, "Turning off fog calculations failed (%08x)\n", hr);
1483
1484 IDirect3DVertexShader9_Release(vertex_shader[1]);
1485 IDirect3DVertexShader9_Release(vertex_shader[2]);
1486 IDirect3DPixelShader9_Release(pixel_shader[1]);
1487 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1488 }
1489
1490 static void generate_bumpmap_textures(IDirect3DDevice9 *device) {
1491 unsigned int i, x, y;
1492 HRESULT hr;
1493 IDirect3DTexture9 *texture[2] = {NULL, NULL};
1494 D3DLOCKED_RECT locked_rect;
1495
1496 /* Generate the textures */
1497 for(i=0; i<2; i++)
1498 {
1499 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, 0, i?D3DFMT_A8R8G8B8:D3DFMT_V8U8,
1500 D3DPOOL_MANAGED, &texture[i], NULL);
1501 ok(SUCCEEDED(hr), "CreateTexture failed (0x%08x)\n", hr);
1502
1503 hr = IDirect3DTexture9_LockRect(texture[i], 0, &locked_rect, NULL, 0);
1504 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1505 for (y = 0; y < 128; ++y)
1506 {
1507 if(i)
1508 { /* Set up black texture with 2x2 texel white spot in the middle */
1509 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1510 for (x = 0; x < 128; ++x)
1511 {
1512 if(y>62 && y<66 && x>62 && x<66)
1513 *ptr++ = 0xffffffff;
1514 else
1515 *ptr++ = 0xff000000;
1516 }
1517 }
1518 else
1519 { /* Set up a displacement map which points away from the center parallel to the closest axis.
1520 * (if multiplied with bumpenvmat)
1521 */
1522 WORD *ptr = (WORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1523 for (x = 0; x < 128; ++x)
1524 {
1525 if(abs(x-64)>abs(y-64))
1526 {
1527 if(x < 64)
1528 *ptr++ = 0xc000;
1529 else
1530 *ptr++ = 0x4000;
1531 }
1532 else
1533 {
1534 if(y < 64)
1535 *ptr++ = 0x0040;
1536 else
1537 *ptr++ = 0x00c0;
1538 }
1539 }
1540 }
1541 }
1542 hr = IDirect3DTexture9_UnlockRect(texture[i], 0);
1543 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1544
1545 hr = IDirect3DDevice9_SetTexture(device, i, (IDirect3DBaseTexture9 *)texture[i]);
1546 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1547
1548 /* Disable texture filtering */
1549 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1550 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1551 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1552 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1553
1554 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1555 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr);
1556 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1557 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr);
1558 }
1559 }
1560
1561 /* test the behavior of the texbem instruction
1562 * with normal 2D and projective 2D textures
1563 */
1564 static void texbem_test(IDirect3DDevice9 *device)
1565 {
1566 HRESULT hr;
1567 DWORD color;
1568 int i;
1569
1570 static const DWORD pixel_shader_code[] = {
1571 0xffff0101, /* ps_1_1*/
1572 0x00000042, 0xb00f0000, /* tex t0*/
1573 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
1574 0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
1575 0x0000ffff
1576 };
1577 static const DWORD double_texbem_code[] = {
1578 0xffff0103, /* ps_1_3 */
1579 0x00000042, 0xb00f0000, /* tex t0 */
1580 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0 */
1581 0x00000042, 0xb00f0002, /* tex t2 */
1582 0x00000043, 0xb00f0003, 0xb0e40002, /* texbem t3, t2 */
1583 0x00000002, 0x800f0000, 0xb0e40001, 0xb0e40003, /* add r0, t1, t3 */
1584 0x0000ffff /* end */
1585 };
1586
1587
1588 static const float quad[][7] = {
1589 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
1590 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
1591 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
1592 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
1593 };
1594 static const float quad_proj[][9] = {
1595 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 128.0f},
1596 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 128.0f, 0.0f, 128.0f},
1597 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 128.0f, 0.0f, 0.0f, 128.0f},
1598 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 128.0f, 128.0f, 0.0f, 128.0f},
1599 };
1600
1601 static const D3DVERTEXELEMENT9 decl_elements[][4] = { {
1602 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1603 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1604 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1605 D3DDECL_END()
1606 },{
1607 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1608 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1609 {0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1610 D3DDECL_END()
1611 } };
1612
1613 /* use asymmetric matrix to test loading */
1614 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
1615
1616 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1617 IDirect3DPixelShader9 *pixel_shader = NULL;
1618 IDirect3DTexture9 *texture = NULL, *texture1, *texture2;
1619 D3DLOCKED_RECT locked_rect;
1620
1621 generate_bumpmap_textures(device);
1622
1623 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1624 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1625 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1626 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1627 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
1628
1629 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1630 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1631
1632 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1633 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1634
1635 for(i=0; i<2; i++)
1636 {
1637 if(i)
1638 {
1639 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
1640 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1641 }
1642
1643 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements[i], &vertex_declaration);
1644 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1645 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1646 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1647
1648 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader);
1649 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1650 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1651 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1652
1653 hr = IDirect3DDevice9_BeginScene(device);
1654 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1655
1656 if(!i)
1657 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1658 else
1659 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad_proj[0], sizeof(quad_proj[0]));
1660 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1661
1662 hr = IDirect3DDevice9_EndScene(device);
1663 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1664
1665 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1666 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1667
1668 color = getPixelColor(device, 320-32, 240);
1669 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1670 color = getPixelColor(device, 320+32, 240);
1671 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1672 color = getPixelColor(device, 320, 240-32);
1673 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1674 color = getPixelColor(device, 320, 240+32);
1675 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1676
1677 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1678 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1679 IDirect3DPixelShader9_Release(pixel_shader);
1680
1681 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1682 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1683 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1684 }
1685
1686 /* clean up */
1687 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1688 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1689
1690 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
1691 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1692
1693 for(i=0; i<2; i++)
1694 {
1695 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
1696 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
1697 IDirect3DTexture9_Release(texture); /* For the GetTexture */
1698 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
1699 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1700 IDirect3DTexture9_Release(texture);
1701 }
1702
1703 /* Test double texbem */
1704 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture, NULL);
1705 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1706 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture1, NULL);
1707 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1708 hr = IDirect3DDevice9_CreateTexture(device, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture2, NULL);
1709 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1710 hr = IDirect3DDevice9_CreatePixelShader(device, double_texbem_code, &pixel_shader);
1711 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1712
1713 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
1714 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1715 ((signed char *) locked_rect.pBits)[0] = (-1.0 / 8.0) * 127;
1716 ((signed char *) locked_rect.pBits)[1] = ( 1.0 / 8.0) * 127;
1717
1718 hr = IDirect3DTexture9_UnlockRect(texture, 0);
1719 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1720
1721 hr = IDirect3DTexture9_LockRect(texture1, 0, &locked_rect, NULL, 0);
1722 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1723 ((signed char *) locked_rect.pBits)[0] = (-2.0 / 8.0) * 127;
1724 ((signed char *) locked_rect.pBits)[1] = (-4.0 / 8.0) * 127;
1725 hr = IDirect3DTexture9_UnlockRect(texture1, 0);
1726 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1727
1728 {
1729 /* Some data without any meaning, just to have an 8x8 array to see which element is picked */
1730 #define tex 0x00ff0000
1731 #define tex1 0x0000ff00
1732 #define origin 0x000000ff
1733 static const DWORD pixel_data[] = {
1734 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1735 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1736 0x000000ff, tex1 , 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1737 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1738 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, origin, 0x000000ff, tex , 0x000000ff,
1739 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1740 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1741 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1742 };
1743 #undef tex1
1744 #undef tex2
1745 #undef origin
1746
1747 hr = IDirect3DTexture9_LockRect(texture2, 0, &locked_rect, NULL, 0);
1748 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1749 for(i = 0; i < 8; i++) {
1750 memcpy(((char *) locked_rect.pBits) + i * locked_rect.Pitch, pixel_data + 8 * i, 8 * sizeof(DWORD));
1751 }
1752 hr = IDirect3DTexture9_UnlockRect(texture2, 0);
1753 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1754 }
1755
1756 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
1757 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1758 hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) texture2);
1759 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1760 hr = IDirect3DDevice9_SetTexture(device, 2, (IDirect3DBaseTexture9 *) texture1);
1761 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1762 hr = IDirect3DDevice9_SetTexture(device, 3, (IDirect3DBaseTexture9 *) texture2);
1763 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1764 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1765 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1766 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX4);
1767 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1768
1769 bumpenvmat[0] =-1.0; bumpenvmat[2] = 2.0;
1770 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.0;
1771 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1772 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1773 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1774 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1775
1776 bumpenvmat[0] = 1.5; bumpenvmat[2] = 0.0;
1777 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.5;
1778 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1779 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1780 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1781 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1782
1783 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1784 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1785 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1786 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1787 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1788 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1789 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1790 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1791
1792 hr = IDirect3DDevice9_BeginScene(device);
1793 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1794 if(SUCCEEDED(hr)) {
1795 static const float double_quad[] = {
1796 -1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1797 1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1798 -1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1799 1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1800 };
1801
1802 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, double_quad, sizeof(float) * 11);
1803 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1804 hr = IDirect3DDevice9_EndScene(device);
1805 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1806 }
1807 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1808 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1809 color = getPixelColor(device, 320, 240);
1810 ok(color == 0x00ffff00, "double texbem failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1811
1812 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1813 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1814 hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
1815 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1816 hr = IDirect3DDevice9_SetTexture(device, 2, NULL);
1817 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1818 hr = IDirect3DDevice9_SetTexture(device, 3, NULL);
1819 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1820 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1821 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1822
1823 IDirect3DPixelShader9_Release(pixel_shader);
1824 IDirect3DTexture9_Release(texture);
1825 IDirect3DTexture9_Release(texture1);
1826 IDirect3DTexture9_Release(texture2);
1827 }
1828
1829 static void z_range_test(IDirect3DDevice9 *device)
1830 {
1831 const struct vertex quad[] =
1832 {
1833 {-1.0f, 0.0f, 1.1f, 0xffff0000},
1834 {-1.0f, 1.0f, 1.1f, 0xffff0000},
1835 { 1.0f, 0.0f, -1.1f, 0xffff0000},
1836 { 1.0f, 1.0f, -1.1f, 0xffff0000},
1837 };
1838 const struct vertex quad2[] =
1839 {
1840 {-1.0f, 0.0f, 1.1f, 0xff0000ff},
1841 {-1.0f, 1.0f, 1.1f, 0xff0000ff},
1842 { 1.0f, 0.0f, -1.1f, 0xff0000ff},
1843 { 1.0f, 1.0f, -1.1f, 0xff0000ff},
1844 };
1845
1846 const struct tvertex quad3[] =
1847 {
1848 { 0, 240, 1.1f, 1.0, 0xffffff00},
1849 { 0, 480, 1.1f, 1.0, 0xffffff00},
1850 { 640, 240, -1.1f, 1.0, 0xffffff00},
1851 { 640, 480, -1.1f, 1.0, 0xffffff00},
1852 };
1853 const struct tvertex quad4[] =
1854 {
1855 { 0, 240, 1.1f, 1.0, 0xff00ff00},
1856 { 0, 480, 1.1f, 1.0, 0xff00ff00},
1857 { 640, 240, -1.1f, 1.0, 0xff00ff00},
1858 { 640, 480, -1.1f, 1.0, 0xff00ff00},
1859 };
1860 HRESULT hr;
1861 DWORD color;
1862 IDirect3DVertexShader9 *shader;
1863 IDirect3DVertexDeclaration9 *decl;
1864 D3DCAPS9 caps;
1865 const DWORD shader_code[] = {
1866 0xfffe0101, /* vs_1_1 */
1867 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1868 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1869 0x00000001, 0xd00f0000, 0xa0e40000, /* mov oD0, c0 */
1870 0x0000ffff /* end */
1871 };
1872 static const D3DVERTEXELEMENT9 decl_elements[] = {
1873 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1874 D3DDECL_END()
1875 };
1876 /* Does the Present clear the depth stencil? Clear the depth buffer with some value != 0,
1877 * then call Present. Then clear the color buffer to make sure it has some defined content
1878 * after the Present with D3DSWAPEFFECT_DISCARD. After that draw a plane that is somewhere cut
1879 * by the depth value.
1880 */
1881 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.75, 0);
1882 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
1883 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1884 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1885
1886 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, TRUE);
1887 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1888 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
1889 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1890 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
1891 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1892 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1893 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1894 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
1895 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
1896
1897 hr = IDirect3DDevice9_BeginScene(device);
1898 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
1899 if(hr == D3D_OK)
1900 {
1901 /* Test the untransformed vertex path */
1902 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1903 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1904 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1905 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1906 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1907 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1908
1909 /* Test the transformed vertex path */
1910 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
1911 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
1912
1913 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad4, sizeof(quad4[0]));
1914 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1915 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1916 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1917 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad3, sizeof(quad3[0]));
1918 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1919
1920 hr = IDirect3DDevice9_EndScene(device);
1921 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
1922 }
1923
1924 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1925 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1926
1927 /* Do not test the exact corner pixels, but go pretty close to them */
1928
1929 /* Clipped because z > 1.0 */
1930 color = getPixelColor(device, 28, 238);
1931 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1932 color = getPixelColor(device, 28, 241);
1933 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1934
1935 /* Not clipped, > z buffer clear value(0.75) */
1936 color = getPixelColor(device, 31, 238);
1937 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1938 color = getPixelColor(device, 31, 241);
1939 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1940 color = getPixelColor(device, 100, 238);
1941 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1942 color = getPixelColor(device, 100, 241);
1943 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1944
1945 /* Not clipped, < z buffer clear value */
1946 color = getPixelColor(device, 104, 238);
1947 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
1948 color = getPixelColor(device, 104, 241);
1949 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
1950 color = getPixelColor(device, 318, 238);
1951 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
1952 color = getPixelColor(device, 318, 241);
1953 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
1954
1955 /* Clipped because z < 0.0 */
1956 color = getPixelColor(device, 321, 238);
1957 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1958 color = getPixelColor(device, 321, 241);
1959 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1960
1961 /* Test the shader path */
1962 IDirect3DDevice9_GetDeviceCaps(device, &caps);
1963 if (caps.VertexShaderVersion < D3DVS_VERSION(1, 1)) {
1964 skip("Vertex shaders not supported\n");
1965 goto out;
1966 }
1967 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
1968 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
1969 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
1970 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
1971
1972 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1973
1974 IDirect3DDevice9_SetVertexDeclaration(device, decl);
1975 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
1976 IDirect3DDevice9_SetVertexShader(device, shader);
1977 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
1978
1979 hr = IDirect3DDevice9_BeginScene(device);
1980 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
1981 if(hr == D3D_OK)
1982 {
1983 float colorf[] = {1.0, 0.0, 0.0, 1.0};
1984 float colorf2[] = {0.0, 0.0, 1.0, 1.0};
1985 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf, 1);
1986 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1987 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1988 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1989 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1990 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf2, 1);
1991 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1992 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1993
1994 hr = IDirect3DDevice9_EndScene(device);
1995 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
1996 }
1997
1998 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1999 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
2000 IDirect3DDevice9_SetVertexShader(device, NULL);
2001 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
2002
2003 IDirect3DVertexDeclaration9_Release(decl);
2004 IDirect3DVertexShader9_Release(shader);
2005
2006 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2007 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2008 /* Z < 1.0 */
2009 color = getPixelColor(device, 28, 238);
2010 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2011
2012 /* 1.0 < z < 0.75 */
2013 color = getPixelColor(device, 31, 238);
2014 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2015 color = getPixelColor(device, 100, 238);
2016 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2017
2018 /* 0.75 < z < 0.0 */
2019 color = getPixelColor(device, 104, 238);
2020 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2021 color = getPixelColor(device, 318, 238);
2022 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2023
2024 /* 0.0 < z */
2025 color = getPixelColor(device, 321, 238);
2026 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2027
2028 out:
2029 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
2030 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2031 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
2032 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2033 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
2034 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2035 }
2036
2037 static void fill_surface(IDirect3DSurface9 *surface, DWORD color)
2038 {
2039 D3DSURFACE_DESC desc;
2040 D3DLOCKED_RECT l;
2041 HRESULT hr;
2042 unsigned int x, y;
2043 DWORD *mem;
2044
2045 memset(&desc, 0, sizeof(desc));
2046 memset(&l, 0, sizeof(l));
2047 hr = IDirect3DSurface9_GetDesc(surface, &desc);
2048 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %s\n", DXGetErrorString9(hr));
2049 hr = IDirect3DSurface9_LockRect(surface, &l, NULL, 0);
2050 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed with %s\n", DXGetErrorString9(hr));
2051 if(FAILED(hr)) return;
2052
2053 for(y = 0; y < desc.Height; y++)
2054 {
2055 mem = (DWORD *) ((BYTE *) l.pBits + y * l.Pitch);
2056 for(x = 0; x < l.Pitch / sizeof(DWORD); x++)
2057 {
2058 mem[x] = color;
2059 }
2060 }
2061 hr = IDirect3DSurface9_UnlockRect(surface);
2062 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2063 }
2064
2065 /* This tests a variety of possible StretchRect() situations */
2066 static void stretchrect_test(IDirect3DDevice9 *device)
2067 {
2068 HRESULT hr;
2069 IDirect3DTexture9 *tex_rt32 = NULL, *tex_rt64 = NULL, *tex_rt_dest64 = NULL;
2070 IDirect3DSurface9 *surf_tex_rt32 = NULL, *surf_tex_rt64 = NULL, *surf_tex_rt_dest64 = NULL;
2071 IDirect3DTexture9 *tex32 = NULL, *tex64 = NULL, *tex_dest64 = NULL;
2072 IDirect3DSurface9 *surf_tex32 = NULL, *surf_tex64 = NULL, *surf_tex_dest64 = NULL;
2073 IDirect3DSurface9 *surf_rt32 = NULL, *surf_rt64 = NULL, *surf_rt_dest64 = NULL;
2074 IDirect3DSurface9 *surf_offscreen32 = NULL, *surf_offscreen64 = NULL, *surf_offscreen_dest64 = NULL;
2075 IDirect3DSurface9 *surf_temp32 = NULL, *surf_temp64 = NULL;
2076 IDirect3DSurface9 *orig_rt = NULL;
2077 DWORD color;
2078
2079 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &orig_rt);
2080 ok(hr == D3D_OK, "Can't get render target, hr = %s\n", DXGetErrorString9(hr));
2081 if(!orig_rt) {
2082 goto out;
2083 }
2084
2085 /* Create our temporary surfaces in system memory */
2086 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp32, NULL);
2087 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2088 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp64, NULL);
2089 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2090
2091 /* Create offscreen plain surfaces in D3DPOOL_DEFAULT */
2092 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen32, NULL);
2093 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2094 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen64, NULL);
2095 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2096 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen_dest64, NULL);
2097 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2098
2099 /* Create render target surfaces */
2100 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt32, NULL );
2101 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2102 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt64, NULL );
2103 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2104 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt_dest64, NULL );
2105 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2106
2107 /* Create render target textures */
2108 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt32, NULL);
2109 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2110 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt64, NULL);
2111 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2112 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt_dest64, NULL);
2113 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2114 if (tex_rt32) {
2115 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt32, 0, &surf_tex_rt32);
2116 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2117 }
2118 if (tex_rt64) {
2119 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt64, 0, &surf_tex_rt64);
2120 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2121 }
2122 if (tex_rt_dest64) {
2123 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt_dest64, 0, &surf_tex_rt_dest64);
2124 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2125 }
2126
2127 /* Create regular textures in D3DPOOL_DEFAULT */
2128 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex32, NULL);
2129 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2130 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex64, NULL);
2131 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2132 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_dest64, NULL);
2133 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2134 if (tex32) {
2135 hr = IDirect3DTexture9_GetSurfaceLevel(tex32, 0, &surf_tex32);
2136 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2137 }
2138 if (tex64) {
2139 hr = IDirect3DTexture9_GetSurfaceLevel(tex64, 0, &surf_tex64);
2140 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2141 }
2142 if (tex_dest64) {
2143 hr = IDirect3DTexture9_GetSurfaceLevel(tex_dest64, 0, &surf_tex_dest64);
2144 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2145 }
2146
2147 /*********************************************************************
2148 * Tests for when the source parameter is an offscreen plain surface *
2149 *********************************************************************/
2150
2151 /* Fill the offscreen 64x64 surface with green */
2152 if (surf_offscreen64)
2153 fill_surface(surf_offscreen64, 0xff00ff00);
2154
2155 /* offscreenplain ==> offscreenplain, same size */
2156 if(surf_offscreen64 && surf_offscreen_dest64) {
2157 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_offscreen_dest64, NULL, 0);
2158 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2159
2160 if (hr == D3D_OK) {
2161 color = getPixelColorFromSurface(surf_offscreen_dest64, 32, 32);
2162 ok(color == 0xff00ff00, "StretchRect offscreen ==> offscreen same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2163 }
2164 }
2165
2166 /* offscreenplain ==> rendertarget texture, same size */
2167 if(surf_offscreen64 && surf_tex_rt_dest64 && surf_temp64) {
2168 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_rt_dest64, NULL, 0);
2169 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2170
2171 /* We can't lock rendertarget textures, so copy to our temp surface first */
2172 if (hr == D3D_OK) {
2173 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2174 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2175 }
2176
2177 if (hr == D3D_OK) {
2178 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2179 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2180 }
2181 }
2182
2183 /* offscreenplain ==> rendertarget surface, same size */
2184 if(surf_offscreen64 && surf_rt_dest64) {
2185 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_rt_dest64, NULL, 0);
2186 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2187
2188 if (hr == D3D_OK) {
2189 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2190 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2191 }
2192 }
2193
2194 /* offscreenplain ==> texture, same size (should fail) */
2195 if(surf_offscreen64 && surf_tex_dest64) {
2196 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_dest64, NULL, 0);
2197 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2198 }
2199
2200 /* Fill the smaller offscreen surface with red */
2201 fill_surface(surf_offscreen32, 0xffff0000);
2202
2203 /* offscreenplain ==> offscreenplain, scaling (should fail) */
2204 if(surf_offscreen32 && surf_offscreen64) {
2205 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_offscreen64, NULL, 0);
2206 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2207 }
2208
2209 /* offscreenplain ==> rendertarget texture, scaling */
2210 if(surf_offscreen32 && surf_tex_rt_dest64 && surf_temp64) {
2211 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_rt_dest64, NULL, 0);
2212 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2213
2214 /* We can't lock rendertarget textures, so copy to our temp surface first */
2215 if (hr == D3D_OK) {
2216 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2217 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2218 }
2219
2220 if (hr == D3D_OK) {
2221 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2222 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2223 }
2224 }
2225
2226 /* offscreenplain ==> rendertarget surface, scaling */
2227 if(surf_offscreen32 && surf_rt_dest64) {
2228 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_rt_dest64, NULL, 0);
2229 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2230
2231 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2232 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2233 }
2234
2235 /* offscreenplain ==> texture, scaling (should fail) */
2236 if(surf_offscreen32 && surf_tex_dest64) {
2237 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_dest64, NULL, 0);
2238 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2239 }
2240
2241 /************************************************************
2242 * Tests for when the source parameter is a regular texture *
2243 ************************************************************/
2244
2245 /* Fill the surface of the regular texture with blue */
2246 if (surf_tex64 && surf_temp64) {
2247 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2248 fill_surface(surf_temp64, 0xff0000ff);
2249 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex64, NULL);
2250 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2251 }
2252
2253 /* texture ==> offscreenplain, same size */
2254 if(surf_tex64 && surf_offscreen64) {
2255 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_offscreen64, NULL, 0);
2256 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2257 }
2258
2259 /* texture ==> rendertarget texture, same size */
2260 if(surf_tex64 && surf_tex_rt_dest64 && surf_temp64) {
2261 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_rt_dest64, NULL, 0);
2262 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2263
2264 /* We can't lock rendertarget textures, so copy to our temp surface first */
2265 if (hr == D3D_OK) {
2266 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2267 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2268 }
2269
2270 if (hr == D3D_OK) {
2271 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2272 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2273 }
2274 }
2275
2276 /* texture ==> rendertarget surface, same size */
2277 if(surf_tex64 && surf_rt_dest64) {
2278 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_rt_dest64, NULL, 0);
2279 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2280
2281 if (hr == D3D_OK) {
2282 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2283 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2284 }
2285 }
2286
2287 /* texture ==> texture, same size (should fail) */
2288 if(surf_tex64 && surf_tex_dest64) {
2289 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_dest64, NULL, 0);
2290 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2291 }
2292
2293 /* Fill the surface of the smaller regular texture with red */
2294 if (surf_tex32 && surf_temp32) {
2295 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2296 fill_surface(surf_temp32, 0xffff0000);
2297 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex32, NULL);
2298 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2299 }
2300
2301 /* texture ==> offscreenplain, scaling (should fail) */
2302 if(surf_tex32 && surf_offscreen64) {
2303 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_offscreen64, NULL, 0);
2304 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2305 }
2306
2307 /* texture ==> rendertarget texture, scaling */
2308 if(surf_tex32 && surf_tex_rt_dest64 && surf_temp64) {
2309 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_rt_dest64, NULL, 0);
2310 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2311
2312 /* We can't lock rendertarget textures, so copy to our temp surface first */
2313 if (hr == D3D_OK) {
2314 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2315 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2316 }
2317
2318 if (hr == D3D_OK) {
2319 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2320 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2321 }
2322 }
2323
2324 /* texture ==> rendertarget surface, scaling */
2325 if(surf_tex32 && surf_rt_dest64) {
2326 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_rt_dest64, NULL, 0);
2327 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2328
2329 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2330 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2331 }
2332
2333 /* texture ==> texture, scaling (should fail) */
2334 if(surf_tex32 && surf_tex_dest64) {
2335 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_dest64, NULL, 0);
2336 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2337 }
2338
2339 /*****************************************************************
2340 * Tests for when the source parameter is a rendertarget texture *
2341 *****************************************************************/
2342
2343 /* Fill the surface of the rendertarget texture with white */
2344 if (surf_tex_rt64 && surf_temp64) {
2345 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2346 fill_surface(surf_temp64, 0xffffffff);
2347 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex_rt64, NULL);
2348 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2349 }
2350
2351 /* rendertarget texture ==> offscreenplain, same size */
2352 if(surf_tex_rt64 && surf_offscreen64) {
2353 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_offscreen64, NULL, 0);
2354 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2355 }
2356
2357 /* rendertarget texture ==> rendertarget texture, same size */
2358 if(surf_tex_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2359 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2360 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2361
2362 /* We can't lock rendertarget textures, so copy to our temp surface first */
2363 if (hr == D3D_OK) {
2364 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2365 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2366 }
2367
2368 if (hr == D3D_OK) {
2369 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2370 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2371 }
2372 }
2373
2374 /* rendertarget texture ==> rendertarget surface, same size */
2375 if(surf_tex_rt64 && surf_rt_dest64) {
2376 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_rt_dest64, NULL, 0);
2377 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2378
2379 if (hr == D3D_OK) {
2380 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2381 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2382 }
2383 }
2384
2385 /* rendertarget texture ==> texture, same size (should fail) */
2386 if(surf_tex_rt64 && surf_tex_dest64) {
2387 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_dest64, NULL, 0);
2388 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2389 }
2390
2391 /* Fill the surface of the smaller rendertarget texture with red */
2392 if (surf_tex_rt32 && surf_temp32) {
2393 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2394 fill_surface(surf_temp32, 0xffff0000);
2395 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex_rt32, NULL);
2396 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2397 }
2398
2399 /* rendertarget texture ==> offscreenplain, scaling (should fail) */
2400 if(surf_tex_rt32 && surf_offscreen64) {
2401 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_offscreen64, NULL, 0);
2402 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2403 }
2404
2405 /* rendertarget texture ==> rendertarget texture, scaling */
2406 if(surf_tex_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2407 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2408 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2409
2410 /* We can't lock rendertarget textures, so copy to our temp surface first */
2411 if (hr == D3D_OK) {
2412 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2413 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2414 }
2415
2416 if (hr == D3D_OK) {
2417 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2418 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2419 }
2420 }
2421
2422 /* rendertarget texture ==> rendertarget surface, scaling */
2423 if(surf_tex_rt32 && surf_rt_dest64) {
2424 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_rt_dest64, NULL, 0);
2425 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2426
2427 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2428 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2429 }
2430
2431 /* rendertarget texture ==> texture, scaling (should fail) */
2432 if(surf_tex_rt32 && surf_tex_dest64) {
2433 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_dest64, NULL, 0);
2434 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2435 }
2436
2437 /*****************************************************************
2438 * Tests for when the source parameter is a rendertarget surface *
2439 *****************************************************************/
2440
2441 /* Fill the surface of the rendertarget surface with black */
2442 if (surf_rt64)
2443 fill_surface(surf_rt64, 0xff000000);
2444
2445 /* rendertarget texture ==> offscreenplain, same size */
2446 if(surf_rt64 && surf_offscreen64) {
2447 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_offscreen64, NULL, 0);
2448 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2449 }
2450
2451 /* rendertarget surface ==> rendertarget texture, same size */
2452 if(surf_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2453 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2454 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2455
2456 /* We can't lock rendertarget textures, so copy to our temp surface first */
2457 if (hr == D3D_OK) {
2458 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2459 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2460 }
2461
2462 if (hr == D3D_OK) {
2463 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2464 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2465 }
2466 }
2467
2468 /* rendertarget surface ==> rendertarget surface, same size */
2469 if(surf_rt64 && surf_rt_dest64) {
2470 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_rt_dest64, NULL, 0);
2471 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2472
2473 if (hr == D3D_OK) {
2474 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2475 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2476 }
2477 }
2478
2479 /* rendertarget surface ==> texture, same size (should fail) */
2480 if(surf_rt64 && surf_tex_dest64) {
2481 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_dest64, NULL, 0);
2482 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2483 }
2484
2485 /* Fill the surface of the smaller rendertarget texture with red */
2486 if (surf_rt32)
2487 fill_surface(surf_rt32, 0xffff0000);
2488
2489 /* rendertarget surface ==> offscreenplain, scaling (should fail) */
2490 if(surf_rt32 && surf_offscreen64) {
2491 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_offscreen64, NULL, 0);
2492 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2493 }
2494
2495 /* rendertarget surface ==> rendertarget texture, scaling */
2496 if(surf_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2497 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2498 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2499
2500 /* We can't lock rendertarget textures, so copy to our temp surface first */
2501 if (hr == D3D_OK) {
2502 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2503 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2504 }
2505
2506 if (hr == D3D_OK) {
2507 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2508 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2509 }
2510 }
2511
2512 /* rendertarget surface ==> rendertarget surface, scaling */
2513 if(surf_rt32 && surf_rt_dest64) {
2514 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_rt_dest64, NULL, 0);
2515 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2516
2517 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2518 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2519 }
2520
2521 /* rendertarget surface ==> texture, scaling (should fail) */
2522 if(surf_rt32 && surf_tex_dest64) {
2523 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_dest64, NULL, 0);
2524 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2525 }
2526
2527 /* TODO: Test when source and destination RECT parameters are given... */
2528 /* TODO: Test format conversions */
2529
2530
2531 out:
2532 /* Clean up */
2533 if (surf_rt32)
2534 IDirect3DSurface9_Release(surf_rt32);
2535 if (surf_rt64)
2536 IDirect3DSurface9_Release(surf_rt64);
2537 if (surf_rt_dest64)
2538 IDirect3DSurface9_Release(surf_rt_dest64);
2539 if (surf_temp32)
2540 IDirect3DSurface9_Release(surf_temp32);
2541 if (surf_temp64)
2542 IDirect3DSurface9_Release(surf_temp64);
2543 if (surf_offscreen32)
2544 IDirect3DSurface9_Release(surf_offscreen32);
2545 if (surf_offscreen64)
2546 IDirect3DSurface9_Release(surf_offscreen64);
2547 if (surf_offscreen_dest64)
2548 IDirect3DSurface9_Release(surf_offscreen_dest64);
2549
2550 if (tex_rt32) {
2551 if (surf_tex_rt32)
2552 IDirect3DSurface9_Release(surf_tex_rt32);
2553 IDirect3DTexture9_Release(tex_rt32);
2554 }
2555 if (tex_rt64) {
2556 if (surf_tex_rt64)
2557 IDirect3DSurface9_Release(surf_tex_rt64);
2558 IDirect3DTexture9_Release(tex_rt64);
2559 }
2560 if (tex_rt_dest64) {
2561 if (surf_tex_rt_dest64)
2562 IDirect3DSurface9_Release(surf_tex_rt_dest64);
2563 IDirect3DTexture9_Release(tex_rt_dest64);
2564 }
2565 if (tex32) {
2566 if (surf_tex32)
2567 IDirect3DSurface9_Release(surf_tex32);
2568 IDirect3DTexture9_Release(tex32);
2569 }
2570 if (tex64) {
2571 if (surf_tex64)
2572 IDirect3DSurface9_Release(surf_tex64);
2573 IDirect3DTexture9_Release(tex64);
2574 }
2575 if (tex_dest64) {
2576 if (surf_tex_dest64)
2577 IDirect3DSurface9_Release(surf_tex_dest64);
2578 IDirect3DTexture9_Release(tex_dest64);
2579 }
2580
2581 if (orig_rt) {
2582 hr = IDirect3DDevice9_SetRenderTarget(device, 0, orig_rt);
2583 ok(hr == D3D_OK, "IDirect3DSetRenderTarget failed with %s\n", DXGetErrorString9(hr));
2584 IDirect3DSurface9_Release(orig_rt);
2585 }
2586 }
2587
2588 static void maxmip_test(IDirect3DDevice9 *device)
2589 {
2590 IDirect3DTexture9 *texture = NULL;
2591 IDirect3DSurface9 *surface = NULL;
2592 HRESULT hr;
2593 DWORD color;
2594 const float quads[] = {
2595 -1.0, -1.0, 0.0, 0.0, 0.0,
2596 -1.0, 0.0, 0.0, 0.0, 1.0,
2597 0.0, -1.0, 0.0, 1.0, 0.0,
2598 0.0, 0.0, 0.0, 1.0, 1.0,
2599
2600 0.0, -1.0, 0.0, 0.0, 0.0,
2601 0.0, 0.0, 0.0, 0.0, 1.0,
2602 1.0, -1.0, 0.0, 1.0, 0.0,
2603 1.0, 0.0, 0.0, 1.0, 1.0,
2604
2605 0.0, 0.0, 0.0, 0.0, 0.0,
2606 0.0, 1.0, 0.0, 0.0, 1.0,
2607 1.0, 0.0, 0.0, 1.0, 0.0,
2608 1.0, 1.0, 0.0, 1.0, 1.0,
2609
2610 -1.0, 0.0, 0.0, 0.0, 0.0,
2611 -1.0, 1.0, 0.0, 0.0, 1.0,
2612 0.0, 0.0, 0.0, 1.0, 0.0,
2613 0.0, 1.0, 0.0, 1.0, 1.0,
2614 };
2615
2616 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2617 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
2618
2619 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
2620 &texture, NULL);
2621 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2622 if(!texture)
2623 {
2624 skip("Failed to create test texture\n");
2625 return;
2626 }
2627
2628 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
2629 fill_surface(surface, 0xffff0000);
2630 IDirect3DSurface9_Release(surface);
2631 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 1, &surface);
2632 fill_surface(surface, 0xff00ff00);
2633 IDirect3DSurface9_Release(surface);
2634 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 2, &surface);
2635 fill_surface(surface, 0xff0000ff);
2636 IDirect3DSurface9_Release(surface);
2637
2638 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2639 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2640 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2641 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2642
2643 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2644 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2645
2646 hr = IDirect3DDevice9_BeginScene(device);
2647 if(SUCCEEDED(hr))
2648 {
2649 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2650 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2651 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2652 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2653
2654 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2655 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2656 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2657 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2658
2659 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2660 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2661 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2662 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2663
2664 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2665 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2666 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2667 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2668 hr = IDirect3DDevice9_EndScene(device);
2669 }
2670
2671 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2672 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2673 /* With mipmapping disabled, the max mip level is ignored, only level 0 is used */
2674 color = getPixelColor(device, 160, 360);
2675 ok(color == 0x00FF0000, "MapMip 0, no mipfilter has color %08x\n", color);
2676 color = getPixelColor(device, 160, 120);
2677 ok(color == 0x00FF0000, "MapMip 3, no mipfilter has color %08x\n", color);
2678 color = getPixelColor(device, 480, 120);
2679 ok(color == 0x00FF0000, "MapMip 2, no mipfilter has color %08x\n", color);
2680 color = getPixelColor(device, 480, 360);
2681 ok(color == 0x00FF0000, "MapMip 1, no mipfilter has color %08x\n", color);
2682
2683 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2684 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
2685
2686 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
2687 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2688
2689 hr = IDirect3DDevice9_BeginScene(device);
2690 if(SUCCEEDED(hr))
2691 {
2692 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2693 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2694 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2695 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2696
2697 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2698 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2699 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2700 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2701
2702 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2703 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2704 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2705 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2706
2707 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2708 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2709 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2710 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2711 hr = IDirect3DDevice9_EndScene(device);
2712 }
2713
2714 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2715 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2716 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2717 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2718
2719 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2720 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2721 /* Max Mip level 0-2 sample from the specified texture level, Max Mip level 3(> levels in texture)
2722 * samples from the highest level in the texture(level 2)
2723 */
2724 color = getPixelColor(device, 160, 360);
2725 ok(color == 0x00FF0000, "MapMip 0, point mipfilter has color %08x\n", color);
2726 color = getPixelColor(device, 160, 120);
2727 ok(color == 0x000000FF, "MapMip 3, point mipfilter has color %08x\n", color);
2728 color = getPixelColor(device, 480, 120);
2729 ok(color == 0x000000FF, "MapMip 2, point mipfilter has color %08x\n", color);
2730 color = getPixelColor(device, 480, 360);
2731 ok(color == 0x0000FF00, "MapMip 1, point mipfilter has color %08x\n", color);
2732
2733 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2734 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2735 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2736 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2737 IDirect3DTexture9_Release(texture);
2738 }
2739
2740 static void release_buffer_test(IDirect3DDevice9 *device)
2741 {
2742 IDirect3DVertexBuffer9 *vb = NULL;
2743 IDirect3DIndexBuffer9 *ib = NULL;
2744 HRESULT hr;
2745 BYTE *data;
2746 long ref;
2747
2748 static const struct vertex quad[] = {
2749 {-1.0, -1.0, 0.1, 0xffff0000},
2750 {-1.0, 1.0, 0.1, 0xffff0000},
2751 { 1.0, 1.0, 0.1, 0xffff0000},
2752
2753 {-1.0, -1.0, 0.1, 0xff00ff00},
2754 {-1.0, 1.0, 0.1, 0xff00ff00},
2755 { 1.0, 1.0, 0.1, 0xff00ff00}
2756 };
2757 short indices[] = {3, 4, 5};
2758
2759 /* Index and vertex buffers should always be creatable */
2760 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE,
2761 D3DPOOL_MANAGED, &vb, NULL);
2762 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
2763 if(!vb) {
2764 skip("Failed to create a vertex buffer\n");
2765 return;
2766 }
2767 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
2768 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %s\n", DXGetErrorString9(hr));
2769 if(!ib) {
2770 skip("Failed to create an index buffer\n");
2771 return;
2772 }
2773
2774 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
2775 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
2776 memcpy(data, quad, sizeof(quad));
2777 hr = IDirect3DVertexBuffer9_Unlock(vb);
2778 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
2779
2780 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
2781 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
2782 memcpy(data, indices, sizeof(indices));
2783 hr = IDirect3DIndexBuffer9_Unlock(ib);
2784 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
2785
2786 hr = IDirect3DDevice9_SetIndices(device, ib);
2787 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %s\n", DXGetErrorString9(hr));
2788 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad[0]));
2789 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
2790 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
2791 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2792
2793 /* Now destroy the bound index buffer and draw again */
2794 ref = IDirect3DIndexBuffer9_Release(ib);
2795 ok(ref == 0, "Index Buffer reference count is %08ld\n", ref);
2796
2797 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
2798 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
2799
2800 hr = IDirect3DDevice9_BeginScene(device);
2801 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2802 if(SUCCEEDED(hr))
2803 {
2804 /* Deliberately using minvertexindex = 0 and numVertices = 6 to prevent d3d from
2805 * making assumptions about the indices or vertices
2806 */
2807 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 3, 3, 0, 1);
2808 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x\n", hr);
2809 hr = IDirect3DDevice9_EndScene(device);
2810 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2811 }
2812
2813 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2814 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2815
2816 hr = IDirect3DDevice9_SetIndices(device, NULL);
2817 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2818 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2819 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2820
2821 /* Index buffer was already destroyed as part of the test */
2822 IDirect3DVertexBuffer9_Release(vb);
2823 }
2824
2825 static void float_texture_test(IDirect3DDevice9 *device)
2826 {
2827 IDirect3D9 *d3d = NULL;
2828 HRESULT hr;
2829 IDirect3DTexture9 *texture = NULL;
2830 D3DLOCKED_RECT lr;
2831 float *data;
2832 DWORD color;
2833 float quad[] = {
2834 -1.0, -1.0, 0.1, 0.0, 0.0,
2835 -1.0, 1.0, 0.1, 0.0, 1.0,
2836 1.0, -1.0, 0.1, 1.0, 0.0,
2837 1.0, 1.0, 0.1, 1.0, 1.0,
2838 };
2839
2840 memset(&lr, 0, sizeof(lr));
2841 IDirect3DDevice9_GetDirect3D(device, &d3d);
2842 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2843 D3DRTYPE_TEXTURE, D3DFMT_R32F) != D3D_OK) {
2844 skip("D3DFMT_R32F textures not supported\n");
2845 goto out;
2846 }
2847
2848 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_R32F,
2849 D3DPOOL_MANAGED, &texture, NULL);
2850 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2851 if(!texture) {
2852 skip("Failed to create R32F texture\n");
2853 goto out;
2854 }
2855
2856 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2857 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
2858 data = lr.pBits;
2859 *data = 0.0;
2860 hr = IDirect3DTexture9_UnlockRect(texture, 0);
2861 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2862
2863 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2864 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2865
2866 hr = IDirect3DDevice9_BeginScene(device);
2867 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
2868 if(SUCCEEDED(hr))
2869 {
2870 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2871 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2872
2873 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2874 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2875
2876 hr = IDirect3DDevice9_EndScene(device);
2877 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
2878 }
2879 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2880 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2881
2882 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2883 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
2884
2885 color = getPixelColor(device, 240, 320);
2886 ok(color == 0x0000FFFF, "R32F with value 0.0 has color %08x, expected 0x0000FFFF\n", color);
2887
2888 out:
2889 if(texture) IDirect3DTexture9_Release(texture);
2890 IDirect3D9_Release(d3d);
2891 }
2892
2893 static void g16r16_texture_test(IDirect3DDevice9 *device)
2894 {
2895 IDirect3D9 *d3d = NULL;
2896 HRESULT hr;
2897 IDirect3DTexture9 *texture = NULL;
2898 D3DLOCKED_RECT lr;
2899 DWORD *data;
2900 DWORD color, red, green, blue;
2901 float quad[] = {
2902 -1.0, -1.0, 0.1, 0.0, 0.0,
2903 -1.0, 1.0, 0.1, 0.0, 1.0,
2904 1.0, -1.0, 0.1, 1.0, 0.0,
2905 1.0, 1.0, 0.1, 1.0, 1.0,
2906 };
2907
2908 memset(&lr, 0, sizeof(lr));
2909 IDirect3DDevice9_GetDirect3D(device, &d3d);
2910 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2911 D3DRTYPE_TEXTURE, D3DFMT_G16R16) != D3D_OK) {
2912 skip("D3DFMT_G16R16 textures not supported\n");
2913 goto out;
2914 }
2915
2916 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_G16R16,
2917 D3DPOOL_MANAGED, &texture, NULL);
2918 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2919 if(!texture) {
2920 skip("Failed to create D3DFMT_G16R16 texture\n");
2921 goto out;
2922 }
2923
2924 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2925 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
2926 data = lr.pBits;
2927 *data = 0x0f00f000;
2928 hr = IDirect3DTexture9_UnlockRect(texture, 0);
2929 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2930
2931 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2932 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2933
2934 hr = IDirect3DDevice9_BeginScene(device);
2935 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
2936 if(SUCCEEDED(hr))
2937 {
2938 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2939 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2940
2941 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2942 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2943
2944 hr = IDirect3DDevice9_EndScene(device);
2945 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
2946 }
2947 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2948 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2949
2950 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2951 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
2952
2953 color = getPixelColor(device, 240, 320);
2954 red = (color & 0x00ff0000) >> 16;
2955 green = (color & 0x0000ff00) >> 8;
2956 blue = (color & 0x000000ff) >> 0;
2957 ok(blue == 0xff && red >= 0xef && red <= 0xf1 && green >= 0x0e && green <= 0x10,
2958 "D3DFMT_G16R16 with value 0x00ffff00 has color %08x, expected 0x00F00FFF\n", color);
2959
2960 out:
2961 if(texture) IDirect3DTexture9_Release(texture);
2962 IDirect3D9_Release(d3d);
2963 }
2964
2965 static void texture_transform_flags_test(IDirect3DDevice9 *device)
2966 {
2967 HRESULT hr;
2968 IDirect3D9 *d3d;
2969 D3DFORMAT fmt = D3DFMT_X8R8G8B8;
2970 D3DCAPS9 caps;
2971 IDirect3DTexture9 *texture = NULL;
2972 IDirect3DVolumeTexture9 *volume = NULL;
2973 unsigned int x, y, z;
2974 D3DLOCKED_RECT lr;
2975 D3DLOCKED_BOX lb;
2976 DWORD color;
2977 IDirect3DVertexDeclaration9 *decl, *decl2, *decl3;
2978 float identity[16] = {1.0, 0.0, 0.0, 0.0,
2979 0.0, 1.0, 0.0, 0.0,
2980 0.0, 0.0, 1.0, 0.0,
2981 0.0, 0.0, 0.0, 1.0};
2982 static const D3DVERTEXELEMENT9 decl_elements[] = {
2983 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2984 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2985 D3DDECL_END()
2986 };
2987 static const D3DVERTEXELEMENT9 decl_elements2[] = {
2988 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2989 {0, 12, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2990 D3DDECL_END()
2991 };
2992 static const D3DVERTEXELEMENT9 decl_elements3[] = {
2993 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2994 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2995 D3DDECL_END()
2996 };
2997 static const unsigned char proj_texdata[] = {0x00, 0x00, 0x00, 0x00,
2998 0x00, 0xff, 0x00, 0x00,
2999 0x00, 0x00, 0x00, 0x00,
3000 0x00, 0x00, 0x00, 0x00};
3001
3002 memset(&lr, 0, sizeof(lr));
3003 memset(&lb, 0, sizeof(lb));
3004 IDirect3DDevice9_GetDirect3D(device, &d3d);
3005 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
3006 D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16) == D3D_OK) {
3007 fmt = D3DFMT_A16B16G16R16;
3008 }
3009 IDirect3D9_Release(d3d);
3010
3011 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
3012 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3013 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
3014 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3015 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements3, &decl3);
3016 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3017 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
3018 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_SRGBTEXTURE) returned %s\n", DXGetErrorString9(hr));
3019 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
3020 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MAGFILTER) returned %s\n", DXGetErrorString9(hr));
3021 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
3022 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MINFILTER) returned %s\n", DXGetErrorString9(hr));
3023 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
3024 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MIPFILTER) returned %s\n", DXGetErrorString9(hr));
3025 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
3026 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSU) returned %s\n", DXGetErrorString9(hr));
3027 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
3028 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSV) returned %s\n", DXGetErrorString9(hr));
3029 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
3030 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSW) returned %s\n", DXGetErrorString9(hr));
3031 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
3032 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState(D3DRS_LIGHTING) returned %s\n", DXGetErrorString9(hr));
3033 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3034 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3035
3036 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
3037 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %s\n", DXGetErrorString9(hr));
3038 hr = IDirect3DDevice9_CreateTexture(device, caps.MaxTextureWidth, caps.MaxTextureHeight, 1,
3039 0, fmt, D3DPOOL_MANAGED, &texture, NULL);
3040 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
3041 if(!texture) {
3042 skip("Failed to create the test texture\n");
3043 return;
3044 }
3045
3046 /* Unfortunately there is no easy way to set up a texture coordinate passthrough
3047 * in d3d fixed function pipeline, so create a texture that has a gradient from 0.0 to
3048 * 1.0 in red and green for the x and y coords
3049 */
3050 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3051 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %s\n", DXGetErrorString9(hr));
3052 for(y = 0; y < caps.MaxTextureHeight; y++) {
3053 for(x = 0; x < caps.MaxTextureWidth; x++) {
3054 double r_f = (double) y / (double) caps.MaxTextureHeight;
3055 double g_f = (double) x / (double) caps.MaxTextureWidth;
3056 if(fmt == D3DFMT_A16B16G16R16) {
3057 unsigned short r, g;
3058 unsigned short *dst = (unsigned short *) (((char *) lr.pBits) + y * lr.Pitch + x * 8);
3059 r = (unsigned short) (r_f * 65536.0);
3060 g = (unsigned short) (g_f * 65536.0);
3061 dst[0] = r;
3062 dst[1] = g;
3063 dst[2] = 0;
3064 dst[3] = 65535;
3065 } else {
3066 unsigned char *dst = ((unsigned char *) lr.pBits) + y * lr.Pitch + x * 4;
3067 unsigned char r = (unsigned char) (r_f * 255.0);
3068 unsigned char g = (unsigned char) (g_f * 255.0);
3069 dst[0] = 0;
3070 dst[1] = g;
3071 dst[2] = r;
3072 dst[3] = 255;
3073 }
3074 }
3075 }
3076 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3077 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %s\n", DXGetErrorString9(hr));
3078 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3079 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
3080
3081 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3082 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3083 hr = IDirect3DDevice9_BeginScene(device);
3084 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3085 if(SUCCEEDED(hr))
3086 {
3087 float quad1[] = {
3088 -1.0, -1.0, 0.1, 1.0, 1.0,
3089 -1.0, 0.0, 0.1, 1.0, 1.0,
3090 0.0, -1.0, 0.1, 1.0, 1.0,
3091 0.0, 0.0, 0.1, 1.0, 1.0,
3092 };
3093 float quad2[] = {
3094 -1.0, 0.0, 0.1, 1.0, 1.0,
3095 -1.0, 1.0, 0.1, 1.0, 1.0,
3096 0.0, 0.0, 0.1, 1.0, 1.0,
3097 0.0, 1.0, 0.1, 1.0, 1.0,
3098 };
3099 float quad3[] = {
3100 0.0, 0.0, 0.1, 0.5, 0.5,
3101 0.0, 1.0, 0.1, 0.5, 0.5,
3102 1.0, 0.0, 0.1, 0.5, 0.5,
3103 1.0, 1.0, 0.1, 0.5, 0.5,
3104 };
3105 float quad4[] = {
3106 320, 480, 0.1, 1.0, 0.0, 1.0,
3107 320, 240, 0.1, 1.0, 0.0, 1.0,
3108 640, 480, 0.1, 1.0, 0.0, 1.0,
3109 640, 240, 0.1, 1.0, 0.0, 1.0,
3110 };
3111 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3112 0.0, 0.0, 0.0, 0.0,
3113 0.0, 0.0, 0.0, 0.0,
3114 0.0, 0.0, 0.0, 0.0};
3115
3116 /* What happens with the texture matrix if D3DTSS_TEXTURETRANSFORMFLAGS is disabled? */
3117 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3118 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3119 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3120 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3121
3122 /* What happens with transforms enabled? */
3123 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3124 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3125 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3126 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3127
3128 /* What happens if 4 coords are used, but only 2 given ?*/
3129 mat[8] = 1.0;
3130 mat[13] = 1.0;
3131 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3132 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3133 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3134 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3135 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3136 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3137
3138 /* What happens with transformed geometry? This setup lead to 0/0 coords with untransformed
3139 * geometry. If the same applies to transformed vertices, the quad will be black, otherwise red,
3140 * due to the coords in the vertices. (turns out red, indeed)
3141 */
3142 memset(mat, 0, sizeof(mat));
3143 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3144 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3145 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_TEX1);
3146 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3147 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3148 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3149 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3150 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3151
3152 hr = IDirect3DDevice9_EndScene(device);
3153 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3154 }
3155 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3156 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3157 color = getPixelColor(device, 160, 360);
3158 ok(color == 0x00FFFF00 || color == 0x00FEFE00, "quad 1 has color %08x, expected 0x00FFFF00\n", color);
3159 color = getPixelColor(device, 160, 120);
3160 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3161 color = getPixelColor(device, 480, 120);
3162 ok(color == 0x0000FF00 || color == 0x0000FE00, "quad 3 has color %08x, expected 0x0000FF00\n", color);
3163 color = getPixelColor(device, 480, 360);
3164 ok(color == 0x00FF0000 || 0x00FE0000, "quad 4 has color %08x, expected 0x00FF0000\n", color);
3165
3166 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3167 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3168
3169 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3170 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3171 hr = IDirect3DDevice9_BeginScene(device);
3172 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3173 if(SUCCEEDED(hr))
3174 {
3175 float quad1[] = {
3176 -1.0, -1.0, 0.1, 0.8, 0.2,
3177 -1.0, 0.0, 0.1, 0.8, 0.2,
3178 0.0, -1.0, 0.1, 0.8, 0.2,
3179 0.0, 0.0, 0.1, 0.8, 0.2,
3180 };
3181 float quad2[] = {
3182 -1.0, 0.0, 0.1, 0.5, 1.0,
3183 -1.0, 1.0, 0.1, 0.5, 1.0,
3184 0.0, 0.0, 0.1, 0.5, 1.0,
3185 0.0, 1.0, 0.1, 0.5, 1.0,
3186 };
3187 float quad3[] = {
3188 0.0, 0.0, 0.1, 0.5, 1.0,
3189 0.0, 1.0, 0.1, 0.5, 1.0,
3190 1.0, 0.0, 0.1, 0.5, 1.0,
3191 1.0, 1.0, 0.1, 0.5, 1.0,
3192 };
3193 float quad4[] = {
3194 0.0, -1.0, 0.1, 0.8, 0.2,
3195 0.0, 0.0, 0.1, 0.8, 0.2,
3196 1.0, -1.0, 0.1, 0.8, 0.2,
3197 1.0, 0.0, 0.1, 0.8, 0.2,
3198 };
3199 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3200 0.0, 0.0, 0.0, 0.0,
3201 0.0, 1.0, 0.0, 0.0,
3202 0.0, 0.0, 0.0, 0.0};
3203
3204 /* What happens to the default 1 in the 3rd coordinate if it is disabled?
3205 */
3206 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3207 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3208 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3209 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3210
3211 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3212 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3213
3214 /* D3DTFF_COUNT1 does not work on Nvidia drivers. It behaves like D3DTTFF_DISABLE. On ATI drivers
3215 * it behaves like COUNT2 because normal textures require 2 coords
3216 */
3217 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3218 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3219 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 5 * sizeof(float));
3220 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3221
3222 /* Just to be sure, the same as quad2 above */
3223 memset(mat, 0, sizeof(mat));
3224 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3225 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3226 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3227 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3228 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3229 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3230
3231 /* Now, what happens to the 2nd coordinate(that is disabled in the matrix) if it is not
3232 * used? And what happens to the first?
3233 */
3234 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3235 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3236 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3237 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3238
3239 hr = IDirect3DDevice9_EndScene(device);
3240 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3241 }
3242 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3243 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3244 color = getPixelColor(device, 160, 360);
3245 ok(color == 0x00FF0000 || color == 0x00FE0000, "quad 1 has color %08x, expected 0x00FF0000\n", color);
3246 color = getPixelColor(device, 160, 120);
3247 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3248 color = getPixelColor(device, 480, 120);
3249 ok(color == 0x00ff8000 || color == 0x00fe7f00 || color == 0x00000000,
3250 "quad 3 has color %08x, expected 0x00ff8000\n", color);
3251 color = getPixelColor(device, 480, 360);
3252 ok(color == 0x0033cc00 || color == 0x0032cb00 || color == 0x00FF0000 || color == 0x00FE0000,
3253 "quad 4 has color %08x, expected 0x0033cc00\n", color);
3254
3255 IDirect3DTexture9_Release(texture);
3256
3257 /* Test projected textures, without any fancy matrices */
3258 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3259 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3260 hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 1, 0, D3DFMT_L8, D3DPOOL_MANAGED, &texture, NULL);
3261 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
3262 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3263 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3264 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl3);
3265 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3266
3267 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3268 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
3269 for(x = 0; x < 4; x++) {
3270 memcpy(((BYTE *) lr.pBits) + lr.Pitch * x, proj_texdata + 4 * x, 4 * sizeof(proj_texdata[0]));
3271 }
3272 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3273 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
3274 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3275 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
3276
3277 hr = IDirect3DDevice9_BeginScene(device);
3278 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3279 if(SUCCEEDED(hr))
3280 {
3281 const float proj_quads[] = {
3282 -1.0, -1.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3283 1.0, -1.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3284 -1.0, 0.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3285 1.0, 0.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3286 -1.0, 0.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3287 1.0, 0.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3288 -1.0, 1.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3289 1.0, 1.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3290 };
3291
3292 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);
3293 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3294 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[0*7], 7 * sizeof(float));
3295 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3296
3297 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED);
3298 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3299 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[4*7], 7 * sizeof(float));
3300 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3301
3302 hr = IDirect3DDevice9_EndScene(device);
3303 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3304 }
3305
3306 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3307 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
3308 IDirect3DTexture9_Release(texture);
3309
3310 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3311 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3312 color = getPixelColor(device, 158, 118);
3313 ok(color == 0x00000000, "proj: Pixel 158/118 has color 0x%08x, expected 0x00000000\n", color);
3314 color = getPixelColor(device, 162, 118);
3315 ok(color == 0x00000000, "proj: Pixel 162/118 has color 0x%08x, expected 0x00000000\n", color);
3316 color = getPixelColor(device, 158, 122);
3317 ok(color == 0x00000000, "proj: Pixel 158/122 has color 0x%08x, expected 0x00000000\n", color);
3318 color = getPixelColor(device, 162, 122);
3319 ok(color == 0x00FFFFFF, "proj: Pixel 162/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3320
3321 color = getPixelColor(device, 158, 178);
3322 ok(color == 0x00000000, "proj: Pixel 158/178 has color 0x%08x, expected 0x00000000\n", color);
3323 color = getPixelColor(device, 162, 178);
3324 ok(color == 0x00FFFFFF, "proj: Pixel 158/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3325 color = getPixelColor(device, 158, 182);
3326 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3327 color = getPixelColor(device, 162, 182);
3328 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3329
3330 color = getPixelColor(device, 318, 118);
3331 ok(color == 0x00000000, "proj: Pixel 318/118 has color 0x%08x, expected 0x00000000\n", color);
3332 color = getPixelColor(device, 322, 118);
3333 ok(color == 0x00000000, "proj: Pixel 322/118 has color 0x%08x, expected 0x00000000\n", color);
3334 color = getPixelColor(device, 318, 122);
3335 ok(color == 0x00FFFFFF, "proj: Pixel 318/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3336 color = getPixelColor(device, 322, 122);
3337 ok(color == 0x00000000, "proj: Pixel 322/122 has color 0x%08x, expected 0x00000000\n", color);
3338
3339 color = getPixelColor(device, 318, 178);
3340 ok(color == 0x00FFFFFF, "proj: Pixel 318/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3341 color = getPixelColor(device, 322, 178);
3342 ok(color == 0x00000000, "proj: Pixel 322/178 has color 0x%08x, expected 0x00000000\n", color);
3343 color = getPixelColor(device, 318, 182);
3344 ok(color == 0x00000000, "proj: Pixel 318/182 has color 0x%08x, expected 0x00000000\n", color);
3345 color = getPixelColor(device, 322, 182);
3346 ok(color == 0x00000000, "proj: Pixel 322/182 has color 0x%08x, expected 0x00000000\n", color);
3347
3348 color = getPixelColor(device, 238, 298);
3349 ok(color == 0x00000000, "proj: Pixel 238/298 has color 0x%08x, expected 0x00000000\n", color);
3350 color = getPixelColor(device, 242, 298);
3351 ok(color == 0x00000000, "proj: Pixel 242/298 has color 0x%08x, expected 0x00000000\n", color);
3352 color = getPixelColor(device, 238, 302);
3353 ok(color == 0x00000000, "proj: Pixel 238/302 has color 0x%08x, expected 0x00000000\n", color);
3354 color = getPixelColor(device, 242, 302);
3355 ok(color == 0x00FFFFFF, "proj: Pixel 242/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3356
3357 color = getPixelColor(device, 238, 388);
3358 ok(color == 0x00000000, "proj: Pixel 238/388 has color 0x%08x, expected 0x00000000\n", color);
3359 color = getPixelColor(device, 242, 388);
3360 ok(color == 0x00FFFFFF, "proj: Pixel 242/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3361 color = getPixelColor(device, 238, 392);
3362 ok(color == 0x00000000, "proj: Pixel 238/392 has color 0x%08x, expected 0x00000000\n", color);
3363 color = getPixelColor(device, 242, 392);
3364 ok(color == 0x00000000, "proj: Pixel 242/392 has color 0x%08x, expected 0x00000000\n", color);
3365
3366 color = getPixelColor(device, 478, 298);
3367 ok(color == 0x00000000, "proj: Pixel 478/298 has color 0x%08x, expected 0x00000000\n", color);
3368 color = getPixelColor(device, 482, 298);
3369 ok(color == 0x00000000, "proj: Pixel 482/298 has color 0x%08x, expected 0x00000000\n", color);
3370 color = getPixelColor(device, 478, 302);
3371 ok(color == 0x00FFFFFF, "proj: Pixel 478/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3372 color = getPixelColor(device, 482, 302);
3373 ok(color == 0x00000000, "proj: Pixel 482/302 has color 0x%08x, expected 0x00000000\n", color);
3374
3375 color = getPixelColor(device, 478, 388);
3376 ok(color == 0x00FFFFFF, "proj: Pixel 478/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3377 color = getPixelColor(device, 482, 388);
3378 ok(color == 0x00000000, "proj: Pixel 482/388 has color 0x%08x, expected 0x00000000\n", color);
3379 color = getPixelColor(device, 478, 392);
3380 ok(color == 0x00000000, "proj: Pixel 478/392 has color 0x%08x, expected 0x00000000\n", color);
3381 color = getPixelColor(device, 482, 392);
3382 ok(color == 0x00000000, "proj: Pixel 482/392 has color 0x%08x, expected 0x00000000\n", color);
3383
3384 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3385 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3386 /* Use a smaller volume texture than the biggest possible size for memory and performance reasons
3387 * Thus watch out if sampling from texels between 0 and 1.
3388 */
3389 hr = IDirect3DDevice9_CreateVolumeTexture(device, 32, 32, 32, 1, 0, fmt, D3DPOOL_MANAGED, &volume, 0);
3390 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
3391 "IDirect3DDevice9_CreateVolumeTexture failed with %s\n", DXGetErrorString9(hr));
3392 if(!volume) {
3393 skip("Failed to create a volume texture\n");
3394 goto out;
3395 }
3396
3397 hr = IDirect3DVolumeTexture9_LockBox(volume, 0, &lb, NULL, 0);
3398 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_LockBox failed with %s\n", DXGetErrorString9(hr));
3399 for(z = 0; z < 32; z++) {
3400 for(y = 0; y < 32; y++) {
3401 for(x = 0; x < 32; x++) {
3402 char size = (fmt == D3DFMT_A16B16G16R16 ? 8 : 4);
3403 void *mem = ((char *) lb.pBits) + y * lb.RowPitch + z * lb.SlicePitch + x * size;
3404 float r_f = (float) x / 31.0;
3405 float g_f = (float) y / 31.0;
3406 float b_f = (float) z / 31.0;
3407
3408 if(fmt == D3DFMT_A16B16G16R16) {
3409 unsigned short *mem_s = mem;
3410 mem_s[0] = r_f * 65535.0;
3411 mem_s[1] = g_f * 65535.0;
3412 mem_s[2] = b_f * 65535.0;
3413 mem_s[3] = 65535;
3414 } else {
3415 unsigned char *mem_c = mem;
3416 mem_c[0] = b_f * 255.0;
3417 mem_c[1] = g_f * 255.0;
3418 mem_c[2] = r_f * 255.0;
3419 mem_c[3] = 255;
3420 }
3421 }
3422 }
3423 }
3424 hr = IDirect3DVolumeTexture9_UnlockBox(volume, 0);
3425 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %s\n", DXGetErrorString9(hr));
3426
3427 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) volume);
3428 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %s\n", DXGetErrorString9(hr));
3429
3430 hr = IDirect3DDevice9_BeginScene(device);
3431 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3432 if(SUCCEEDED(hr))
3433 {
3434 float quad1[] = {
3435 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3436 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3437 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3438 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3439 };
3440 float quad2[] = {
3441 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3442 -1.0, 1.0, 0.1, 1.0, 1.0, 1.0,
3443 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3444 0.0, 1.0, 0.1, 1.0, 1.0, 1.0
3445 };
3446 float quad3[] = {
3447 0.0, 0.0, 0.1, 0.0, 0.0,
3448 0.0, 1.0, 0.1, 0.0, 0.0,
3449 1.0, 0.0, 0.1, 0.0, 0.0,
3450 1.0, 1.0, 0.1, 0.0, 0.0
3451 };
3452 float quad4[] = {
3453 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3454 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3455 1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3456 1.0, 0.0, 0.1, 1.0, 1.0, 1.0
3457 };
3458 float mat[16] = {1.0, 0.0, 0.0, 0.0,
3459 0.0, 0.0, 1.0, 0.0,
3460 0.0, 1.0, 0.0, 0.0,
3461 0.0, 0.0, 0.0, 1.0};
3462 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3463 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3464
3465 /* Draw a quad with all 3 coords enabled. Nothing fancy. v and w are swapped, but have the same
3466 * values
3467 */
3468 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3469 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3470 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3);
3471 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3472 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3473 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3474
3475 /* Now disable the w coordinate. Does that change the input, or the output. The coordinates
3476 * are swapped by the matrix. If it changes the input, the v coord will be missing(green),
3477 * otherwise the w will be missing(blue).
3478 * turns out that on nvidia cards the blue color is missing, so it is an output modification.
3479 * On ATI cards the COUNT2 is ignored, and it behaves in the same way as COUNT3.
3480 */
3481 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3482 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3483 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
3484 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3485
3486 /* default values? Set up the identity matrix, pass in 2 vertex coords, and enable 4 */
3487 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3488 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3489 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3490 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3491 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3492 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3493 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3494 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3495
3496 /* D3DTTFF_COUNT1. Set a NULL matrix, and count1, pass in all values as 1.0. Nvidia has count1 ==
3497 * disable. ATI extends it up to the amount of values needed for the volume texture
3498 */
3499 memset(mat, 0, sizeof(mat));
3500 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3501 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3502 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3503 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3504 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3505 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3506 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3507 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3508
3509 hr = IDirect3DDevice9_EndScene(device);
3510 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3511 }
3512 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3513 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3514
3515 color = getPixelColor(device, 160, 360);
3516 ok(color == 0x00ffffff, "quad 1 has color %08x, expected 0x00ffffff\n", color);
3517 color = getPixelColor(device, 160, 120);
3518 ok(color == 0x00ffff00 /* NV*/ || color == 0x00ffffff /* ATI */,
3519 "quad 2 has color %08x, expected 0x00ffff00\n", color);
3520 color = getPixelColor(device, 480, 120);
3521 ok(color == 0x000000ff, "quad 3 has color %08x, expected 0x000000ff\n", color);
3522 color = getPixelColor(device, 480, 360);
3523 ok(color == 0x00ffffff || color == 0x0000ff00, "quad 4 has color %08x, expected 0x00ffffff\n", color);
3524
3525 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff303030, 0.0, 0);
3526 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3527 hr = IDirect3DDevice9_BeginScene(device);
3528 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3529 if(SUCCEEDED(hr))
3530 {
3531 float quad1[] = {
3532 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3533 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3534 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3535 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3536 };
3537 float quad2[] = {
3538 -1.0, 0.0, 0.1,
3539 -1.0, 1.0, 0.1,
3540 0.0, 0.0, 0.1,
3541 0.0, 1.0, 0.1,
3542 };
3543 float quad3[] = {
3544 0.0, 0.0, 0.1, 1.0,
3545 0.0, 1.0, 0.1, 1.0,
3546 1.0, 0.0, 0.1, 1.0,
3547 1.0, 1.0, 0.1, 1.0
3548 };
3549 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3550 0.0, 0.0, 0.0, 0.0,
3551 0.0, 0.0, 0.0, 0.0,
3552 0.0, 1.0, 0.0, 0.0};
3553 float mat2[16] = {0.0, 0.0, 0.0, 1.0,
3554 1.0, 0.0, 0.0, 0.0,
3555 0.0, 1.0, 0.0, 0.0,
3556 0.0, 0.0, 1.0, 0.0};
3557 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3558 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3559
3560 /* Default values? 4 coords used, 3 passed. What happens to the 4th?
3561 */
3562 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3563 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3564 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3565 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3566 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3567 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3568
3569 /* None passed */
3570 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3571 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3572 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3573 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3574 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
3575 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3576
3577 /* 4 used, 1 passed */
3578 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
3579 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3580 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat2);
3581 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3582 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 4 * sizeof(float));
3583 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3584
3585 hr = IDirect3DDevice9_EndScene(device);
3586 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3587 }
3588 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3589 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3590 color = getPixelColor(device, 160, 360);
3591 ok(color == 0x0000ff00, "quad 1 has color %08x, expected 0x0000ff00\n", color);
3592 color = getPixelColor(device, 160, 120);
3593 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x00000000\n", color);
3594 color = getPixelColor(device, 480, 120);
3595 ok(color == 0x00ff0000, "quad 3 has color %08x, expected 0x00ff0000\n", color);
3596 /* Quad4: unused */
3597
3598 IDirect3DVolumeTexture9_Release(volume);
3599
3600 out:
3601 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
3602 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3603 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
3604 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3605 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3606 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3607 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3608 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
3609 IDirect3DVertexDeclaration9_Release(decl);
3610 IDirect3DVertexDeclaration9_Release(decl2);
3611 IDirect3DVertexDeclaration9_Release(decl3);
3612 }
3613
3614 static void texdepth_test(IDirect3DDevice9 *device)
3615 {
3616 IDirect3DPixelShader9 *shader;
3617 HRESULT hr;
3618 const float texdepth_test_data1[] = { 0.25, 2.0, 0.0, 0.0};
3619 const float texdepth_test_data2[] = { 0.25, 0.5, 0.0, 0.0};
3620 const float texdepth_test_data3[] = {-1.00, 0.1, 0.0, 0.0};
3621 const float texdepth_test_data4[] = {-0.25, -0.5, 0.0, 0.0};
3622 const float texdepth_test_data5[] = { 1.00, -0.1, 0.0, 0.0};
3623 const float texdepth_test_data6[] = { 1.00, 0.5, 0.0, 0.0};
3624 const float texdepth_test_data7[] = { 0.50, 0.0, 0.0, 0.0};
3625 DWORD shader_code[] = {
3626 0xffff0104, /* ps_1_4 */
3627 0x00000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c1, 0, 0, 1, 1 */
3628 0x00000001, 0x800f0005, 0xa0e40000, /* mov r5, c0 */
3629 0x0000fffd, /* phase */
3630 0x00000057, 0x800f0005, /* texdepth r5 */
3631 0x00000001, 0x800f0000, 0xa0e40001, /* mov r0, c1 */
3632 0x0000ffff /* end */
3633 };
3634 DWORD color;
3635 float vertex[] = {
3636 -1.0, -1.0, 0.0,
3637 1.0, -1.0, 1.0,
3638 -1.0, 1.0, 0.0,
3639 1.0, 1.0, 1.0
3640 };
3641
3642 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
3643 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3644
3645 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffff00, 0.0, 0);
3646 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3647 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
3648 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3649 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3650 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3651 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_ALWAYS);
3652 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3653 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3654
3655 /* Fill the depth buffer with a gradient */
3656 hr = IDirect3DDevice9_BeginScene(device);
3657 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3658 if(SUCCEEDED(hr))
3659 {
3660 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3661 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3662 hr = IDirect3DDevice9_EndScene(device);
3663 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3664 }
3665
3666 /* Now perform the actual tests. Same geometry, but with the shader */
3667 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
3668 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3669 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
3670 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3671 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3672 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3673
3674 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data1, 1);
3675 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3676 hr = IDirect3DDevice9_BeginScene(device);
3677 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3678 if(SUCCEEDED(hr))
3679 {
3680 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3681 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3682
3683 hr = IDirect3DDevice9_EndScene(device);
3684 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3685 }
3686
3687 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3688 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3689 color = getPixelColor(device, 158, 240);
3690 ok(color == 0x000000ff, "Pixel 158(25%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3691 color = getPixelColor(device, 162, 240);
3692 ok(color == 0x00ffffff, "Pixel 158(25%% + 2 pixel) has color %08x, expected 0x00ffffff\n", color);
3693
3694 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3695
3696 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data2, 1);
3697 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3698 hr = IDirect3DDevice9_BeginScene(device);
3699 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3700 if(SUCCEEDED(hr))
3701 {
3702 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3703 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3704
3705 hr = IDirect3DDevice9_EndScene(device);
3706 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3707 }
3708
3709 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3710 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3711 color = getPixelColor(device, 318, 240);
3712 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3713 color = getPixelColor(device, 322, 240);
3714 ok(color == 0x00ffff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3715
3716 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3717
3718 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data3, 1);
3719 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3720 hr = IDirect3DDevice9_BeginScene(device);
3721 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3722 if(SUCCEEDED(hr))
3723 {
3724 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3725 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3726
3727 hr = IDirect3DDevice9_EndScene(device);
3728 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3729 }
3730 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3731 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3732
3733 color = getPixelColor(device, 1, 240);
3734 ok(color == 0x00ff0000, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ff0000\n", color);
3735
3736 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3737
3738 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data4, 1);
3739 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3740 hr = IDirect3DDevice9_BeginScene(device);
3741 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3742 if(SUCCEEDED(hr))
3743 {
3744 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3745 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3746
3747 hr = IDirect3DDevice9_EndScene(device);
3748 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3749 }
3750 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3751 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3752 color = getPixelColor(device, 318, 240);
3753 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3754 color = getPixelColor(device, 322, 240);
3755 ok(color == 0x0000ff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x0000ff00\n", color);
3756
3757 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3758
3759 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data5, 1);
3760 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3761 hr = IDirect3DDevice9_BeginScene(device);
3762 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3763 if(SUCCEEDED(hr))
3764 {
3765 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3766 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3767
3768 hr = IDirect3DDevice9_EndScene(device);
3769 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3770 }
3771 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3772 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3773
3774 color = getPixelColor(device, 1, 240);
3775 ok(color == 0x00ffff00, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3776
3777 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3778
3779 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data6, 1);
3780 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3781 hr = IDirect3DDevice9_BeginScene(device);
3782 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3783 if(SUCCEEDED(hr))
3784 {
3785 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3786 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3787
3788 hr = IDirect3DDevice9_EndScene(device);
3789 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3790 }
3791 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3792 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3793
3794 color = getPixelColor(device, 638, 240);
3795 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3796
3797 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3798
3799 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data7, 1);
3800 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3801 hr = IDirect3DDevice9_BeginScene(device);
3802 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3803 if(SUCCEEDED(hr))
3804 {
3805 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3806 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3807
3808 hr = IDirect3DDevice9_EndScene(device);
3809 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3810 }
3811 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3812 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3813
3814 color = getPixelColor(device, 638, 240);
3815 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3816
3817 /* Cleanup */
3818 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3819 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3820 IDirect3DPixelShader9_Release(shader);
3821
3822 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
3823 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3824 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3825 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3826 }
3827
3828 static void texkill_test(IDirect3DDevice9 *device)
3829 {
3830 IDirect3DPixelShader9 *shader;
3831 HRESULT hr;
3832 DWORD color;
3833
3834 const float vertex[] = {
3835 /* bottom top right left */
3836 -1.0, -1.0, 1.0, -0.1, 0.9, 0.9, -0.1,
3837 1.0, -1.0, 0.0, 0.9, -0.1, 0.9, -0.1,
3838 -1.0, 1.0, 1.0, -0.1, 0.9, -0.1, 0.9,
3839 1.0, 1.0, 0.0, 0.9, -0.1, -0.1, 0.9,
3840 };
3841
3842 DWORD shader_code_11[] = {
3843 0xffff0101, /* ps_1_1 */
3844 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
3845 0x00000041, 0xb00f0000, /* texkill t0 */
3846 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
3847 0x0000ffff /* end */
3848 };
3849 DWORD shader_code_20[] = {
3850 0xffff0200, /* ps_2_0 */
3851 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
3852 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c0, 0.0, 0.0, 1.0, 1.0 */
3853 0x01000041, 0xb00f0000, /* texkill t0 */
3854 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
3855 0x0000ffff /* end */
3856 };
3857
3858 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3859 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3860 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader);
3861 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3862
3863 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3864 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3865 hr = IDirect3DDevice9_BeginScene(device);
3866 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3867 if(SUCCEEDED(hr))
3868 {
3869 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE4(0) | D3DFVF_TEX1);
3870 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
3871 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3872 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3873 hr = IDirect3DDevice9_EndScene(device);
3874 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3875 }
3876 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3877 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3878 color = getPixelColor(device, 63, 46);
3879 ok(color == 0x0000ff00, "Pixel 63/46 has color %08x, expected 0x0000ff00\n", color);
3880 color = getPixelColor(device, 66, 46);
3881 ok(color == 0x0000ff00, "Pixel 66/64 has color %08x, expected 0x0000ff00\n", color);
3882 color = getPixelColor(device, 63, 49);
3883 ok(color == 0x0000ff00, "Pixel 63/49 has color %08x, expected 0x0000ff00\n", color);
3884 color = getPixelColor(device, 66, 49);
3885 ok(color == 0x00ff0000, "Pixel 66/49 has color %08x, expected 0x00ff0000\n", color);
3886
3887 color = getPixelColor(device, 578, 46);
3888 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3889 color = getPixelColor(device, 575, 46);
3890 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3891 color = getPixelColor(device, 578, 49);
3892 ok(color == 0x0000ff00, "Pixel 578/49 has color %08x, expected 0x0000ff00\n", color);
3893 color = getPixelColor(device, 575, 49);
3894 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3895
3896 color = getPixelColor(device, 63, 430);
3897 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3898 color = getPixelColor(device, 63, 433);
3899 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3900 color = getPixelColor(device, 66, 433);
3901 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3902 color = getPixelColor(device, 66, 430);
3903 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3904
3905 color = getPixelColor(device, 578, 430);
3906 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3907 color = getPixelColor(device, 578, 433);
3908 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3909 color = getPixelColor(device, 575, 433);
3910 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3911 color = getPixelColor(device, 575, 430);
3912 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3913
3914 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3915 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3916 IDirect3DPixelShader9_Release(shader);
3917
3918 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3919 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3920 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader);
3921 if(FAILED(hr)) {
3922 skip("Failed to create 2.0 test shader, most likely not supported\n");
3923 return;
3924 }
3925
3926 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3927 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3928 hr = IDirect3DDevice9_BeginScene(device);
3929 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3930 if(SUCCEEDED(hr))
3931 {
3932 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3933 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3934 hr = IDirect3DDevice9_EndScene(device);
3935 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3936 }
3937 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3938
3939 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3940 color = getPixelColor(device, 63, 46);
3941 ok(color == 0x00ffff00, "Pixel 63/46 has color %08x, expected 0x00ffff00\n", color);
3942 color = getPixelColor(device, 66, 46);
3943 ok(color == 0x00ffff00, "Pixel 66/64 has color %08x, expected 0x00ffff00\n", color);
3944 color = getPixelColor(device, 63, 49);
3945 ok(color == 0x00ffff00, "Pixel 63/49 has color %08x, expected 0x00ffff00\n", color);
3946 color = getPixelColor(device, 66, 49);
3947 ok(color == 0x000000ff, "Pixel 66/49 has color %08x, expected 0x000000ff\n", color);
3948
3949 color = getPixelColor(device, 578, 46);
3950 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3951 color = getPixelColor(device, 575, 46);
3952 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3953 color = getPixelColor(device, 578, 49);
3954 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3955 color = getPixelColor(device, 575, 49);
3956 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3957
3958 color = getPixelColor(device, 63, 430);
3959 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3960 color = getPixelColor(device, 63, 433);
3961 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3962 color = getPixelColor(device, 66, 433);
3963 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3964 color = getPixelColor(device, 66, 430);
3965 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3966
3967 color = getPixelColor(device, 578, 430);
3968 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3969 color = getPixelColor(device, 578, 433);
3970 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3971 color = getPixelColor(device, 575, 433);
3972 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3973 color = getPixelColor(device, 575, 430);
3974 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3975
3976 /* Cleanup */
3977 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3978 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
3979 IDirect3DPixelShader9_Release(shader);
3980 }
3981
3982 static void x8l8v8u8_test(IDirect3DDevice9 *device)
3983 {
3984 IDirect3D9 *d3d9;
3985 HRESULT hr;
3986 IDirect3DTexture9 *texture;
3987 IDirect3DPixelShader9 *shader;
3988 IDirect3DPixelShader9 *shader2;
3989 D3DLOCKED_RECT lr;
3990 DWORD color;
3991 DWORD shader_code[] = {
3992 0xffff0101, /* ps_1_1 */
3993 0x00000042, 0xb00f0000, /* tex t0 */
3994 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
3995 0x0000ffff /* end */
3996 };
3997 DWORD shader_code2[] = {
3998 0xffff0101, /* ps_1_1 */
3999 0x00000042, 0xb00f0000, /* tex t0 */
4000 0x00000001, 0x800f0000, 0xb0ff0000, /* mov r0, t0.w */
4001 0x0000ffff /* end */
4002 };
4003
4004 float quad[] = {
4005 -1.0, -1.0, 0.1, 0.5, 0.5,
4006 1.0, -1.0, 0.1, 0.5, 0.5,
4007 -1.0, 1.0, 0.1, 0.5, 0.5,
4008 1.0, 1.0, 0.1, 0.5, 0.5,
4009 };
4010
4011 memset(&lr, 0, sizeof(lr));
4012 IDirect3DDevice9_GetDirect3D(device, &d3d9);
4013 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4014 0, D3DRTYPE_TEXTURE, D3DFMT_X8L8V8U8);
4015 IDirect3D9_Release(d3d9);
4016 if(FAILED(hr)) {
4017 skip("No D3DFMT_X8L8V8U8 support\n");
4018 };
4019
4020 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
4021 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4022
4023 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8L8V8U8, D3DPOOL_MANAGED, &texture, NULL);
4024 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed (%08x)\n", hr);
4025 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
4026 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed (%08x)\n", hr);
4027 *((DWORD *) lr.pBits) = 0x11ca3141;
4028 hr = IDirect3DTexture9_UnlockRect(texture, 0);
4029 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed (%08x)\n", hr);
4030
4031 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4032 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4033 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code2, &shader2);
4034 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4035
4036 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4037 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
4038 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4039 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4040 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4041 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4042
4043 hr = IDirect3DDevice9_BeginScene(device);
4044 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4045 if(SUCCEEDED(hr))
4046 {
4047 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4048 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4049
4050 hr = IDirect3DDevice9_EndScene(device);
4051 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4052 }
4053 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4054 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4055 color = getPixelColor(device, 578, 430);
4056 ok(color == 0x008262ca || color == 0x008363ca || color == 0x008362ca,
4057 "D3DFMT_X8L8V8U8 = 0x112131ca returns color %08x, expected 0x008262ca\n", color);
4058
4059 hr = IDirect3DDevice9_SetPixelShader(device, shader2);
4060 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4061 hr = IDirect3DDevice9_BeginScene(device);
4062 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4063 if(SUCCEEDED(hr))
4064 {
4065 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4066 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4067
4068 hr = IDirect3DDevice9_EndScene(device);
4069 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4070 }
4071 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4072 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4073 color = getPixelColor(device, 578, 430);
4074 ok(color == 0x00ffffff, "w component of D3DFMT_X8L8V8U8 = 0x11ca3141 returns color %08x\n", color);
4075
4076 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4077 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4078 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4079 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4080 IDirect3DPixelShader9_Release(shader);
4081 IDirect3DPixelShader9_Release(shader2);
4082 IDirect3DTexture9_Release(texture);
4083 }
4084
4085 static void autogen_mipmap_test(IDirect3DDevice9 *device)
4086 {
4087 HRESULT hr;
4088 IDirect3D9 *d3d;
4089 IDirect3DTexture9 *texture = NULL;
4090 IDirect3DSurface9 *surface;
4091 DWORD color;
4092 const RECT r1 = {256, 256, 512, 512};
4093 const RECT r2 = {512, 256, 768, 512};
4094 const RECT r3 = {256, 512, 512, 768};
4095 const RECT r4 = {512, 512, 768, 768};
4096 unsigned int x, y;
4097 D3DLOCKED_RECT lr;
4098 memset(&lr, 0, sizeof(lr));
4099
4100 IDirect3DDevice9_GetDirect3D(device, &d3d);
4101 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4102 D3DUSAGE_AUTOGENMIPMAP, D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8) != D3D_OK) {
4103 skip("No autogenmipmap support\n");
4104 IDirect3D9_Release(d3d);
4105 return;
4106 }
4107 IDirect3D9_Release(d3d);
4108
4109 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
4110 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4111
4112 /* Make the mipmap big, so that a smaller mipmap is used
4113 */
4114 hr = IDirect3DDevice9_CreateTexture(device, 1024, 1024, 0, D3DUSAGE_AUTOGENMIPMAP,
4115 D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0);
4116 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
4117
4118 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
4119 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel returned %s\n", DXGetErrorString9(hr));
4120 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
4121 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %s\n", DXGetErrorString9(hr));
4122 for(y = 0; y < 1024; y++) {
4123 for(x = 0; x < 1024; x++) {
4124 DWORD *dst = (DWORD *) (((BYTE *) lr.pBits) + y * lr.Pitch + x * 4);
4125 POINT pt;
4126
4127 pt.x = x;
4128 pt.y = y;
4129 if(PtInRect(&r1, pt)) {
4130 *dst = 0xffff0000;
4131 } else if(PtInRect(&r2, pt)) {
4132 *dst = 0xff00ff00;
4133 } else if(PtInRect(&r3, pt)) {
4134 *dst = 0xff0000ff;
4135 } else if(PtInRect(&r4, pt)) {
4136 *dst = 0xff000000;
4137 } else {
4138 *dst = 0xffffffff;
4139 }
4140 }
4141 }
4142 hr = IDirect3DSurface9_UnlockRect(surface);
4143 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned %s\n", DXGetErrorString9(hr));
4144 IDirect3DSurface9_Release(surface);
4145
4146 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4147 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
4148 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
4149 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
4150
4151 hr = IDirect3DDevice9_BeginScene(device);
4152 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4153 if(SUCCEEDED(hr)) {
4154 const float quad[] = {
4155 -0.5, -0.5, 0.1, 0.0, 0.0,
4156 -0.5, 0.5, 0.1, 0.0, 1.0,
4157 0.5, -0.5, 0.1, 1.0, 0.0,
4158 0.5, 0.5, 0.1, 1.0, 1.0
4159 };
4160
4161 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4162 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4163 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4164 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4165 hr = IDirect3DDevice9_EndScene(device);
4166 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4167 }
4168 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4169 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
4170 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
4171 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
4172 IDirect3DTexture9_Release(texture);
4173
4174 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4175 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4176 color = getPixelColor(device, 200, 200);
4177 ok(color == 0x00ffffff, "pixel 200/200 has color %08x, expected 0x00ffffff\n", color);
4178 color = getPixelColor(device, 280, 200);
4179 ok(color == 0x000000ff, "pixel 280/200 has color %08x, expected 0x000000ff\n", color);
4180 color = getPixelColor(device, 360, 200);
4181 ok(color == 0x00000000, "pixel 360/200 has color %08x, expected 0x00000000\n", color);
4182 color = getPixelColor(device, 440, 200);
4183 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4184 color = getPixelColor(device, 200, 270);
4185 ok(color == 0x00ffffff, "pixel 200/270 has color %08x, expected 0x00ffffff\n", color);
4186 color = getPixelColor(device, 280, 270);
4187 ok(color == 0x00ff0000, "pixel 280/270 has color %08x, expected 0x00ff0000\n", color);
4188 color = getPixelColor(device, 360, 270);
4189 ok(color == 0x0000ff00, "pixel 360/270 has color %08x, expected 0x0000ff00\n", color);
4190 color = getPixelColor(device, 440, 270);
4191 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4192 }
4193
4194 static void test_constant_clamp_vs(IDirect3DDevice9 *device)
4195 {
4196 IDirect3DVertexShader9 *shader_11, *shader_11_2, *shader_20, *shader_20_2;
4197 IDirect3DVertexDeclaration9 *decl;
4198 HRESULT hr;
4199 DWORD color;
4200 DWORD shader_code_11[] = {
4201 0xfffe0101, /* vs_1_1 */
4202 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4203 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4204 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4205 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4206 0x0000ffff /* end */
4207 };
4208 DWORD shader_code_11_2[] = {
4209 0xfffe0101, /* vs_1_1 */
4210 0x00000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000, /* dcl ... */
4211 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* dcl ... */
4212 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4213 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4214 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4215 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4216 0x0000ffff /* end */
4217 };
4218 DWORD shader_code_20[] = {
4219 0xfffe0200, /* vs_2_0 */
4220 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4221 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4222 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4223 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4224 0x0000ffff /* end */
4225 };
4226 DWORD shader_code_20_2[] = {
4227 0xfffe0200, /* vs_2_0 */
4228 0x05000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000,
4229 0x05000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000,
4230 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4231 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4232 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4233 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4234 0x0000ffff /* end */
4235 };
4236 static const D3DVERTEXELEMENT9 decl_elements[] = {
4237 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4238 D3DDECL_END()
4239 };
4240 float quad1[] = {
4241 -1.0, -1.0, 0.1,
4242 0.0, -1.0, 0.1,
4243 -1.0, 0.0, 0.1,
4244 0.0, 0.0, 0.1
4245 };
4246 float quad2[] = {
4247 0.0, -1.0, 0.1,
4248 1.0, -1.0, 0.1,
4249 0.0, 0.0, 0.1,
4250 1.0, 0.0, 0.1
4251 };
4252 float quad3[] = {
4253 0.0, 0.0, 0.1,
4254 1.0, 0.0, 0.1,
4255 0.0, 1.0, 0.1,
4256 1.0, 1.0, 0.1
4257 };
4258 float quad4[] = {
4259 -1.0, 0.0, 0.1,
4260 0.0, 0.0, 0.1,
4261 -1.0, 1.0, 0.1,
4262 0.0, 1.0, 0.1
4263 };
4264 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4265 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4266
4267 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4268 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4269
4270 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11, &shader_11);
4271 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
4272 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11_2, &shader_11_2);
4273 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
4274 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20, &shader_20);
4275 if(FAILED(hr)) shader_20 = NULL;
4276 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20_2, &shader_20_2);
4277 if(FAILED(hr)) shader_20_2 = NULL;
4278 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
4279 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4280
4281 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, test_data_c1, 1);
4282 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %s\n", DXGetErrorString9(hr));
4283 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 2, test_data_c2, 1);
4284 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %s\n", DXGetErrorString9(hr));
4285 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
4286 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4287
4288 hr = IDirect3DDevice9_BeginScene(device);
4289 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4290 if(SUCCEEDED(hr))
4291 {
4292 hr = IDirect3DDevice9_SetVertexShader(device, shader_11);
4293 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4294 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4295 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4296
4297 hr = IDirect3DDevice9_SetVertexShader(device, shader_11_2);
4298 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4299 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4300 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4301
4302 if(shader_20) {
4303 hr = IDirect3DDevice9_SetVertexShader(device, shader_20);
4304 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4305 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4306 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4307 }
4308
4309 if(shader_20_2) {
4310 hr = IDirect3DDevice9_SetVertexShader(device, shader_20_2);
4311 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4312 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4313 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4314 }
4315
4316 hr = IDirect3DDevice9_EndScene(device);
4317 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4318 }
4319 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4320 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4321
4322 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
4323 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4324 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
4325 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4326
4327 color = getPixelColor(device, 160, 360);
4328 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4329 "quad 1 has color %08x, expected 0x00bfbf80\n", color);
4330 color = getPixelColor(device, 480, 360);
4331 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4332 "quad 2 has color %08x, expected 0x00bfbf80\n", color);
4333 if(shader_20) {
4334 color = getPixelColor(device, 160, 120);
4335 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4336 "quad 3 has color %08x, expected 0x00bfbf80\n", color);
4337 }
4338 if(shader_20_2) {
4339 color = getPixelColor(device, 480, 120);
4340 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4341 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4342 }
4343
4344 IDirect3DVertexDeclaration9_Release(decl);
4345 if(shader_20_2) IDirect3DVertexShader9_Release(shader_20_2);
4346 if(shader_20) IDirect3DVertexShader9_Release(shader_20);
4347 IDirect3DVertexShader9_Release(shader_11_2);
4348 IDirect3DVertexShader9_Release(shader_11);
4349 }
4350
4351 static void constant_clamp_ps_test(IDirect3DDevice9 *device)
4352 {
4353 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_14, *shader_20;
4354 HRESULT hr;
4355 DWORD color;
4356 DWORD shader_code_11[] = {
4357 0xffff0101, /* ps_1_1 */
4358 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4359 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4360 0x0000ffff /* end */
4361 };
4362 DWORD shader_code_12[] = {
4363 0xffff0102, /* ps_1_2 */
4364 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4365 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4366 0x0000ffff /* end */
4367 };
4368 /* Skip 1.3 shaders because we have only 4 quads(ok, could make them smaller if needed).
4369 * 1.2 and 1.4 shaders behave the same, so it's unlikely that 1.3 shaders are different.
4370 * During development of this test, 1.3 shaders were verified too
4371 */
4372 DWORD shader_code_14[] = {
4373 0xffff0104, /* ps_1_4 */
4374 /* Try to make one constant local. It gets clamped too, although the binary contains
4375 * the bigger numbers
4376 */
4377 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* def c2, -0.5, 1.25, 2, 1 */
4378 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4379 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4380 0x0000ffff /* end */
4381 };
4382 DWORD shader_code_20[] = {
4383 0xffff0200, /* ps_2_0 */
4384 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4385 0x03000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4386 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4387 0x0000ffff /* end */
4388 };
4389 float quad1[] = {
4390 -1.0, -1.0, 0.1,
4391 0.0, -1.0, 0.1,
4392 -1.0, 0.0, 0.1,
4393 0.0, 0.0, 0.1
4394 };
4395 float quad2[] = {
4396 0.0, -1.0, 0.1,
4397 1.0, -1.0, 0.1,
4398 0.0, 0.0, 0.1,
4399 1.0, 0.0, 0.1
4400 };
4401 float quad3[] = {
4402 0.0, 0.0, 0.1,
4403 1.0, 0.0, 0.1,
4404 0.0, 1.0, 0.1,
4405 1.0, 1.0, 0.1
4406 };
4407 float quad4[] = {
4408 -1.0, 0.0, 0.1,
4409 0.0, 0.0, 0.1,
4410 -1.0, 1.0, 0.1,
4411 0.0, 1.0, 0.1
4412 };
4413 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4414 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4415
4416 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4417 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4418
4419 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4420 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4421 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4422 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4423 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4424 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4425 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader_20);
4426 if(FAILED(hr)) shader_20 = NULL;
4427
4428 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4429 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4430 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4431 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4432 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4433 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4434
4435 hr = IDirect3DDevice9_BeginScene(device);
4436 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4437 if(SUCCEEDED(hr))
4438 {
4439 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4440 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4441 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4442 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4443
4444 hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4445 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4446 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4447 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4448
4449 hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4450 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4451 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4452 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4453
4454 if(shader_20) {
4455 hr = IDirect3DDevice9_SetPixelShader(device, shader_20);
4456 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4457 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4458 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4459 }
4460
4461 hr = IDirect3DDevice9_EndScene(device);
4462 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4463 }
4464 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4465 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4466
4467 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4468 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4469
4470 color = getPixelColor(device, 160, 360);
4471 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4472 "quad 1 has color %08x, expected 0x00808000\n", color);
4473 color = getPixelColor(device, 480, 360);
4474 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4475 "quad 2 has color %08x, expected 0x00808000\n", color);
4476 color = getPixelColor(device, 480, 120);
4477 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4478 "quad 3 has color %08x, expected 0x00808000\n", color);
4479 if(shader_20) {
4480 color = getPixelColor(device, 160, 120);
4481 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4482 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4483 }
4484
4485 if(shader_20) IDirect3DPixelShader9_Release(shader_20);
4486 IDirect3DPixelShader9_Release(shader_14);
4487 IDirect3DPixelShader9_Release(shader_12);
4488 IDirect3DPixelShader9_Release(shader_11);
4489 }
4490
4491 static void dp2add_ps_test(IDirect3DDevice9 *device)
4492 {
4493 IDirect3DPixelShader9 *shader_dp2add = NULL;
4494 IDirect3DPixelShader9 *shader_dp2add_sat = NULL;
4495 HRESULT hr;
4496 DWORD color;
4497
4498 /* DP2ADD is defined as: (src0.r * src1.r) + (src0.g * src1.g) + src2.
4499 * One D3D restriction of all shader instructions except SINCOS is that no more than 2
4500 * source tokens can be constants. So, for this exercise, we move contents of c0 to
4501 * r0 first.
4502 * The result here for the r,g,b components should be roughly 0.5:
4503 * (0.5 * 0.5) + (0.5 * 0.5) + 0.0 = 0.5 */
4504 static const DWORD shader_code_dp2add[] = {
4505 0xffff0200, /* ps_2_0 */
4506 0x05000051, 0xa00f0000, 0x3f000000, 0x3f000000, 0x3f800000, 0x00000000, /* def c0, 0.5, 0.5, 1.0, 0 */
4507
4508 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4509 0x0400005a, 0x80070000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add r0.rgb, r0, r0, r0.a */
4510
4511 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4512 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4513 0x0000ffff /* end */
4514 };
4515
4516 /* Test the _sat modifier, too. Result here should be:
4517 * DP2: (-0.5 * -0.5) + (-0.5 * -0.5) + 2.0 = 2.5
4518 * _SAT: ==> 1.0
4519 * ADD: (1.0 + -0.5) = 0.5
4520 */
4521 static const DWORD shader_code_dp2add_sat[] = {
4522 0xffff0200, /* ps_2_0 */
4523 0x05000051, 0xa00f0000, 0xbf000000, 0xbf000000, 0x3f800000, 0x40000000, /* def c0, -0.5, -0.5, 1.0, 2.0 */
4524
4525 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4526 0x0400005a, 0x80170000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add_sat r0.rgb, r0, r0, r0.a */
4527 0x03000002, 0x80070000, 0x80e40000, 0xa0000000, /* add r0.rgb, r0, c0.r */
4528
4529 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4530 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4531 0x0000ffff /* end */
4532 };
4533
4534 const float quad[] = {
4535 -1.0, -1.0, 0.1,
4536 1.0, -1.0, 0.1,
4537 -1.0, 1.0, 0.1,
4538 1.0, 1.0, 0.1
4539 };
4540
4541
4542 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
4543 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4544
4545 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add, &shader_dp2add);
4546 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4547
4548 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add_sat, &shader_dp2add_sat);
4549 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4550
4551 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4552 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4553
4554 if (shader_dp2add) {
4555
4556 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add);
4557 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4558
4559 hr = IDirect3DDevice9_BeginScene(device);
4560 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4561 if(SUCCEEDED(hr))
4562 {
4563 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4564 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4565
4566 hr = IDirect3DDevice9_EndScene(device);
4567 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4568 }
4569 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4570 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4571
4572 color = getPixelColor(device, 360, 240);
4573 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4574
4575 IDirect3DPixelShader9_Release(shader_dp2add);
4576 } else {
4577 skip("dp2add shader creation failed\n");
4578 }
4579
4580 if (shader_dp2add_sat) {
4581
4582 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add_sat);
4583 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4584
4585 hr = IDirect3DDevice9_BeginScene(device);
4586 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4587 if(SUCCEEDED(hr))
4588 {
4589 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4590 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4591
4592 hr = IDirect3DDevice9_EndScene(device);
4593 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4594 }
4595 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4596 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4597
4598 color = getPixelColor(device, 360, 240);
4599 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4600
4601 IDirect3DPixelShader9_Release(shader_dp2add_sat);
4602 } else {
4603 skip("dp2add shader creation failed\n");
4604 }
4605
4606 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4607 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4608 }
4609
4610 static void cnd_test(IDirect3DDevice9 *device)
4611 {
4612 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_13, *shader_14;
4613 IDirect3DPixelShader9 *shader_11_coissue, *shader_12_coissue, *shader_13_coissue, *shader_14_coissue;
4614 HRESULT hr;
4615 DWORD color;
4616 /* ps 1.x shaders are rather picky with writemasks and source swizzles. The dp3 is
4617 * used to copy r0.r to all components of r1, then copy r1.a to c0.a. Essentially it
4618 * does a mov r0.a, r0.r, which isn't allowed as-is in 1.x pixel shaders.
4619 */
4620 DWORD shader_code_11[] = {
4621 0xffff0101, /* ps_1_1 */
4622 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4623 0x00000040, 0xb00f0000, /* texcoord t0 */
4624 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, ???(t0) */
4625 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4626 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4627 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4628 0x0000ffff /* end */
4629 };
4630 DWORD shader_code_12[] = {
4631 0xffff0102, /* ps_1_2 */
4632 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4633 0x00000040, 0xb00f0000, /* texcoord t0 */
4634 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4635 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4636 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4637 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4638 0x0000ffff /* end */
4639 };
4640 DWORD shader_code_13[] = {
4641 0xffff0103, /* ps_1_3 */
4642 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4643 0x00000040, 0xb00f0000, /* texcoord t0 */
4644 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4645 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3, r1, r0, c0 */
4646 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4647 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4648 0x0000ffff /* end */
4649 };
4650 DWORD shader_code_14[] = {
4651 0xffff0104, /* ps_1_3 */
4652 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4653 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4654 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4655 0x00000050, 0x800f0000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0, c1, c2 */
4656 0x0000ffff /* end */
4657 };
4658
4659 /* Special fun: The coissue flag on cnd: Apparently cnd always selects the 2nd source,
4660 * as if the src0 comparison against 0.5 always evaluates to true. The coissue flag isn't
4661 * set by the compiler, it was added manually after compilation. It isn't always allowed,
4662 * only if there's a mov r0.a, XXXX, and the cnd instruction writes to r0.xyz, otherwise
4663 * native CreatePixelShader returns an error.
4664 *
4665 * The shader attempts to test the range [-1;1] against coissued cnd, which is a bit tricky.
4666 * The input from t0 is [0;1]. 0.5 is substracted, then we have to multiply with 2. Since
4667 * constants are clamped to [-1;1], a 2.0 is constructed by adding c0.r(=1.0) to c0.r into r1.r,
4668 * then r1(2.0, 0.0, 0.0, 0.0) is passed to dp3(explained above).
4669 */
4670 DWORD shader_code_11_coissue[] = {
4671 0xffff0101, /* ps_1_1 */
4672 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4673 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4674 0x00000040, 0xb00f0000, /* texcoord t0 */
4675 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4676 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4677 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4678 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4679 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4680 /* 0x40000000 = D3DSI_COISSUE */
4681 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4682 0x0000ffff /* end */
4683 };
4684 DWORD shader_code_12_coissue[] = {
4685 0xffff0102, /* ps_1_2 */
4686 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4687 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4688 0x00000040, 0xb00f0000, /* texcoord t0 */
4689 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4690 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4691 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4692 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4693 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4694 /* 0x40000000 = D3DSI_COISSUE */
4695 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4696 0x0000ffff /* end */
4697 };
4698 DWORD shader_code_13_coissue[] = {
4699 0xffff0103, /* ps_1_3 */
4700 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4701 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4702 0x00000040, 0xb00f0000, /* texcoord t0 */
4703 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4704 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4705 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4706 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4707 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4708 /* 0x40000000 = D3DSI_COISSUE */
4709 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4710 0x0000ffff /* end */
4711 };
4712 /* ps_1_4 does not have a different cnd behavior, just pass the [0;1] texcrd result to cnd, it will
4713 * compare against 0.5
4714 */
4715 DWORD shader_code_14_coissue[] = {
4716 0xffff0104, /* ps_1_4 */
4717 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4718 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4719 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4720 /* 0x40000000 = D3DSI_COISSUE */
4721 0x40000050, 0x80070000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0, c1, c2 */
4722 0x0000ffff /* end */
4723 };
4724 float quad1[] = {
4725 -1.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4726 0.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4727 -1.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4728 0.0, 0.0, 0.1, 1.0, 1.0, 0.0
4729 };
4730 float quad2[] = {
4731 0.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4732 1.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4733 0.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4734 1.0, 0.0, 0.1, 1.0, 1.0, 0.0
4735 };
4736 float quad3[] = {
4737 0.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4738 1.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4739 0.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4740 1.0, 1.0, 0.1, 1.0, 1.0, 0.0
4741 };
4742 float quad4[] = {
4743 -1.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4744 0.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4745 -1.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4746 0.0, 1.0, 0.1, 1.0, 1.0, 0.0
4747 };
4748 float test_data_c1[4] = { 0.0, 0.0, 0.0, 0.0};
4749 float test_data_c2[4] = { 1.0, 1.0, 1.0, 1.0};
4750 float test_data_c1_coi[4] = { 0.0, 1.0, 0.0, 0.0};
4751 float test_data_c2_coi[4] = { 1.0, 0.0, 1.0, 1.0};
4752
4753 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4754 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4755
4756 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4757 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4758 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4759 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4760 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13, &shader_13);
4761 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4762 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4763 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4764 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11_coissue, &shader_11_coissue);
4765 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4766 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12_coissue, &shader_12_coissue);
4767 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4768 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13_coissue, &shader_13_coissue);
4769 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4770 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14_coissue, &shader_14_coissue);
4771 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4772
4773 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4774 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4775 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4776 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4777 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4778 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4779
4780 hr = IDirect3DDevice9_BeginScene(device);
4781 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4782 if(SUCCEEDED(hr))
4783 {
4784 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4785 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4786 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4787 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4788
4789 hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4790 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4791 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4792 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4793
4794 hr = IDirect3DDevice9_SetPixelShader(device, shader_13);
4795 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4796 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4797 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4798
4799 hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4800 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4801 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4802 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4803
4804 hr = IDirect3DDevice9_EndScene(device);
4805 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4806 }
4807 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4808 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4809
4810 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4811 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4812
4813 /* This is the 1.4 test. Each component(r, g, b) is tested separately against 0.5 */
4814 color = getPixelColor(device, 158, 118);
4815 ok(color == 0x00ff00ff, "pixel 158, 118 has color %08x, expected 0x00ff00ff\n", color);
4816 color = getPixelColor(device, 162, 118);
4817 ok(color == 0x000000ff, "pixel 162, 118 has color %08x, expected 0x000000ff\n", color);
4818 color = getPixelColor(device, 158, 122);
4819 ok(color == 0x00ffffff, "pixel 162, 122 has color %08x, expected 0x00ffffff\n", color);
4820 color = getPixelColor(device, 162, 122);
4821 ok(color == 0x0000ffff, "pixel 162, 122 has color %08x, expected 0x0000ffff\n", color);
4822
4823 /* 1.1 shader. All 3 components get set, based on the .w comparison */
4824 color = getPixelColor(device, 158, 358);
4825 ok(color == 0x00ffffff, "pixel 158, 358 has color %08x, expected 0x00ffffff\n", color);
4826 color = getPixelColor(device, 162, 358);
4827 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4828 "pixel 162, 358 has color %08x, expected 0x00000000\n", color);
4829 color = getPixelColor(device, 158, 362);
4830 ok(color == 0x00ffffff, "pixel 158, 362 has color %08x, expected 0x00ffffff\n", color);
4831 color = getPixelColor(device, 162, 362);
4832 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4833 "pixel 162, 362 has color %08x, expected 0x00000000\n", color);
4834
4835 /* 1.2 shader */
4836 color = getPixelColor(device, 478, 358);
4837 ok(color == 0x00ffffff, "pixel 478, 358 has color %08x, expected 0x00ffffff\n", color);
4838 color = getPixelColor(device, 482, 358);
4839 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4840 "pixel 482, 358 has color %08x, expected 0x00000000\n", color);
4841 color = getPixelColor(device, 478, 362);
4842 ok(color == 0x00ffffff, "pixel 478, 362 has color %08x, expected 0x00ffffff\n", color);
4843 color = getPixelColor(device, 482, 362);
4844 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4845 "pixel 482, 362 has color %08x, expected 0x00000000\n", color);
4846
4847 /* 1.3 shader */
4848 color = getPixelColor(device, 478, 118);
4849 ok(color == 0x00ffffff, "pixel 478, 118 has color %08x, expected 0x00ffffff\n", color);
4850 color = getPixelColor(device, 482, 118);
4851 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4852 "pixel 482, 118 has color %08x, expected 0x00000000\n", color);
4853 color = getPixelColor(device, 478, 122);
4854 ok(color == 0x00ffffff, "pixel 478, 122 has color %08x, expected 0x00ffffff\n", color);
4855 color = getPixelColor(device, 482, 122);
4856 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4857 "pixel 482, 122 has color %08x, expected 0x00000000\n", color);
4858
4859 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4860 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4861 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1_coi, 1);
4862 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4863 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2_coi, 1);
4864 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4865
4866 hr = IDirect3DDevice9_BeginScene(device);
4867 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4868 if(SUCCEEDED(hr))
4869 {
4870 hr = IDirect3DDevice9_SetPixelShader(device, shader_11_coissue);
4871 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4872 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4873 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4874
4875 hr = IDirect3DDevice9_SetPixelShader(device, shader_12_coissue);
4876 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4877 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4878 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4879
4880 hr = IDirect3DDevice9_SetPixelShader(device, shader_13_coissue);
4881 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4882 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4883 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4884
4885 hr = IDirect3DDevice9_SetPixelShader(device, shader_14_coissue);
4886 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4887 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4888 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4889
4890 hr = IDirect3DDevice9_EndScene(device);
4891 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4892 }
4893 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4894 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4895
4896 /* This is the 1.4 test. The coissue doesn't change the behavior here, but keep in mind
4897 * that we swapped the values in c1 and c2 to make the other tests return some color
4898 */
4899 color = getPixelColor(device, 158, 118);
4900 ok(color == 0x00ffffff, "pixel 158, 118 has color %08x, expected 0x00ffffff\n", color);
4901 color = getPixelColor(device, 162, 118);
4902 ok(color == 0x0000ffff, "pixel 162, 118 has color %08x, expected 0x0000ffff\n", color);
4903 color = getPixelColor(device, 158, 122);
4904 ok(color == 0x00ff00ff, "pixel 162, 122 has color %08x, expected 0x00ff00ff\n", color);
4905 color = getPixelColor(device, 162, 122);
4906 ok(color == 0x000000ff, "pixel 162, 122 has color %08x, expected 0x000000ff\n", color);
4907
4908 /* 1.1 shader. coissue flag changed the semantic of cnd, c1 is always selected */
4909 color = getPixelColor(device, 158, 358);
4910 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4911 "pixel 158, 358 has color %08x, expected 0x0000ff00\n", color);
4912 color = getPixelColor(device, 162, 358);
4913 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4914 "pixel 162, 358 has color %08x, expected 0x0000ff00\n", color);
4915 color = getPixelColor(device, 158, 362);
4916 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4917 "pixel 158, 362 has color %08x, expected 0x0000ff00\n", color);
4918 color = getPixelColor(device, 162, 362);
4919 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4920 "pixel 162, 362 has color %08x, expected 0x0000ff00\n", color);
4921
4922 /* 1.2 shader */
4923 color = getPixelColor(device, 478, 358);
4924 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4925 "pixel 478, 358 has color %08x, expected 0x0000ff00\n", color);
4926 color = getPixelColor(device, 482, 358);
4927 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4928 "pixel 482, 358 has color %08x, expected 0x0000ff00\n", color);
4929 color = getPixelColor(device, 478, 362);
4930 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4931 "pixel 478, 362 has color %08x, expected 0x0000ff00\n", color);
4932 color = getPixelColor(device, 482, 362);
4933 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4934 "pixel 482, 362 has color %08x, expected 0x0000ff00\n", color);
4935
4936 /* 1.3 shader */
4937 color = getPixelColor(device, 478, 118);
4938 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4939 "pixel 478, 118 has color %08x, expected 0x0000ff00\n", color);
4940 color = getPixelColor(device, 482, 118);
4941 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4942 "pixel 482, 118 has color %08x, expected 0x0000ff00\n", color);
4943 color = getPixelColor(device, 478, 122);
4944 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4945 "pixel 478, 122 has color %08x, expected 0x0000ff00\n", color);
4946 color = getPixelColor(device, 482, 122);
4947 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4948 "pixel 482, 122 has color %08x, expected 0x0000ff00\n", color);
4949
4950 IDirect3DPixelShader9_Release(shader_14_coissue);
4951 IDirect3DPixelShader9_Release(shader_13_coissue);
4952 IDirect3DPixelShader9_Release(shader_12_coissue);
4953 IDirect3DPixelShader9_Release(shader_11_coissue);
4954 IDirect3DPixelShader9_Release(shader_14);
4955 IDirect3DPixelShader9_Release(shader_13);
4956 IDirect3DPixelShader9_Release(shader_12);
4957 IDirect3DPixelShader9_Release(shader_11);
4958 }
4959
4960 static void nested_loop_test(IDirect3DDevice9 *device) {
4961 const DWORD shader_code[] = {
4962 0xffff0300, /* ps_3_0 */
4963 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4964 0x05000051, 0xa00f0001, 0x3d000000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1/32, 0, 0, 0*/
4965 0x05000030, 0xf00f0000, 0x00000004, 0x00000000, 0x00000002, 0x00000000, /* defi i0, 4, 0, 2, 0 */
4966 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4967 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
4968 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
4969 0x03000002, 0x800f0000, 0x80e40000, 0xa0e40001, /* add r0, r0, c1 */
4970 0x0000001d, /* endloop */
4971 0x0000001d, /* endloop */
4972 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4973 0x0000ffff /* end */
4974 };
4975 IDirect3DPixelShader9 *shader;
4976 HRESULT hr;
4977 DWORD color;
4978 const float quad[] = {
4979 -1.0, -1.0, 0.1,
4980 1.0, -1.0, 0.1,
4981 -1.0, 1.0, 0.1,
4982 1.0, 1.0, 0.1
4983 };
4984
4985 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4986 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed with %s\n", DXGetErrorString9(hr));
4987 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4988 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %s\n", DXGetErrorString9(hr));
4989 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4990 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
4991 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x0000ff00, 0.0, 0);
4992 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4993
4994 hr = IDirect3DDevice9_BeginScene(device);
4995 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4996 if(SUCCEEDED(hr))
4997 {
4998 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4999 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5000 hr = IDirect3DDevice9_EndScene(device);
5001 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5002 }
5003 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5004 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5005
5006 color = getPixelColor(device, 360, 240);
5007 ok(color == 0x007f0000 || color == 0x00800000 || color == 0x00810000,
5008 "Nested loop test returned color 0x%08x, expected 0x00800000\n", color);
5009
5010 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5011 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %s\n", DXGetErrorString9(hr));
5012 IDirect3DPixelShader9_Release(shader);
5013 }
5014
5015 struct varying_test_struct
5016 {
5017 const DWORD *shader_code;
5018 IDirect3DPixelShader9 *shader;
5019 DWORD color, color_rhw;
5020 const char *name;
5021 BOOL todo, todo_rhw;
5022 };
5023
5024 struct hugeVertex
5025 {
5026 float pos_x, pos_y, pos_z, rhw;
5027 float weight_1, weight_2, weight_3, weight_4;
5028 float index_1, index_2, index_3, index_4;
5029 float normal_1, normal_2, normal_3, normal_4;
5030 float fog_1, fog_2, fog_3, fog_4;
5031 float texcoord_1, texcoord_2, texcoord_3, texcoord_4;
5032 float tangent_1, tangent_2, tangent_3, tangent_4;
5033 float binormal_1, binormal_2, binormal_3, binormal_4;
5034 float depth_1, depth_2, depth_3, depth_4;
5035 DWORD diffuse, specular;
5036 };
5037
5038 static void fixed_function_varying_test(IDirect3DDevice9 *device) {
5039 /* dcl_position: fails to compile */
5040 const DWORD blendweight_code[] = {
5041 0xffff0300, /* ps_3_0 */
5042 0x0200001f, 0x80000001, 0x900f0000, /* dcl_blendweight, v0 */
5043 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5044 0x0000ffff /* end */
5045 };
5046 const DWORD blendindices_code[] = {
5047 0xffff0300, /* ps_3_0 */
5048 0x0200001f, 0x80000002, 0x900f0000, /* dcl_blendindices, v0 */
5049 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5050 0x0000ffff /* end */
5051 };
5052 const DWORD normal_code[] = {
5053 0xffff0300, /* ps_3_0 */
5054 0x0200001f, 0x80000003, 0x900f0000, /* dcl_normal, v0 */
5055 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5056 0x0000ffff /* end */
5057 };
5058 /* psize: fails? */
5059 const DWORD texcoord0_code[] = {
5060 0xffff0300, /* ps_3_0 */
5061 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0, v0 */
5062 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5063 0x0000ffff /* end */
5064 };
5065 const DWORD tangent_code[] = {
5066 0xffff0300, /* ps_3_0 */
5067 0x0200001f, 0x80000006, 0x900f0000, /* dcl_tangent, v0 */
5068 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5069 0x0000ffff /* end */
5070 };
5071 const DWORD binormal_code[] = {
5072 0xffff0300, /* ps_3_0 */
5073 0x0200001f, 0x80000007, 0x900f0000, /* dcl_binormal, v0 */
5074 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5075 0x0000ffff /* end */
5076 };
5077 /* tessfactor: fails */
5078 /* positiont: fails */
5079 const DWORD color_code[] = {
5080 0xffff0300, /* ps_3_0 */
5081 0x0200001f, 0x8000000a, 0x900f0000, /* dcl_color0, v0 */
5082 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5083 0x0000ffff /* end */
5084 };
5085 const DWORD fog_code[] = {
5086 0xffff0300, /* ps_3_0 */
5087 0x0200001f, 0x8000000b, 0x900f0000, /* dcl_fog, v0 */
5088 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5089 0x0000ffff /* end */
5090 };
5091 const DWORD depth_code[] = {
5092 0xffff0300, /* ps_3_0 */
5093 0x0200001f, 0x8000000c, 0x900f0000, /* dcl_depth, v0 */
5094 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5095 0x0000ffff /* end */
5096 };
5097 const DWORD specular_code[] = {
5098 0xffff0300, /* ps_3_0 */
5099 0x0200001f, 0x8001000a, 0x900f0000, /* dcl_color1, v0 */
5100 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5101 0x0000ffff /* end */
5102 };
5103 /* sample: fails */
5104
5105 struct varying_test_struct tests[] = {
5106 {blendweight_code, NULL, 0x00000000, 0x00191919, "blendweight" , FALSE, TRUE },
5107 {blendindices_code, NULL, 0x00000000, 0x00000000, "blendindices" , FALSE, FALSE },
5108 {normal_code, NULL, 0x00000000, 0x004c4c4c, "normal" , FALSE, TRUE },
5109 /* Why does dx not forward the texcoord? */
5110 {texcoord0_code, NULL, 0x00000000, 0x00808c8c, "texcoord0" , FALSE, FALSE },
5111 {tangent_code, NULL, 0x00000000, 0x00999999, "tangent" , FALSE, TRUE },
5112 {binormal_code, NULL, 0x00000000, 0x00b2b2b2, "binormal" , FALSE, TRUE },
5113 {color_code, NULL, 0x00e6e6e6, 0x00e6e6e6, "color" , FALSE, FALSE },
5114 {fog_code, NULL, 0x00000000, 0x00666666, "fog" , FALSE, TRUE },
5115 {depth_code, NULL, 0x00000000, 0x00cccccc, "depth" , FALSE, TRUE },
5116 {specular_code, NULL, 0x004488ff, 0x004488ff, "specular" , FALSE, FALSE }
5117 };
5118 /* Declare a monster vertex type :-) */
5119 static const D3DVERTEXELEMENT9 decl_elements[] = {
5120 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5121 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5122 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5123 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5124 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5125 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5126 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5127 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5128 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5129 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5130 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5131 D3DDECL_END()
5132 };
5133 static const D3DVERTEXELEMENT9 decl_elements2[] = {
5134 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
5135 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5136 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5137 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5138 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5139 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5140 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5141 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5142 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5143 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5144 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5145 D3DDECL_END()
5146 };
5147 struct hugeVertex data[4] = {
5148 {
5149 -1.0, -1.0, 0.1, 1.0,
5150 0.1, 0.1, 0.1, 0.1,
5151 0.2, 0.2, 0.2, 0.2,
5152 0.3, 0.3, 0.3, 0.3,
5153 0.4, 0.4, 0.4, 0.4,
5154 0.50, 0.55, 0.55, 0.55,
5155 0.6, 0.6, 0.6, 0.7,
5156 0.7, 0.7, 0.7, 0.6,
5157 0.8, 0.8, 0.8, 0.8,
5158 0xe6e6e6e6, /* 0.9 * 256 */
5159 0x224488ff /* Nothing special */
5160 },
5161 {
5162 1.0, -1.0, 0.1, 1.0,
5163 0.1, 0.1, 0.1, 0.1,
5164 0.2, 0.2, 0.2, 0.2,
5165 0.3, 0.3, 0.3, 0.3,
5166 0.4, 0.4, 0.4, 0.4,
5167 0.50, 0.55, 0.55, 0.55,
5168 0.6, 0.6, 0.6, 0.7,
5169 0.7, 0.7, 0.7, 0.6,
5170 0.8, 0.8, 0.8, 0.8,
5171 0xe6e6e6e6, /* 0.9 * 256 */
5172 0x224488ff /* Nothing special */
5173 },
5174 {
5175 -1.0, 1.0, 0.1, 1.0,
5176 0.1, 0.1, 0.1, 0.1,
5177 0.2, 0.2, 0.2, 0.2,
5178 0.3, 0.3, 0.3, 0.3,
5179 0.4, 0.4, 0.4, 0.4,
5180 0.50, 0.55, 0.55, 0.55,
5181 0.6, 0.6, 0.6, 0.7,
5182 0.7, 0.7, 0.7, 0.6,
5183 0.8, 0.8, 0.8, 0.8,
5184 0xe6e6e6e6, /* 0.9 * 256 */
5185 0x224488ff /* Nothing special */
5186 },
5187 {
5188 1.0, 1.0, 0.1, 1.0,
5189 0.1, 0.1, 0.1, 0.1,
5190 0.2, 0.2, 0.2, 0.2,
5191 0.3, 0.3, 0.3, 0.3,
5192 0.4, 0.4, 0.4, 0.4,
5193 0.50, 0.55, 0.55, 0.55,
5194 0.6, 0.6, 0.6, 0.7,
5195 0.7, 0.7, 0.7, 0.6,
5196 0.8, 0.8, 0.8, 0.8,
5197 0xe6e6e6e6, /* 0.9 * 256 */
5198 0x224488ff /* Nothing special */
5199 },
5200 };
5201 struct hugeVertex data2[4];
5202 IDirect3DVertexDeclaration9 *decl;
5203 IDirect3DVertexDeclaration9 *decl2;
5204 HRESULT hr;
5205 unsigned int i;
5206 DWORD color, r, g, b, r_e, g_e, b_e;
5207 BOOL drawok;
5208
5209 memcpy(data2, data, sizeof(data2));
5210 data2[0].pos_x = 0; data2[0].pos_y = 0;
5211 data2[1].pos_x = 640; data2[1].pos_y = 0;
5212 data2[2].pos_x = 0; data2[2].pos_y = 480;
5213 data2[3].pos_x = 640; data2[3].pos_y = 480;
5214
5215 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
5216 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5217 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
5218 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5219 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
5220 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5221
5222 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5223 {
5224 hr = IDirect3DDevice9_CreatePixelShader(device, tests[i].shader_code, &tests[i].shader);
5225 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed for shader %s, hr = %s\n",
5226 tests[i].name, DXGetErrorString9(hr));
5227 }
5228
5229 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5230 {
5231 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5232 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
5233
5234 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5235 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5236
5237 hr = IDirect3DDevice9_BeginScene(device);
5238 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5239 drawok = FALSE;
5240 if(SUCCEEDED(hr))
5241 {
5242 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data, sizeof(data[0]));
5243 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed (%08x)\n", hr);
5244 drawok = SUCCEEDED(hr);
5245 hr = IDirect3DDevice9_EndScene(device);
5246 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5247 }
5248 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5249 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5250
5251 /* Some drivers reject the combination of ps_3_0 and fixed function vertex processing. Accept
5252 * the failure and do not check the color if it failed
5253 */
5254 if(!drawok) {
5255 continue;
5256 }
5257
5258 color = getPixelColor(device, 360, 240);
5259 r = color & 0x00ff0000 >> 16;
5260 g = color & 0x0000ff00 >> 8;
5261 b = color & 0x000000ff;
5262 r_e = tests[i].color & 0x00ff0000 >> 16;
5263 g_e = tests[i].color & 0x0000ff00 >> 8;
5264 b_e = tests[i].color & 0x000000ff;
5265
5266 if(tests[i].todo) {
5267 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5268 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5269 tests[i].name, color, tests[i].color);
5270 } else {
5271 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5272 "Test %s returned color 0x%08x, expected 0x%08x\n",
5273 tests[i].name, color, tests[i].color);
5274 }
5275 }
5276
5277 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
5278 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5279 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5280 {
5281 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5282 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
5283
5284 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5285 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5286
5287 hr = IDirect3DDevice9_BeginScene(device);
5288 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5289 if(SUCCEEDED(hr))
5290 {
5291 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data2, sizeof(data2[0]));
5292 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5293 hr = IDirect3DDevice9_EndScene(device);
5294 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5295 }
5296 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5297 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5298
5299 color = getPixelColor(device, 360, 240);
5300 r = color & 0x00ff0000 >> 16;
5301 g = color & 0x0000ff00 >> 8;
5302 b = color & 0x000000ff;
5303 r_e = tests[i].color_rhw & 0x00ff0000 >> 16;
5304 g_e = tests[i].color_rhw & 0x0000ff00 >> 8;
5305 b_e = tests[i].color_rhw & 0x000000ff;
5306
5307 if(tests[i].todo_rhw) {
5308 /* This isn't a weekend's job to fix, ignore the problem for now. Needs a replacement
5309 * pipeline
5310 */
5311 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5312 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5313 tests[i].name, color, tests[i].color_rhw);
5314 } else {
5315 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5316 "Test %s returned color 0x%08x, expected 0x%08x\n",
5317 tests[i].name, color, tests[i].color_rhw);
5318 }
5319 }
5320
5321 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5322 {
5323 IDirect3DPixelShader9_Release(tests[i].shader);
5324 }
5325
5326 IDirect3DVertexDeclaration9_Release(decl2);
5327 IDirect3DVertexDeclaration9_Release(decl);
5328 }
5329
5330 static void vshader_version_varying_test(IDirect3DDevice9 *device) {
5331 static const DWORD ps_code[] = {
5332 0xffff0300, /* ps_3_0 */
5333 0x05000030, 0xf00f0000, 0x00000003, 0x00000003, 0x00000001, 0x00000000, /* defi i0, 3, 3, 1, 0 */
5334 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5335 0x0200001f, 0x8001000a, 0x900f0003, /* dcl_color1 v3 */
5336 0x0200001f, 0x8000000b, 0x900f0004, /* dcl_fog v4 */
5337 0x0200001f, 0x80030005, 0x900f0005, /* dcl_texcoord3 v5 */
5338 0x0200001f, 0x80000003, 0x900f0006,
5339 0x0200001f, 0x80000006, 0x900f0007,
5340 0x0200001f, 0x80000001, 0x900f0008,
5341 0x0200001f, 0x8000000c, 0x900f0009,
5342
5343 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5344 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
5345 0x04000002, 0x800f0000, 0x80e40000, 0x90e42000, 0xf0e40800, /* add r0, r0, v0[aL] */
5346 0x0000001d, /* endloop */
5347 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5348 0x0000ffff /* end */
5349 };
5350 static const DWORD vs_1_code[] = {
5351 0xfffe0101, /* vs_1_1 */
5352 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5353 0x00000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5354 0x00000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5355 0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5356 0x00000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5357 0x00000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5358 0x00000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5359 0x00000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5360 0x00000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5361 0x00000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5362 0x00000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5363 0x00000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5364 0x00000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5365 0x00000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5366 0x00000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5367 0x00000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5368 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5369 0x0000ffff
5370 };
5371 DWORD vs_2_code[] = {
5372 0xfffe0200, /* vs_2_0 */
5373 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5374 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0 */
5375 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.5, 0.0, 0.0 */
5376 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.5, 0.0 */
5377 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5378 0x02000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5379 0x02000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5380 0x02000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5381 0x02000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5382 0x02000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5383 0x02000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5384 0x02000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5385 0x02000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5386 0x02000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5387 0x02000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5388 0x02000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5389 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5390 0x0000ffff /* end */
5391 };
5392 /* TODO: Define normal, tangent, blendweight and depth here */
5393 static const DWORD vs_3_code[] = {
5394 0xfffe0300, /* vs_3_0 */
5395 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5396 0x0200001f, 0x8001000a, 0xe00f0009, /* dcl_color1 o9 */
5397 0x0200001f, 0x8000000b, 0xe00f0002, /* dcl_fog o2 */
5398 0x0200001f, 0x80030005, 0xe00f0005, /* dcl_texcoord3 o5 */
5399 0x0200001f, 0x80000000, 0xe00f000b, /* dcl_position o11 */
5400 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5401 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5402 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5403 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5404 0x02000001, 0xe00f0009, 0xa0e40000, /* mov o9, c0 */
5405 0x02000001, 0xe00f0002, 0xa0e40001, /* mov o2, c1 */
5406 0x02000001, 0xe00f0005, 0xa0e40002, /* mov o5, c2 */
5407 0x02000001, 0xe00f000b, 0x90e40000, /* mov o11, v0 */
5408 0x0000ffff /* end */
5409 };
5410 float quad1[] = {
5411 -1.0, -1.0, 0.1,
5412 0.0, -1.0, 0.1,
5413 -1.0, 0.0, 0.1,
5414 0.0, 0.0, 0.1
5415 };
5416 float quad2[] = {
5417 0.0, -1.0, 0.1,
5418 1.0, -1.0, 0.1,
5419 0.0, 0.0, 0.1,
5420 1.0, 0.0, 0.1
5421 };
5422 float quad3[] = {
5423 -1.0, 0.0, 0.1,
5424 0.0, 0.0, 0.1,
5425 -1.0, 1.0, 0.1,
5426 0.0, 1.0, 0.1
5427 };
5428
5429 HRESULT hr;
5430 DWORD color;
5431 IDirect3DPixelShader9 *pixelshader = NULL;
5432 IDirect3DVertexShader9 *vs_1_shader = NULL;
5433 IDirect3DVertexShader9 *vs_2_shader = NULL;
5434 IDirect3DVertexShader9 *vs_3_shader = NULL;
5435
5436 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff110000, 0.0, 0);
5437
5438 hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &pixelshader);
5439 ok(hr == D3D_OK, "IDirect3DDevice_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5440 hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_code, &vs_1_shader);
5441 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5442 hr = IDirect3DDevice9_CreateVertexShader(device, vs_2_code, &vs_2_shader);
5443 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5444 hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_code, &vs_3_shader);
5445 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5446 hr = IDirect3DDevice9_SetPixelShader(device, pixelshader);
5447 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5448 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5449
5450 hr = IDirect3DDevice9_BeginScene(device);
5451 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5452 if(SUCCEEDED(hr))
5453 {
5454 hr = IDirect3DDevice9_SetVertexShader(device, vs_1_shader);
5455 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5456 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5457 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5458
5459 hr = IDirect3DDevice9_SetVertexShader(device, vs_2_shader);
5460 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5461 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5462 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5463
5464 hr = IDirect3DDevice9_SetVertexShader(device, vs_3_shader);
5465 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5466 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5467 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5468
5469 hr = IDirect3DDevice9_EndScene(device);
5470 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5471 }
5472 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5473 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5474
5475 color = getPixelColor(device, 160, 120);
5476 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5477 (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003500 &&
5478 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5479 "vs_3_0 returned color 0x%08x, expected 0x00203366\n", color);
5480 color = getPixelColor(device, 160, 360);
5481 ok((color & 0x00ff0000) >= 0x003c0000 && (color & 0x00ff0000) <= 0x004e0000 &&
5482 (color & 0x0000ff00) >= 0x00000000 && (color & 0x0000ff00) <= 0x00000000 &&
5483 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5484 "vs_1_1 returned color 0x%08x, expected 0x004c0066\n", color);
5485 color = getPixelColor(device, 480, 360);
5486 ok((color & 0x00ff0000) >= 0x003c0000 && (color & 0x00ff0000) <= 0x004e0000 &&
5487 (color & 0x0000ff00) >= 0x00000000 && (color & 0x0000ff00) <= 0x00000000 &&
5488 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5489 "vs_2_0 returned color 0x%08x, expected 0x004c0066\n", color);
5490
5491 /* cleanup */
5492 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5493 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5494 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5495 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5496 if(pixelshader) IDirect3DPixelShader9_Release(pixelshader);
5497 if(vs_1_shader) IDirect3DVertexShader9_Release(vs_1_shader);
5498 if(vs_2_shader) IDirect3DVertexShader9_Release(vs_2_shader);
5499 if(vs_3_shader) IDirect3DVertexShader9_Release(vs_3_shader);
5500 }
5501
5502 static void pshader_version_varying_test(IDirect3DDevice9 *device) {
5503 static const DWORD vs_code[] = {
5504 0xfffe0300, /* vs_3_0 */
5505 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5506 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5507 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color0 o1 */
5508 0x0200001f, 0x80000005, 0xe00f0002, /* dcl_texcoord0 o2 */
5509 0x0200001f, 0x8000000b, 0xe00f0003, /* dcl_fog o3 */
5510 0x0200001f, 0x80000003, 0xe00f0004, /* dcl_normal o4 */
5511 0x0200001f, 0x8000000c, 0xe00f0005, /* dcl_depth o5 */
5512 0x0200001f, 0x80000006, 0xe00f0006, /* dcl_tangent o6 */
5513 0x0200001f, 0x80000001, 0xe00f0007, /* dcl_blendweight o7 */
5514 0x05000051, 0xa00f0001, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c1, 0.1, 0.0, 0.0, 0.0 */
5515 0x05000051, 0xa00f0002, 0x00000000, 0x3e4ccccd, 0x00000000, 0x3f800000, /* def c2, 0.0, 0.2, 0.0, 1.0 */
5516 0x05000051, 0xa00f0003, 0x3ecccccd, 0x3f59999a, 0x3f666666, 0x00000000, /* def c3, 0.4, 0.85,0.9, 0.0 */
5517 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c0, 1.0, 1.0, 1.0, 1.0 */
5518
5519 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5520 0x02000001, 0xe00f0001, 0xa0e40001, /* mov o1, c1 */
5521 0x02000001, 0xe00f0002, 0xa0e40002, /* mov o2, c2 */
5522 0x02000001, 0xe00f0003, 0xa0e40003, /* mov o3, c3 */
5523 0x02000001, 0xe00f0004, 0xa0e40000, /* mov o4, c0 */
5524 0x02000001, 0xe00f0005, 0xa0e40000, /* mov o5, c0 */
5525 0x02000001, 0xe00f0006, 0xa0e40000, /* mov o6, c0 */
5526 0x02000001, 0xe00f0007, 0xa0e40000, /* mov o7, c0 */
5527 0x0000ffff /* end */
5528 };
5529 static const DWORD ps_1_code[] = {
5530 0xffff0104, /* ps_1_4 */
5531 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5532 0x00000040, 0x80070001, 0xb0e40000, /* texcrd r1.xyz, t0 */
5533 0x00000001, 0x80080001, 0xa0ff0000, /* mov r1.a, c0.a */
5534 0x00000002, 0x800f0000, 0x90e40000, 0x80e40001, /* add r0, v0, r1 */
5535 0x0000ffff /* end */
5536 };
5537 static const DWORD ps_2_code[] = {
5538 0xffff0200, /* ps_2_0 */
5539 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
5540 0x0200001f, 0x80000000, 0x900f0000, /* dcl v0 */
5541 0x0200001f, 0x80000000, 0x900f0001, /* dcl v1 */
5542
5543 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5544 0x03000002, 0x800f0000, 0x80e40000,0xb0e40000, /* add r0, r0, t0 */
5545 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5546 0x0000ffff /* end */
5547 };
5548 static const DWORD ps_3_code[] = {
5549 0xffff0300, /* ps_3_0 */
5550 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0 v0 */
5551 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
5552 0x0200001f, 0x8000000b, 0x900f0002, /* dcl_fog v2 */
5553
5554 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5555 0x03000002, 0x800f0000, 0x80e40000, 0x90e40001, /* add r0, r0, v1 */
5556 0x03000002, 0x800f0000, 0x80e40000, 0x90e40002, /* mov r0, r0, v2 */
5557 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5558 0x0000ffff /* end */
5559 };
5560
5561 float quad1[] = {
5562 -1.0, -1.0, 0.1,
5563 0.0, -1.0, 0.1,
5564 -1.0, 0.0, 0.1,
5565 0.0, 0.0, 0.1
5566 };
5567 float quad2[] = {
5568 0.0, -1.0, 0.1,
5569 1.0, -1.0, 0.1,
5570 0.0, 0.0, 0.1,
5571 1.0, 0.0, 0.1
5572 };
5573 float quad3[] = {
5574 -1.0, 0.0, 0.1,
5575 0.0, 0.0, 0.1,
5576 -1.0, 1.0, 0.1,
5577 0.0, 1.0, 0.1
5578 };
5579 float quad4[] = {
5580 0.0, 0.0, 0.1,
5581 1.0, 0.0, 0.1,
5582 0.0, 1.0, 0.1,
5583 1.0, 1.0, 0.1
5584 };
5585
5586 HRESULT hr;
5587 DWORD color;
5588 IDirect3DVertexShader9 *vertexshader = NULL;
5589 IDirect3DPixelShader9 *ps_1_shader = NULL;
5590 IDirect3DPixelShader9 *ps_2_shader = NULL;
5591 IDirect3DPixelShader9 *ps_3_shader = NULL;
5592 IDirect3DTexture9 *texture = NULL;
5593 D3DLOCKED_RECT lr;
5594 unsigned int x, y;
5595
5596 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
5597
5598 hr = IDirect3DDevice9_CreateTexture(device, 512, 512, 1, 0, D3DFMT_A16B16G16R16, D3DPOOL_MANAGED, &texture, NULL);
5599 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
5600 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
5601 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %s\n", DXGetErrorString9(hr));
5602 for(y = 0; y < 512; y++) {
5603 for(x = 0; x < 512; x++) {
5604 double r_f = (double) x / (double) 512;
5605 double g_f = (double) y / (double) 512;
5606 unsigned short *dst = (unsigned short *) (((unsigned char *) lr.pBits) + y * lr.Pitch + x * 8);
5607 unsigned short r = (unsigned short) (r_f * 65535.0);
5608 unsigned short g = (unsigned short) (g_f * 65535.0);
5609 dst[0] = r;
5610 dst[1] = g;
5611 dst[2] = 0;
5612 dst[3] = 65535;
5613 }
5614 }
5615 hr = IDirect3DTexture9_UnlockRect(texture, 0);
5616 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %s\n", DXGetErrorString9(hr));
5617
5618 hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vertexshader);
5619 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5620 hr = IDirect3DDevice9_CreatePixelShader(device, ps_1_code, &ps_1_shader);
5621 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5622 hr = IDirect3DDevice9_CreatePixelShader(device, ps_2_code, &ps_2_shader);
5623 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5624 hr = IDirect3DDevice9_CreatePixelShader(device, ps_3_code, &ps_3_shader);
5625 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5626 hr = IDirect3DDevice9_SetVertexShader(device, vertexshader);
5627 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5628 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5629
5630 hr = IDirect3DDevice9_BeginScene(device);
5631 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5632 if(SUCCEEDED(hr))
5633 {
5634 hr = IDirect3DDevice9_SetPixelShader(device, ps_1_shader);
5635 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5636 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5637 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5638
5639 hr = IDirect3DDevice9_SetPixelShader(device, ps_2_shader);
5640 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5641 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5642 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5643
5644 hr = IDirect3DDevice9_SetPixelShader(device, ps_3_shader);
5645 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5646 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5647 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5648
5649 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5650 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5651 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
5652 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
5653 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
5654 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
5655 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
5656 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
5657 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5658 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5659
5660 hr = IDirect3DDevice9_EndScene(device);
5661 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5662 }
5663 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5664 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5665
5666 color = getPixelColor(device, 160, 120);
5667 ok((color & 0x00ff0000) >= 0x00790000 && (color & 0x00ff0000) <= 0x00810000 &&
5668 (color & 0x0000ff00) == 0x0000ff00 &&
5669 (color & 0x000000ff) >= 0x000000e4 && (color & 0x000000ff) <= 0x000000e6,
5670 "ps_3_0 returned color 0x%08x, expected 0x0080ffe5\n", color);
5671 color = getPixelColor(device, 160, 360);
5672 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5673 (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003400 &&
5674 (color & 0x000000ff) == 0x00000000,
5675 "ps_1_4 returned color 0x%08x, expected 0x00203300\n", color);
5676 color = getPixelColor(device, 480, 360);
5677 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5678 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5679 (color & 0x000000ff) == 0x00000000,
5680 "ps_2_0 returned color 0x%08x, expected 0x00203300\n", color);
5681 color = getPixelColor(device, 480, 160);
5682 ok( color == 0x00ffffff /* Nvidia driver garbage with HW vp */ || (
5683 (color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5684 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5685 (color & 0x000000ff) == 0x00000000),
5686 "fixed function fragment processing returned color 0x%08x, expected 0x00203300\n", color);
5687
5688 /* cleanup */
5689 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
5690 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
5691 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5692 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5693 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5694 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5695 if(vertexshader) IDirect3DVertexShader9_Release(vertexshader);
5696 if(ps_1_shader) IDirect3DPixelShader9_Release(ps_1_shader);
5697 if(ps_2_shader) IDirect3DPixelShader9_Release(ps_2_shader);
5698 if(ps_3_shader) IDirect3DPixelShader9_Release(ps_3_shader);
5699 if(texture) IDirect3DTexture9_Release(texture);
5700 }
5701
5702 void test_compare_instructions(IDirect3DDevice9 *device)
5703 {
5704 DWORD shader_sge_vec_code[] = {
5705 0xfffe0101, /* vs_1_1 */
5706 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5707 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5708 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5709 0x0000000d, 0xd00f0000, 0x80e40000, 0xa0e40001, /* sge oD0, r0, c1 */
5710 0x0000ffff /* end */
5711 };
5712 DWORD shader_slt_vec_code[] = {
5713 0xfffe0101, /* vs_1_1 */
5714 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5715 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5716 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5717 0x0000000c, 0xd00f0000, 0x80e40000, 0xa0e40001, /* slt oD0, r0, c1 */
5718 0x0000ffff /* end */
5719 };
5720 DWORD shader_sge_scalar_code[] = {
5721 0xfffe0101, /* vs_1_1 */
5722 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5723 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5724 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5725 0x0000000d, 0xd0010000, 0x80000000, 0xa0550001, /* slt oD0.r, r0.r, c1.b */
5726 0x0000000d, 0xd0020000, 0x80550000, 0xa0aa0001, /* slt oD0.g, r0.g, c1.r */
5727 0x0000000d, 0xd0040000, 0x80aa0000, 0xa0000001, /* slt oD0.b, r0.b, c1.g */
5728 0x0000ffff /* end */
5729 };
5730 DWORD shader_slt_scalar_code[] = {
5731 0xfffe0101, /* vs_1_1 */
5732 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5733 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5734 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5735 0x0000000c, 0xd0010000, 0x80000000, 0xa0aa0001, /* slt oD0.r, r0.r, c1.b */
5736 0x0000000c, 0xd0020000, 0x80550000, 0xa0000001, /* slt oD0.g, r0.g, c1.r */
5737 0x0000000c, 0xd0040000, 0x80aa0000, 0xa0550001, /* slt oD0.b, r0.b, c1.g */
5738 0x0000ffff /* end */
5739 };
5740 IDirect3DVertexShader9 *shader_sge_vec;
5741 IDirect3DVertexShader9 *shader_slt_vec;
5742 IDirect3DVertexShader9 *shader_sge_scalar;
5743 IDirect3DVertexShader9 *shader_slt_scalar;
5744 HRESULT hr, color;
5745 float quad1[] = {
5746 -1.0, -1.0, 0.1,
5747 0.0, -1.0, 0.1,
5748 -1.0, 0.0, 0.1,
5749 0.0, 0.0, 0.1
5750 };
5751 float quad2[] = {
5752 0.0, -1.0, 0.1,
5753 1.0, -1.0, 0.1,
5754 0.0, 0.0, 0.1,
5755 1.0, 0.0, 0.1
5756 };
5757 float quad3[] = {
5758 -1.0, 0.0, 0.1,
5759 0.0, 0.0, 0.1,
5760 -1.0, 1.0, 0.1,
5761 0.0, 1.0, 0.1
5762 };
5763 float quad4[] = {
5764 0.0, 0.0, 0.1,
5765 1.0, 0.0, 0.1,
5766 0.0, 1.0, 0.1,
5767 1.0, 1.0, 0.1
5768 };
5769 const float const0[4] = {0.8, 0.2, 0.2, 0.2};
5770 const float const1[4] = {0.2, 0.8, 0.2, 0.2};
5771
5772 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5773
5774 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_vec_code, &shader_sge_vec);
5775 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5776 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_vec_code, &shader_slt_vec);
5777 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5778 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_scalar_code, &shader_sge_scalar);
5779 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5780 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_scalar_code, &shader_slt_scalar);
5781 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5782 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5783 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5784 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, const1, 1);
5785 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5786 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5787 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
5788
5789 hr = IDirect3DDevice9_BeginScene(device);
5790 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5791 if(SUCCEEDED(hr))
5792 {
5793 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_vec);
5794 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5795 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5796 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5797
5798 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_vec);
5799 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5800 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5801 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5802
5803 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_scalar);
5804 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5805 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5806 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5807
5808 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5809 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5810
5811 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_scalar);
5812 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5813 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5814 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5815
5816 hr = IDirect3DDevice9_EndScene(device);
5817 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5818 }
5819
5820 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5821 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5822
5823 color = getPixelColor(device, 160, 360);
5824 ok(color == 0x00FF00FF, "Compare test: Quad 1(sge vec) returned color 0x%08x, expected 0x00FF00FF\n", color);
5825 color = getPixelColor(device, 480, 360);
5826 ok(color == 0x0000FF00, "Compare test: Quad 2(slt vec) returned color 0x%08x, expected 0x0000FF00\n", color);
5827 color = getPixelColor(device, 160, 120);
5828 ok(color == 0x00FFFFFF, "Compare test: Quad 3(sge scalar) returned color 0x%08x, expected 0x00FFFFFF\n", color);
5829 color = getPixelColor(device, 480, 160);
5830 ok(color == 0x000000ff, "Compare test: Quad 4(slt scalar) returned color 0x%08x, expected 0x000000ff\n", color);
5831
5832 IDirect3DVertexShader9_Release(shader_sge_vec);
5833 IDirect3DVertexShader9_Release(shader_slt_vec);
5834 IDirect3DVertexShader9_Release(shader_sge_scalar);
5835 IDirect3DVertexShader9_Release(shader_slt_scalar);
5836 }
5837
5838 void test_vshader_input(IDirect3DDevice9 *device)
5839 {
5840 DWORD swapped_shader_code_3[] = {
5841 0xfffe0300, /* vs_3_0 */
5842 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5843 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5844 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5845 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5846 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5847 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5848 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5849 0x03000002, 0xe00f0001, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5850 0x0000ffff /* end */
5851 };
5852 DWORD swapped_shader_code_1[] = {
5853 0xfffe0101, /* vs_1_1 */
5854 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5855 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5856 0x0000001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5857 0x00000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5858 0x00000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5859 0x00000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5860 0x0000ffff /* end */
5861 };
5862 DWORD swapped_shader_code_2[] = {
5863 0xfffe0200, /* vs_2_0 */
5864 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5865 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5866 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5867 0x02000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5868 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5869 0x03000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5870 0x0000ffff /* end */
5871 };
5872 DWORD texcoord_color_shader_code_3[] = {
5873 0xfffe0300, /* vs_3_0 */
5874 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5875 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5876 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5877 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5878 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5879 0x02000001, 0xe00f0001, 0x90e40001, /* mov o1, v1 */
5880 0x0000ffff /* end */
5881 };
5882 DWORD texcoord_color_shader_code_2[] = {
5883 0xfffe0200, /* vs_2_0 */
5884 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5885 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5886 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5887 0x02000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5888 0x0000ffff /* end */
5889 };
5890 DWORD texcoord_color_shader_code_1[] = {
5891 0xfffe0101, /* vs_1_1 */
5892 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5893 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5894 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5895 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5896 0x0000ffff /* end */
5897 };
5898 DWORD color_color_shader_code_3[] = {
5899 0xfffe0300, /* vs_3_0 */
5900 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5901 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5902 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5903 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5904 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5905 0x03000005, 0xe00f0001, 0xa0e40000, 0x90e40001, /* mul o1, c0, v1 */
5906 0x0000ffff /* end */
5907 };
5908 DWORD color_color_shader_code_2[] = {
5909 0xfffe0200, /* vs_2_0 */
5910 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5911 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5912 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5913 0x03000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5914 0x0000ffff /* end */
5915 };
5916 DWORD color_color_shader_code_1[] = {
5917 0xfffe0101, /* vs_1_1 */
5918 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5919 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5920 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5921 0x00000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5922 0x0000ffff /* end */
5923 };
5924 IDirect3DVertexShader9 *swapped_shader, *texcoord_color_shader, *color_color_shader;
5925 HRESULT hr;
5926 DWORD color, r, g, b;
5927 float quad1[] = {
5928 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5929 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5930 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5931 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5932 };
5933 float quad2[] = {
5934 0.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5935 1.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5936 0.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5937 1.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5938 };
5939 float quad3[] = {
5940 -1.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 0.0,
5941 0.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
5942 -1.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 1.0, 0.0,
5943 0.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0,
5944 };
5945 float quad4[] = {
5946 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5947 1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5948 0.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5949 1.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5950 };
5951 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd[] = {
5952 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5953 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5954 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5955 D3DDECL_END()
5956 };
5957 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_rightorder[] = {
5958 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5959 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5960 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5961 D3DDECL_END()
5962 };
5963 static const D3DVERTEXELEMENT9 decl_elements_onetexcrd[] = {
5964 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5965 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5966 D3DDECL_END()
5967 };
5968 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_wrongidx[] = {
5969 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5970 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5971 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
5972 D3DDECL_END()
5973 };
5974 static const D3DVERTEXELEMENT9 decl_elements_texcoord_color[] = {
5975 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5976 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5977 D3DDECL_END()
5978 };
5979 static const D3DVERTEXELEMENT9 decl_elements_color_color[] = {
5980 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5981 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5982 D3DDECL_END()
5983 };
5984 static const D3DVERTEXELEMENT9 decl_elements_color_ubyte[] = {
5985 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5986 {0, 12, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5987 D3DDECL_END()
5988 };
5989 static const D3DVERTEXELEMENT9 decl_elements_color_float[] = {
5990 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5991 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5992 D3DDECL_END()
5993 };
5994 IDirect3DVertexDeclaration9 *decl_twotexcrd, *decl_onetexcrd, *decl_twotex_wrongidx, *decl_twotexcrd_rightorder;
5995 IDirect3DVertexDeclaration9 *decl_texcoord_color, *decl_color_color, *decl_color_ubyte, *decl_color_float;
5996 unsigned int i;
5997 float normalize[4] = {1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0};
5998 float no_normalize[4] = {1.0, 1.0, 1.0, 1.0};
5999
6000 struct vertex quad1_color[] = {
6001 {-1.0, -1.0, 0.1, 0x00ff8040},
6002 { 0.0, -1.0, 0.1, 0x00ff8040},
6003 {-1.0, 0.0, 0.1, 0x00ff8040},
6004 { 0.0, 0.0, 0.1, 0x00ff8040}
6005 };
6006 struct vertex quad2_color[] = {
6007 { 0.0, -1.0, 0.1, 0x00ff8040},
6008 { 1.0, -1.0, 0.1, 0x00ff8040},
6009 { 0.0, 0.0, 0.1, 0x00ff8040},
6010 { 1.0, 0.0, 0.1, 0x00ff8040}
6011 };
6012 struct vertex quad3_color[] = {
6013 {-1.0, 0.0, 0.1, 0x00ff8040},
6014 { 0.0, 0.0, 0.1, 0x00ff8040},
6015 {-1.0, 1.0, 0.1, 0x00ff8040},
6016 { 0.0, 1.0, 0.1, 0x00ff8040}
6017 };
6018 float quad4_color[] = {
6019 0.0, 0.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6020 1.0, 0.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6021 0.0, 1.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6022 1.0, 1.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6023 };
6024
6025 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd, &decl_twotexcrd);
6026 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6027 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_onetexcrd, &decl_onetexcrd);
6028 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6029 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_wrongidx, &decl_twotex_wrongidx);
6030 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6031 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_rightorder, &decl_twotexcrd_rightorder);
6032 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6033
6034 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_texcoord_color, &decl_texcoord_color);
6035 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6036 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_color, &decl_color_color);
6037 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6038 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_ubyte, &decl_color_ubyte);
6039 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6040 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_float, &decl_color_float);
6041 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6042
6043 for(i = 1; i <= 3; i++) {
6044 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
6045 if(i == 3) {
6046 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_3, &swapped_shader);
6047 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6048 } else if(i == 2){
6049 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_2, &swapped_shader);
6050 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6051 } else if(i == 1) {
6052 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_1, &swapped_shader);
6053 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6054 }
6055
6056 hr = IDirect3DDevice9_BeginScene(device);
6057 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6058 if(SUCCEEDED(hr))
6059 {
6060 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6061 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6062
6063 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6064 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6065 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 11);
6066 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6067
6068 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6069 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6070 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 11);
6071 if(i == 3 || i == 2) {
6072 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6073 } else if(i == 1) {
6074 /* Succeeds or fails, depending on SW or HW vertex processing */
6075 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6076 }
6077
6078 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd_rightorder);
6079 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6080 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 11);
6081 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6082
6083 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotex_wrongidx);
6084 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6085 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 11);
6086 if(i == 3 || i == 2) {
6087 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6088 } else if(i == 1) {
6089 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = 1\n", hr);
6090 }
6091
6092 hr = IDirect3DDevice9_EndScene(device);
6093 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6094 }
6095
6096 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6097 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6098
6099 if(i == 3 || i == 2) {
6100 color = getPixelColor(device, 160, 360);
6101 ok(color == 0x00FFFF80 || color == 0x00FFFF7f || color == 0x00FFFF81,
6102 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6103
6104 /* The last value of the read but undefined stream is used, it is 0x00. The defined input is vec4(1, 0, 0, 0) */
6105 color = getPixelColor(device, 480, 360);
6106 ok(color == 0x00FFFF00 || color ==0x00FF0000,
6107 "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6108 color = getPixelColor(device, 160, 120);
6109 /* Same as above, accept both the last used value and 0.0 for the undefined streams */
6110 ok(color == 0x00FF0080 || color == 0x00FF007f || color == 0x00FF0081 || color == 0x00FF0000,
6111 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6112
6113 color = getPixelColor(device, 480, 160);
6114 ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6115 } else if(i == 1) {
6116 color = getPixelColor(device, 160, 360);
6117 ok(color == 0x00FFFF80 || color == 0x00FFFF7f || color == 0x00FFFF81,
6118 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6119 color = getPixelColor(device, 480, 360);
6120 /* Accept the clear color as well in this case, since SW VP returns an error */
6121 ok(color == 0x00FFFF00 || color == 0x00FF0000, "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6122 color = getPixelColor(device, 160, 120);
6123 ok(color == 0x00FF0080 || color == 0x00FF0000 || color == 0x00FF007f || color == 0x00FF0081,
6124 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6125 color = getPixelColor(device, 480, 160);
6126 ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6127 }
6128
6129 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff808080, 0.0, 0);
6130 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6131
6132 /* Now find out if the whole streams are re-read, or just the last active value for the
6133 * vertices is used.
6134 */
6135 hr = IDirect3DDevice9_BeginScene(device);
6136 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6137 if(SUCCEEDED(hr))
6138 {
6139 float quad1_modified[] = {
6140 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0,
6141 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0,
6142 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0,
6143 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0,
6144 };
6145 float quad2_modified[] = {
6146 0.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6147 1.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6148 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6149 1.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6150 };
6151
6152 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6153 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6154
6155 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6156 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6157 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 3, quad1_modified, sizeof(float) * 11);
6158 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6159
6160 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6161 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6162 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_modified, sizeof(float) * 11);
6163 if(i == 3 || i == 2) {
6164 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6165 } else if(i == 1) {
6166 /* Succeeds or fails, depending on SW or HW vertex processing */
6167 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6168 }
6169
6170 hr = IDirect3DDevice9_EndScene(device);
6171 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6172 }
6173 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6174 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6175
6176 color = getPixelColor(device, 480, 350);
6177 /* vs_1_1 may fail, accept the clear color. Some drivers also set the undefined streams to 0, accept that
6178 * as well.
6179 *
6180 * NOTE: This test fails on the reference rasterizer. In the refrast, the 4 vertices have different colors,
6181 * i.e., the whole old stream is read, and not just the last used attribute. Some games require that this
6182 * does *not* happen, otherwise they can crash because of a read from a bad pointer, so do not accept the
6183 * refrast's result.
6184 *
6185 * A test app for this behavior is Half Life 2 Episode 2 in dxlevel 95, and related games(Portal, TF2).
6186 */
6187 ok(color == 0x000000FF || color == 0x00808080 || color == 0x00000000,
6188 "Input test: Quad 2(different colors) returned color 0x%08x, expected 0x000000FF, 0x00808080 or 0x00000000\n", color);
6189 color = getPixelColor(device, 160, 120);
6190
6191 IDirect3DDevice9_SetVertexShader(device, NULL);
6192 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6193
6194 IDirect3DVertexShader9_Release(swapped_shader);
6195 }
6196
6197 for(i = 1; i <= 3; i++) {
6198 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
6199 if(i == 3) {
6200 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_3, &texcoord_color_shader);
6201 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6202 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_3, &color_color_shader);
6203 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6204 } else if(i == 2){
6205 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_2, &texcoord_color_shader);
6206 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6207 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_2, &color_color_shader);
6208 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6209 } else if(i == 1) {
6210 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_1, &texcoord_color_shader);
6211 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6212 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_1, &color_color_shader);
6213 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6214 }
6215
6216 hr = IDirect3DDevice9_BeginScene(device);
6217 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6218 if(SUCCEEDED(hr))
6219 {
6220 hr = IDirect3DDevice9_SetVertexShader(device, texcoord_color_shader);
6221 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6222 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_texcoord_color);
6223 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6224 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1_color, sizeof(quad1_color[0]));
6225 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6226
6227 hr = IDirect3DDevice9_SetVertexShader(device, color_color_shader);
6228 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6229
6230 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, normalize, 1);
6231 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6232 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_ubyte);
6233 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6234 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_color, sizeof(quad2_color[0]));
6235 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6236
6237 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, no_normalize, 1);
6238 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6239 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_color);
6240 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6241 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3_color, sizeof(quad3_color[0]));
6242 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6243
6244 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_float);
6245 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6246 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4_color, sizeof(float) * 7);
6247 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6248
6249 hr = IDirect3DDevice9_EndScene(device);
6250 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6251 }
6252 IDirect3DDevice9_SetVertexShader(device, NULL);
6253 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6254
6255 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6256 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6257
6258 color = getPixelColor(device, 160, 360);
6259 r = (color & 0x00ff0000) >> 16;
6260 g = (color & 0x0000ff00) >> 8;
6261 b = (color & 0x000000ff) >> 0;
6262 ok(r >= 0xfe && r <= 0xff && g >= 0x7f && g <= 0x81 && b >= 0x3f && b <= 0x41,
6263 "Input test: Quad 1(color-texcoord) returned color 0x%08x, expected 0x00ff8040\n", color);
6264 color = getPixelColor(device, 480, 360);
6265 r = (color & 0x00ff0000) >> 16;
6266 g = (color & 0x0000ff00) >> 8;
6267 b = (color & 0x000000ff) >> 0;
6268 ok(r >= 0x3f && r <= 0x41 && g >= 0x7f && g <= 0x81 && b >= 0xfe && b <= 0xff,
6269 "Input test: Quad 2(color-ubyte) returned color 0x%08x, expected 0x004080ff\n", color);
6270 color = getPixelColor(device, 160, 120);
6271 r = (color & 0x00ff0000) >> 16;
6272 g = (color & 0x0000ff00) >> 8;
6273 b = (color & 0x000000ff) >> 0;
6274 ok(r >= 0xfe && r <= 0xff && g >= 0x7f && g <= 0x81 && b >= 0x3f && b <= 0x41,
6275 "Input test: Quad 3(color-color) returned color 0x%08x, expected 0x00ff8040\n", color);
6276 color = getPixelColor(device, 480, 160);
6277 r = (color & 0x00ff0000) >> 16;
6278 g = (color & 0x0000ff00) >> 8;
6279 b = (color & 0x000000ff) >> 0;
6280 ok(r >= 0xfe && r <= 0xff && g >= 0xfe && g <= 0xff && b <= 0x01,
6281 "Input test: Quad 4(color-float) returned color 0x%08x, expected 0x00FFFF00\n", color);
6282
6283 IDirect3DVertexShader9_Release(texcoord_color_shader);
6284 IDirect3DVertexShader9_Release(color_color_shader);
6285 }
6286
6287 IDirect3DVertexDeclaration9_Release(decl_twotexcrd);
6288 IDirect3DVertexDeclaration9_Release(decl_onetexcrd);
6289 IDirect3DVertexDeclaration9_Release(decl_twotex_wrongidx);
6290 IDirect3DVertexDeclaration9_Release(decl_twotexcrd_rightorder);
6291
6292 IDirect3DVertexDeclaration9_Release(decl_texcoord_color);
6293 IDirect3DVertexDeclaration9_Release(decl_color_color);
6294 IDirect3DVertexDeclaration9_Release(decl_color_ubyte);
6295 IDirect3DVertexDeclaration9_Release(decl_color_float);
6296 }
6297
6298 static void srgbtexture_test(IDirect3DDevice9 *device)
6299 {
6300 /* Fill a texture with 0x7f (~ .5), and then turn on the D3DSAMP_SRGBTEXTURE
6301 * texture stage state to render a quad using that texture. The resulting
6302 * color components should be 0x36 (~ 0.21), per this formula:
6303 * linear_color = ((srgb_color + 0.055) / 1.055) ^ 2.4
6304 * This is true where srgb_color > 0.04045.
6305 */
6306 IDirect3D9 *d3d = NULL;
6307 HRESULT hr;
6308 LPDIRECT3DTEXTURE9 texture = NULL;
6309 LPDIRECT3DSURFACE9 surface = NULL;
6310 D3DLOCKED_RECT lr;
6311 DWORD color;
6312 float quad[] = {
6313 -1.0, 1.0, 0.0, 0.0, 0.0,
6314 1.0, 1.0, 0.0, 1.0, 0.0,
6315 -1.0, -1.0, 0.0, 0.0, 1.0,
6316 1.0, -1.0, 0.0, 1.0, 1.0,
6317 };
6318
6319
6320 memset(&lr, 0, sizeof(lr));
6321 IDirect3DDevice9_GetDirect3D(device, &d3d);
6322 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6323 D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_TEXTURE,
6324 D3DFMT_A8R8G8B8) != D3D_OK) {
6325 skip("D3DFMT_A8R8G8B8 textures with SRGBREAD not supported\n");
6326 goto out;
6327 }
6328
6329 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0,
6330 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
6331 &texture, NULL);
6332 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
6333 if(!texture) {
6334 skip("Failed to create A8R8G8B8 texture with SRGBREAD\n");
6335 goto out;
6336 }
6337 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
6338 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
6339
6340 fill_surface(surface, 0xff7f7f7f);
6341 IDirect3DSurface9_Release(surface);
6342
6343 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6344 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6345 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
6346 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
6347
6348 hr = IDirect3DDevice9_BeginScene(device);
6349 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
6350 if(SUCCEEDED(hr))
6351 {
6352 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, TRUE);
6353 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
6354
6355 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6356 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
6357
6358
6359 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
6360 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
6361
6362 hr = IDirect3DDevice9_EndScene(device);
6363 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
6364 }
6365
6366 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6367 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
6368 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
6369 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
6370
6371 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6372 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6373
6374 color = getPixelColor(device, 320, 240);
6375 ok(color == 0x00363636 || color == 0x00373737, "srgb quad has color %08x, expected 0x00363636\n", color);
6376
6377 out:
6378 if(texture) IDirect3DTexture9_Release(texture);
6379 IDirect3D9_Release(d3d);
6380 }
6381
6382 /* Return true if color is near the expected value */
6383 static int color_near(DWORD color, DWORD expected)
6384 {
6385 const BYTE slop = 2;
6386
6387 BYTE r, g, b;
6388 BYTE rx, gx, bx;
6389 r = (color & 0x00ff0000) >> 16;
6390 g = (color & 0x0000ff00) >> 8;
6391 b = (color & 0x000000ff);
6392 rx = (expected & 0x00ff0000) >> 16;
6393 gx = (expected & 0x0000ff00) >> 8;
6394 bx = (expected & 0x000000ff);
6395
6396 return
6397 ((r >= (rx - slop)) && (r <= (rx + slop))) &&
6398 ((g >= (gx - slop)) && (g <= (gx + slop))) &&
6399 ((b >= (bx - slop)) && (b <= (bx + slop)));
6400 }
6401
6402 static void shademode_test(IDirect3DDevice9 *device)
6403 {
6404 /* Render a quad and try all of the different fixed function shading models. */
6405 HRESULT hr;
6406 DWORD color0, color1;
6407 DWORD color0_gouraud = 0, color1_gouraud = 0;
6408 DWORD shademode = D3DSHADE_FLAT;
6409 DWORD primtype = D3DPT_TRIANGLESTRIP;
6410 LPVOID data = NULL;
6411 LPDIRECT3DVERTEXBUFFER9 vb_strip = NULL;
6412 LPDIRECT3DVERTEXBUFFER9 vb_list = NULL;
6413 UINT i, j;
6414 struct vertex quad_strip[] =
6415 {
6416 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6417 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6418 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6419 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6420 };
6421 struct vertex quad_list[] =
6422 {
6423 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6424 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6425 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6426
6427 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6428 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6429 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6430 };
6431
6432 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_strip),
6433 0, 0, D3DPOOL_MANAGED, &vb_strip, NULL);
6434 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6435 if (FAILED(hr)) goto bail;
6436
6437 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_list),
6438 0, 0, D3DPOOL_MANAGED, &vb_list, NULL);
6439 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6440 if (FAILED(hr)) goto bail;
6441
6442 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6443 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6444
6445 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6446 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
6447
6448 hr = IDirect3DVertexBuffer9_Lock(vb_strip, 0, sizeof(quad_strip), (void **) &data, 0);
6449 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
6450 memcpy(data, quad_strip, sizeof(quad_strip));
6451 hr = IDirect3DVertexBuffer9_Unlock(vb_strip);
6452 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
6453
6454 hr = IDirect3DVertexBuffer9_Lock(vb_list, 0, sizeof(quad_list), (void **) &data, 0);
6455 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
6456 memcpy(data, quad_list, sizeof(quad_list));
6457 hr = IDirect3DVertexBuffer9_Unlock(vb_list);
6458 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
6459
6460 /* Try it first with a TRIANGLESTRIP. Do it with different geometry because
6461 * the color fixups we have to do for FLAT shading will be dependent on that. */
6462 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_strip, 0, sizeof(quad_strip[0]));
6463 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6464
6465 /* First loop uses a TRIANGLESTRIP geometry, 2nd uses a TRIANGLELIST */
6466 for (j=0; j<2; j++) {
6467
6468 /* Inner loop just changes the D3DRS_SHADEMODE */
6469 for (i=0; i<3; i++) {
6470 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6471 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6472
6473 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, shademode);
6474 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6475
6476 hr = IDirect3DDevice9_BeginScene(device);
6477 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
6478 if(SUCCEEDED(hr))
6479 {
6480 hr = IDirect3DDevice9_DrawPrimitive(device, primtype, 0, 2);
6481 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed with %s\n", DXGetErrorString9(hr));
6482
6483 hr = IDirect3DDevice9_EndScene(device);
6484 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
6485 }
6486
6487 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6488 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6489
6490 /* Sample two spots from the output */
6491 color0 = getPixelColor(device, 100, 100); /* Inside first triangle */
6492 color1 = getPixelColor(device, 500, 350); /* Inside second triangle */
6493 switch(shademode) {
6494 case D3DSHADE_FLAT:
6495 /* Should take the color of the first vertex of each triangle */
6496 todo_wine ok(color0 == 0x00ff0000, "FLAT shading has color0 %08x, expected 0x00ff0000 (todo)\n", color0);
6497 todo_wine ok(color1 == 0x0000ff00, "FLAT shading has color1 %08x, expected 0x0000ff00 (todo)\n", color1);
6498 shademode = D3DSHADE_GOURAUD;
6499 break;
6500 case D3DSHADE_GOURAUD:
6501 /* Should be an interpolated blend */
6502
6503 ok(color_near(color0, 0x000dca28),
6504 "GOURAUD shading has color0 %08x, expected 0x00dca28\n", color0);
6505 ok(color_near(color1, 0x000d45c7),
6506 "GOURAUD shading has color1 %08x, expected 0x000d45c7\n", color1);
6507
6508 color0_gouraud = color0;
6509 color1_gouraud = color1;
6510
6511 shademode = D3DSHADE_PHONG;
6512 break;
6513 case D3DSHADE_PHONG:
6514 /* Should be the same as GOURAUD, since no hardware implements this */
6515 ok(color_near(color0, 0x000dca28),
6516 "PHONG shading has color0 %08x, expected 0x000dca28\n", color0);
6517 ok(color_near(color1, 0x000d45c7),
6518 "PHONG shading has color1 %08x, expected 0x000d45c7\n", color1);
6519
6520 ok(color0 == color0_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6521 color0_gouraud, color0);
6522 ok(color1 == color1_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6523 color1_gouraud, color1);
6524 break;
6525 }
6526 }
6527 /* Now, do it all over again with a TRIANGLELIST */
6528 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_list, 0, sizeof(quad_list[0]));
6529 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6530 primtype = D3DPT_TRIANGLELIST;
6531 shademode = D3DSHADE_FLAT;
6532 }
6533
6534 bail:
6535 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
6536 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6537 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
6538 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6539
6540 if (vb_strip)
6541 IDirect3DVertexBuffer9_Release(vb_strip);
6542 if (vb_list)
6543 IDirect3DVertexBuffer9_Release(vb_list);
6544 }
6545
6546
6547 static void fog_srgbwrite_test(IDirect3DDevice9 *device)
6548 {
6549 /* Draw a black quad, half fogged with white fog -> grey color. Enable sRGB writing.
6550 * if sRGB writing is applied before fogging, the 0.0 will be multiplied with ~ 12.92, so still
6551 * stay 0.0. After that the fog gives 0.5. If sRGB writing is applied after fogging, the
6552 * 0.5 will run through the alternative path(0^5 ^ 0.41666 * 1.055 - 0.055), resulting in approx.
6553 * 0.73
6554 *
6555 * At the time of this writing, wined3d could not apply sRGB correction to fixed function rendering,
6556 * so use shaders for this task
6557 */
6558 IDirect3DPixelShader9 *pshader;
6559 IDirect3DVertexShader9 *vshader;
6560 IDirect3D9 *d3d;
6561 DWORD vshader_code[] = {
6562 0xfffe0101, /* vs_1_1 */
6563 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
6564 0x00000051, 0xa00f0000, 0x3f000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0 */
6565 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
6566 0x00000001, 0xc00f0001, 0xa0000000, /* mov oFog, c0.x */
6567 0x0000ffff /* end */
6568 };
6569 DWORD pshader_code[] = {
6570 0xffff0101, /* ps_1_1 */
6571 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
6572 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
6573 0x0000ffff /* end */
6574 };
6575 const float quad[] = {
6576 -1.0, -1.0, 0.1,
6577 1.0, -1.0, 0.1,
6578 -1.0, 1.0, 0.1,
6579 1.0, 1.0, 0.1
6580 };
6581 HRESULT hr;
6582 DWORD color;
6583
6584 IDirect3DDevice9_GetDirect3D(device, &d3d);
6585 /* Ask for srgb writing on D3DRTYPE_TEXTURE. Some Windows drivers do not report it on surfaces.
6586 * For some not entirely understood reasons D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE
6587 * passes on surfaces, while asking for SRGBWRITE alone fails. Textures advertize srgb writing
6588 * alone as well, so use that since it is not the point of this test to show how CheckDeviceFormat
6589 * works
6590 */
6591 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6592 D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE,
6593 D3DRTYPE_TEXTURE, D3DFMT_A8R8G8B8) != D3D_OK) {
6594 skip("No SRGBWRITEENABLE support on D3DFMT_X8R8G8B8\n");
6595 IDirect3D9_Release(d3d);
6596 return;
6597 }
6598 IDirect3D9_Release(d3d);
6599
6600 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
6601 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6602
6603 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
6604 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6605 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
6606 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6607 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
6608 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6609 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xffffffff);
6610 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6611 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, TRUE);
6612 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6613
6614 hr = IDirect3DDevice9_CreateVertexShader(device, vshader_code, &vshader);
6615 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6616 hr = IDirect3DDevice9_CreatePixelShader(device, pshader_code, &pshader);
6617 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
6618 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
6619 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
6620 hr = IDirect3DDevice9_SetVertexShader(device, vshader);
6621 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6622 hr = IDirect3DDevice9_SetPixelShader(device, pshader);
6623 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
6624
6625 hr = IDirect3DDevice9_BeginScene(device);
6626 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6627 if(SUCCEEDED(hr)) {
6628 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 3);
6629 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6630
6631 hr = IDirect3DDevice9_EndScene(device);
6632 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6633 }
6634
6635 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
6636 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6637 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
6638 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
6639 IDirect3DPixelShader9_Release(pshader);
6640 IDirect3DVertexShader9_Release(vshader);
6641
6642 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
6643 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6644 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, FALSE);
6645 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6646
6647 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6648 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6649 color = getPixelColor(device, 160, 360);
6650 ok(color == 0x00808080 || color == 0x007f7f7f || color == 0x00818181,
6651 "Fog with D3DRS_SRGBWRITEENABLE returned color 0x%08x, expected 0x00808080\n", color);
6652 }
6653
6654 static void alpha_test(IDirect3DDevice9 *device)
6655 {
6656 HRESULT hr;
6657 IDirect3DTexture9 *offscreenTexture;
6658 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
6659 DWORD color, red, green, blue;
6660
6661 struct vertex quad1[] =
6662 {
6663 {-1.0f, -1.0f, 0.1f, 0x4000ff00},
6664 {-1.0f, 0.0f, 0.1f, 0x4000ff00},
6665 { 1.0f, -1.0f, 0.1f, 0x4000ff00},
6666 { 1.0f, 0.0f, 0.1f, 0x4000ff00},
6667 };
6668 struct vertex quad2[] =
6669 {
6670 {-1.0f, 0.0f, 0.1f, 0xc00000ff},
6671 {-1.0f, 1.0f, 0.1f, 0xc00000ff},
6672 { 1.0f, 0.0f, 0.1f, 0xc00000ff},
6673 { 1.0f, 1.0f, 0.1f, 0xc00000ff},
6674 };
6675 static const float composite_quad[][5] = {
6676 { 0.0f, -1.0f, 0.1f, 0.0f, 1.0f},
6677 { 0.0f, 1.0f, 0.1f, 0.0f, 0.0f},
6678 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f},
6679 { 1.0f, 1.0f, 0.1f, 1.0f, 0.0f},
6680 };
6681
6682 /* Clear the render target with alpha = 0.5 */
6683 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6684 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6685
6686 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
6687 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %#08x\n", hr);
6688
6689 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
6690 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
6691 if(!backbuffer) {
6692 goto out;
6693 }
6694
6695 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
6696 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
6697 if(!offscreen) {
6698 goto out;
6699 }
6700
6701 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6702 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6703
6704 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
6705 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
6706 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
6707 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
6708 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
6709 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
6710 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
6711 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
6712 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6713 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6714
6715 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
6716 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6717 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
6718
6719 /* Draw two quads, one with src alpha blending, one with dest alpha blending. */
6720 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6721 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6722 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6723 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6724 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6725 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6726
6727 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6728 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6729 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6730 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6731 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6732 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6733
6734 /* Switch to the offscreen buffer, and redo the testing. The offscreen render target
6735 * doesn't have an alpha channel. DESTALPHA and INVDESTALPHA "don't work" on render
6736 * targets without alpha channel, they give essentially ZERO and ONE blend factors. */
6737 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
6738 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6739 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6740 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6741
6742 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6743 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6744 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6745 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6746 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6747 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6748
6749 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6750 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6751 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6752 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6753 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6754 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6755
6756 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
6757 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6758
6759 /* Render the offscreen texture onto the frame buffer to be able to compare it regularly.
6760 * Disable alpha blending for the final composition
6761 */
6762 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
6763 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6764 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6765 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6766
6767 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
6768 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6769 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, composite_quad, sizeof(float) * 5);
6770 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6771 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6772 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6773
6774 hr = IDirect3DDevice9_EndScene(device);
6775 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
6776 }
6777
6778 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6779
6780 color = getPixelColor(device, 160, 360);
6781 red = (color & 0x00ff0000) >> 16;
6782 green = (color & 0x0000ff00) >> 8;
6783 blue = (color & 0x000000ff);
6784 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
6785 "SRCALPHA on frame buffer returned color %08x, expected 0x00bf4000\n", color);
6786
6787 color = getPixelColor(device, 160, 120);
6788 red = (color & 0x00ff0000) >> 16;
6789 green = (color & 0x0000ff00) >> 8;
6790 blue = (color & 0x000000ff);
6791 ok(red >= 0x7e && red <= 0x81 && green == 0x00 && blue >= 0x7e && blue <= 0x81,
6792 "DSTALPHA on frame buffer returned color %08x, expected 0x00ff0000\n", color);
6793
6794 color = getPixelColor(device, 480, 360);
6795 red = (color & 0x00ff0000) >> 16;
6796 green = (color & 0x0000ff00) >> 8;
6797 blue = (color & 0x000000ff);
6798 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
6799 "SRCALPHA on texture returned color %08x, expected bar\n", color);
6800
6801 color = getPixelColor(device, 480, 120);
6802 red = (color & 0x00ff0000) >> 16;
6803 green = (color & 0x0000ff00) >> 8;
6804 blue = (color & 0x000000ff);
6805 ok(red == 0x00 && green == 0x00 && blue >= 0xfe && blue <= 0xff ,
6806 "DSTALPHA on texture returned color %08x, expected 0x00800080\n", color);
6807
6808 out:
6809 /* restore things */
6810 if(backbuffer) {
6811 IDirect3DSurface9_Release(backbuffer);
6812 }
6813 if(offscreenTexture) {
6814 IDirect3DTexture9_Release(offscreenTexture);
6815 }
6816 if(offscreen) {
6817 IDirect3DSurface9_Release(offscreen);
6818 }
6819 }
6820
6821 struct vertex_shortcolor {
6822 float x, y, z;
6823 unsigned short r, g, b, a;
6824 };
6825 struct vertex_floatcolor {
6826 float x, y, z;
6827 float r, g, b, a;
6828 };
6829
6830 static void fixed_function_decl_test(IDirect3DDevice9 *device)
6831 {
6832 HRESULT hr;
6833 BOOL s_ok, ub_ok, f_ok;
6834 DWORD color, size, i;
6835 void *data;
6836 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor[] = {
6837 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6838 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6839 D3DDECL_END()
6840 };
6841 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor_2streams[] = {
6842 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6843 {1, 0, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6844 D3DDECL_END()
6845 };
6846 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n[] = {
6847 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6848 {0, 12, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6849 D3DDECL_END()
6850 };
6851 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n_2streams[] = {
6852 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6853 {1, 0, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6854 D3DDECL_END()
6855 };
6856 static const D3DVERTEXELEMENT9 decl_elements_short4[] = {
6857 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6858 {0, 12, D3DDECLTYPE_USHORT4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6859 D3DDECL_END()
6860 };
6861 static const D3DVERTEXELEMENT9 decl_elements_float[] = {
6862 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6863 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6864 D3DDECL_END()
6865 };
6866 static const D3DVERTEXELEMENT9 decl_elements_positiont[] = {
6867 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
6868 {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6869 D3DDECL_END()
6870 };
6871 IDirect3DVertexDeclaration9 *dcl_float = NULL, *dcl_short = NULL, *dcl_ubyte = NULL, *dcl_color = NULL;
6872 IDirect3DVertexDeclaration9 *dcl_color_2 = NULL, *dcl_ubyte_2 = NULL, *dcl_positiont;
6873 IDirect3DVertexBuffer9 *vb, *vb2;
6874 struct vertex quad1[] = /* D3DCOLOR */
6875 {
6876 {-1.0f, -1.0f, 0.1f, 0x00ffff00},
6877 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6878 { 0.0f, -1.0f, 0.1f, 0x00ffff00},
6879 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6880 };
6881 struct vertex quad2[] = /* UBYTE4N */
6882 {
6883 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6884 {-1.0f, 1.0f, 0.1f, 0x00ffff00},
6885 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6886 { 0.0f, 1.0f, 0.1f, 0x00ffff00},
6887 };
6888 struct vertex_shortcolor quad3[] = /* short */
6889 {
6890 { 0.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6891 { 0.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6892 { 1.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6893 { 1.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6894 };
6895 struct vertex_floatcolor quad4[] =
6896 {
6897 { 0.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6898 { 0.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6899 { 1.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6900 { 1.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6901 };
6902 DWORD colors[] = {
6903 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6904 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6905 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6906 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6907 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6908 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6909 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6910 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6911 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6912 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6913 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6914 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6915 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6916 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6917 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6918 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6919 };
6920 float quads[] = {
6921 -1.0, -1.0, 0.1,
6922 -1.0, 0.0, 0.1,
6923 0.0, -1.0, 0.1,
6924 0.0, 0.0, 0.1,
6925
6926 0.0, -1.0, 0.1,
6927 0.0, 0.0, 0.1,
6928 1.0, -1.0, 0.1,
6929 1.0, 0.0, 0.1,
6930
6931 0.0, 0.0, 0.1,
6932 0.0, 1.0, 0.1,
6933 1.0, 0.0, 0.1,
6934 1.0, 1.0, 0.1,
6935
6936 -1.0, 0.0, 0.1,
6937 -1.0, 1.0, 0.1,
6938 0.0, 0.0, 0.1,
6939 0.0, 1.0, 0.1
6940 };
6941 struct tvertex quad_transformed[] = {
6942 { 90, 110, 0.1, 2.0, 0x00ffff00},
6943 { 570, 110, 0.1, 2.0, 0x00ffff00},
6944 { 90, 300, 0.1, 2.0, 0x00ffff00},
6945 { 570, 300, 0.1, 2.0, 0x00ffff00}
6946 };
6947 D3DCAPS9 caps;
6948
6949 memset(&caps, 0, sizeof(caps));
6950 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
6951 ok(hr == D3D_OK, "GetDeviceCaps failed, hr = %08x\n", hr);
6952
6953 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6954 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6955
6956 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor, &dcl_color);
6957 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6958 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_short4, &dcl_short);
6959 ok(SUCCEEDED(hr) || hr == E_FAIL, "CreateVertexDeclaration failed (%08x)\n", hr);
6960 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_float, &dcl_float);
6961 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6962 if(caps.DeclTypes & D3DDTCAPS_UBYTE4N) {
6963 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n_2streams, &dcl_ubyte_2);
6964 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6965 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n, &dcl_ubyte);
6966 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6967 } else {
6968 trace("D3DDTCAPS_UBYTE4N not supported\n");
6969 dcl_ubyte_2 = NULL;
6970 dcl_ubyte = NULL;
6971 }
6972 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor_2streams, &dcl_color_2);
6973 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6974 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_positiont, &dcl_positiont);
6975 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6976
6977 size = max(sizeof(quad1), max(sizeof(quad2), max(sizeof(quad3), max(sizeof(quad4), sizeof(quads)))));
6978 hr = IDirect3DDevice9_CreateVertexBuffer(device, size,
6979 0, 0, D3DPOOL_MANAGED, &vb, NULL);
6980 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6981
6982 hr = IDirect3DDevice9_BeginScene(device);
6983 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
6984 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
6985 if(SUCCEEDED(hr)) {
6986 if(dcl_color) {
6987 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
6988 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
6989 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6990 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6991 }
6992
6993 /* Tests with non-standard fixed function types fail on the refrast. The ATI driver partially
6994 * accepts them, the nvidia driver accepts them all. All those differences even though we're
6995 * using software vertex processing. Doh!
6996 */
6997 if(dcl_ubyte) {
6998 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
6999 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7000 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
7001 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7002 ub_ok = SUCCEEDED(hr);
7003 }
7004
7005 if(dcl_short) {
7006 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7007 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7008 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(quad3[0]));
7009 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7010 s_ok = SUCCEEDED(hr);
7011 }
7012
7013 if(dcl_float) {
7014 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7015 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7016 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(quad4[0]));
7017 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7018 f_ok = SUCCEEDED(hr);
7019 }
7020
7021 hr = IDirect3DDevice9_EndScene(device);
7022 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7023 }
7024
7025 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7026 if(dcl_short) {
7027 color = getPixelColor(device, 480, 360);
7028 ok(color == 0x000000ff || !s_ok,
7029 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7030 }
7031 if(dcl_ubyte) {
7032 color = getPixelColor(device, 160, 120);
7033 ok(color == 0x0000ffff || !ub_ok,
7034 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7035 }
7036 if(dcl_color) {
7037 color = getPixelColor(device, 160, 360);
7038 ok(color == 0x00ffff00,
7039 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7040 }
7041 if(dcl_float) {
7042 color = getPixelColor(device, 480, 120);
7043 ok(color == 0x00ff0000 || !f_ok,
7044 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7045 }
7046
7047 /* The following test with vertex buffers doesn't serve to find out new information from windows.
7048 * It is a plain regression test because wined3d uses different codepaths for attribute conversion
7049 * with vertex buffers. It makes sure that the vertex buffer one works, while the above tests
7050 * whether the immediate mode code works
7051 */
7052 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7053 hr = IDirect3DDevice9_BeginScene(device);
7054 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7055 if(SUCCEEDED(hr)) {
7056 if(dcl_color) {
7057 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad1), (void **) &data, 0);
7058 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7059 memcpy(data, quad1, sizeof(quad1));
7060 hr = IDirect3DVertexBuffer9_Unlock(vb);
7061 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7062 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7063 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7064 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad1[0]));
7065 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7066 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7067 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7068 }
7069
7070 if(dcl_ubyte) {
7071 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad2), (void **) &data, 0);
7072 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7073 memcpy(data, quad2, sizeof(quad2));
7074 hr = IDirect3DVertexBuffer9_Unlock(vb);
7075 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7076 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7077 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7078 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad2[0]));
7079 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7080 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7081 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7082 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7083 ub_ok = SUCCEEDED(hr);
7084 }
7085
7086 if(dcl_short) {
7087 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad3), (void **) &data, 0);
7088 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7089 memcpy(data, quad3, sizeof(quad3));
7090 hr = IDirect3DVertexBuffer9_Unlock(vb);
7091 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7092 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7093 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7094 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad3[0]));
7095 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7096 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7097 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7098 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7099 s_ok = SUCCEEDED(hr);
7100 }
7101
7102 if(dcl_float) {
7103 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad4), (void **) &data, 0);
7104 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7105 memcpy(data, quad4, sizeof(quad4));
7106 hr = IDirect3DVertexBuffer9_Unlock(vb);
7107 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7108 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7109 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7110 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad4[0]));
7111 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7112 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7113 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7114 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7115 f_ok = SUCCEEDED(hr);
7116 }
7117
7118 hr = IDirect3DDevice9_EndScene(device);
7119 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7120 }
7121
7122 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7123 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7124 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7125 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7126
7127 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7128 if(dcl_short) {
7129 color = getPixelColor(device, 480, 360);
7130 ok(color == 0x000000ff || !s_ok,
7131 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7132 }
7133 if(dcl_ubyte) {
7134 color = getPixelColor(device, 160, 120);
7135 ok(color == 0x0000ffff || !ub_ok,
7136 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7137 }
7138 if(dcl_color) {
7139 color = getPixelColor(device, 160, 360);
7140 ok(color == 0x00ffff00,
7141 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7142 }
7143 if(dcl_float) {
7144 color = getPixelColor(device, 480, 120);
7145 ok(color == 0x00ff0000 || !f_ok,
7146 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7147 }
7148
7149 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7150 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
7151
7152 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad_transformed), (void **) &data, 0);
7153 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7154 memcpy(data, quad_transformed, sizeof(quad_transformed));
7155 hr = IDirect3DVertexBuffer9_Unlock(vb);
7156 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7157
7158 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_positiont);
7159 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7160
7161 hr = IDirect3DDevice9_BeginScene(device);
7162 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7163 if(SUCCEEDED(hr)) {
7164 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad_transformed[0]));
7165 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7166 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7167 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7168
7169 hr = IDirect3DDevice9_EndScene(device);
7170 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7171 }
7172
7173 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7174 color = getPixelColor(device, 88, 108);
7175 ok(color == 0x000000ff,
7176 "pixel 88/108 has color %08x, expected 0x000000ff\n", color);
7177 color = getPixelColor(device, 92, 108);
7178 ok(color == 0x000000ff,
7179 "pixel 92/108 has color %08x, expected 0x000000ff\n", color);
7180 color = getPixelColor(device, 88, 112);
7181 ok(color == 0x000000ff,
7182 "pixel 88/112 has color %08x, expected 0x000000ff\n", color);
7183 color = getPixelColor(device, 92, 112);
7184 ok(color == 0x00ffff00,
7185 "pixel 92/112 has color %08x, expected 0x00ffff00\n", color);
7186
7187 color = getPixelColor(device, 568, 108);
7188 ok(color == 0x000000ff,
7189 "pixel 568/108 has color %08x, expected 0x000000ff\n", color);
7190 color = getPixelColor(device, 572, 108);
7191 ok(color == 0x000000ff,
7192 "pixel 572/108 has color %08x, expected 0x000000ff\n", color);
7193 color = getPixelColor(device, 568, 112);
7194 ok(color == 0x00ffff00,
7195 "pixel 568/112 has color %08x, expected 0x00ffff00\n", color);
7196 color = getPixelColor(device, 572, 112);
7197 ok(color == 0x000000ff,
7198 "pixel 572/112 has color %08x, expected 0x000000ff\n", color);
7199
7200 color = getPixelColor(device, 88, 298);
7201 ok(color == 0x000000ff,
7202 "pixel 88/298 has color %08x, expected 0x000000ff\n", color);
7203 color = getPixelColor(device, 92, 298);
7204 ok(color == 0x00ffff00,
7205 "pixel 92/298 has color %08x, expected 0x00ffff00\n", color);
7206 color = getPixelColor(device, 88, 302);
7207 ok(color == 0x000000ff,
7208 "pixel 88/302 has color %08x, expected 0x000000ff\n", color);
7209 color = getPixelColor(device, 92, 302);
7210 ok(color == 0x000000ff,
7211 "pixel 92/302 has color %08x, expected 0x000000ff\n", color);
7212
7213 color = getPixelColor(device, 568, 298);
7214 ok(color == 0x00ffff00,
7215 "pixel 568/298 has color %08x, expected 0x00ffff00\n", color);
7216 color = getPixelColor(device, 572, 298);
7217 ok(color == 0x000000ff,
7218 "pixel 572/298 has color %08x, expected 0x000000ff\n", color);
7219 color = getPixelColor(device, 568, 302);
7220 ok(color == 0x000000ff,
7221 "pixel 568/302 has color %08x, expected 0x000000ff\n", color);
7222 color = getPixelColor(device, 572, 302);
7223 ok(color == 0x000000ff,
7224 "pixel 572/302 has color %08x, expected 0x000000ff\n", color);
7225
7226 /* This test is pointless without those two declarations: */
7227 if((!dcl_color_2) || (!dcl_ubyte_2)) {
7228 skip("color-ubyte switching test declarations aren't supported\n");
7229 goto out;
7230 }
7231
7232 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quads), (void **) &data, 0);
7233 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7234 memcpy(data, quads, sizeof(quads));
7235 hr = IDirect3DVertexBuffer9_Unlock(vb);
7236 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7237 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(colors),
7238 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
7239 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
7240 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(colors), (void **) &data, 0);
7241 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7242 memcpy(data, colors, sizeof(colors));
7243 hr = IDirect3DVertexBuffer9_Unlock(vb2);
7244 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7245
7246 for(i = 0; i < 2; i++) {
7247 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
7248 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
7249
7250 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(float) * 3);
7251 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7252 if(i == 0) {
7253 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 0, sizeof(DWORD) * 4);
7254 } else {
7255 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 8, sizeof(DWORD) * 4);
7256 }
7257 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7258
7259 hr = IDirect3DDevice9_BeginScene(device);
7260 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
7261 ub_ok = FALSE;
7262 if(SUCCEEDED(hr)) {
7263 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7264 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7265 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7266 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7267 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7268 ub_ok = SUCCEEDED(hr);
7269
7270 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color_2);
7271 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7272 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7273 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7274
7275 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7276 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7277 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7278 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7279 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7280 ub_ok = (SUCCEEDED(hr) && ub_ok);
7281
7282 hr = IDirect3DDevice9_EndScene(device);
7283 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
7284 }
7285
7286 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7287 if(i == 0) {
7288 color = getPixelColor(device, 480, 360);
7289 ok(color == 0x00ff0000,
7290 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ff0000\n", color);
7291 color = getPixelColor(device, 160, 120);
7292 ok(color == 0x00ffffff,
7293 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7294 color = getPixelColor(device, 160, 360);
7295 ok(color == 0x000000ff || !ub_ok,
7296 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7297 color = getPixelColor(device, 480, 120);
7298 ok(color == 0x000000ff || !ub_ok,
7299 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7300 } else {
7301 color = getPixelColor(device, 480, 360);
7302 ok(color == 0x000000ff,
7303 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x000000ff\n", color);
7304 color = getPixelColor(device, 160, 120);
7305 ok(color == 0x00ffffff,
7306 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7307 color = getPixelColor(device, 160, 360);
7308 ok(color == 0x00ff0000 || !ub_ok,
7309 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7310 color = getPixelColor(device, 480, 120);
7311 ok(color == 0x00ff0000 || !ub_ok,
7312 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7313 }
7314 }
7315
7316 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7317 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7318 hr = IDirect3DDevice9_SetStreamSource(device, 1, NULL, 0, 0);
7319 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7320 IDirect3DVertexBuffer9_Release(vb2);
7321
7322 out:
7323 IDirect3DVertexBuffer9_Release(vb);
7324 if(dcl_float) IDirect3DVertexDeclaration9_Release(dcl_float);
7325 if(dcl_short) IDirect3DVertexDeclaration9_Release(dcl_short);
7326 if(dcl_ubyte) IDirect3DVertexDeclaration9_Release(dcl_ubyte);
7327 if(dcl_color) IDirect3DVertexDeclaration9_Release(dcl_color);
7328 if(dcl_color_2) IDirect3DVertexDeclaration9_Release(dcl_color_2);
7329 if(dcl_ubyte_2) IDirect3DVertexDeclaration9_Release(dcl_ubyte_2);
7330 if(dcl_positiont) IDirect3DVertexDeclaration9_Release(dcl_positiont);
7331 }
7332
7333 struct vertex_float16color {
7334 float x, y, z;
7335 DWORD c1, c2;
7336 };
7337
7338 static void test_vshader_float16(IDirect3DDevice9 *device)
7339 {
7340 HRESULT hr;
7341 DWORD color;
7342 void *data;
7343 static const D3DVERTEXELEMENT9 decl_elements[] = {
7344 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7345 {0, 12, D3DDECLTYPE_FLOAT16_4,D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
7346 D3DDECL_END()
7347 };
7348 IDirect3DVertexDeclaration9 *vdecl = NULL;
7349 IDirect3DVertexBuffer9 *buffer = NULL;
7350 IDirect3DVertexShader9 *shader;
7351 DWORD shader_code[] = {
7352 0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000001f, 0x8000000a,
7353 0x900f0001, 0x00000001, 0xc00f0000, 0x90e40000, 0x00000001, 0xd00f0000,
7354 0x90e40001, 0x0000ffff
7355 };
7356 struct vertex_float16color quad[] = {
7357 { -1.0, -1.0, 0.1, 0x3c000000, 0x00000000 }, /* green */
7358 { -1.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7359 { 0.0, -1.0, 0.1, 0x3c000000, 0x00000000 },
7360 { 0.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7361
7362 { 0.0, -1.0, 0.1, 0x00003c00, 0x00000000 }, /* red */
7363 { 0.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7364 { 1.0, -1.0, 0.1, 0x00003c00, 0x00000000 },
7365 { 1.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7366
7367 { 0.0, 0.0, 0.1, 0x00000000, 0x00003c00 }, /* blue */
7368 { 0.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7369 { 1.0, 0.0, 0.1, 0x00000000, 0x00003c00 },
7370 { 1.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7371
7372 { -1.0, 0.0, 0.1, 0x00000000, 0x3c000000 }, /* alpha */
7373 { -1.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7374 { 0.0, 0.0, 0.1, 0x00000000, 0x3c000000 },
7375 { 0.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7376 };
7377
7378 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7379 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7380
7381 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vdecl);
7382 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%s\n", DXGetErrorString9(hr));
7383 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
7384 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7385 hr = IDirect3DDevice9_SetVertexShader(device, shader);
7386 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7387
7388 hr = IDirect3DDevice9_BeginScene(device);
7389 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7390 if(SUCCEEDED(hr)) {
7391 hr = IDirect3DDevice9_SetVertexDeclaration(device, vdecl);
7392 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7393 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 0, sizeof(quad[0]));
7394 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7395 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 4, sizeof(quad[0]));
7396 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7397 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 8, sizeof(quad[0]));
7398 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7399 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 12, sizeof(quad[0]));
7400 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7401
7402 hr = IDirect3DDevice9_EndScene(device);
7403 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
7404 }
7405 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7406 color = getPixelColor(device, 480, 360);
7407 ok(color == 0x00ff0000,
7408 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7409 color = getPixelColor(device, 160, 120);
7410 ok(color == 0x00000000,
7411 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7412 color = getPixelColor(device, 160, 360);
7413 ok(color == 0x0000ff00,
7414 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7415 color = getPixelColor(device, 480, 120);
7416 ok(color == 0x000000ff,
7417 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7418
7419 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7420 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7421
7422 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0,
7423 D3DPOOL_MANAGED, &buffer, NULL);
7424 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexBuffer failed, hr=%s\n", DXGetErrorString9(hr));
7425 hr = IDirect3DVertexBuffer9_Lock(buffer, 0, sizeof(quad), (void **) &data, 0);
7426 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed, hr=%s\n", DXGetErrorString9(hr));
7427 memcpy(data, quad, sizeof(quad));
7428 hr = IDirect3DVertexBuffer9_Unlock(buffer);
7429 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed, hr=%s\n", DXGetErrorString9(hr));
7430 hr = IDirect3DDevice9_SetStreamSource(device, 0, buffer, 0, sizeof(quad[0]));
7431 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%s\n", DXGetErrorString9(hr));
7432
7433 hr = IDirect3DDevice9_BeginScene(device);
7434 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7435 if(SUCCEEDED(hr)) {
7436 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7437 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7438 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7439 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7440 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7441 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7442 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 12, 2);
7443 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7444
7445 hr = IDirect3DDevice9_EndScene(device);
7446 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
7447 }
7448
7449 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7450 color = getPixelColor(device, 480, 360);
7451 ok(color == 0x00ff0000,
7452 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7453 color = getPixelColor(device, 160, 120);
7454 ok(color == 0x00000000,
7455 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7456 color = getPixelColor(device, 160, 360);
7457 ok(color == 0x0000ff00,
7458 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7459 color = getPixelColor(device, 480, 120);
7460 ok(color == 0x000000ff,
7461 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7462
7463 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7464 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%s\n", DXGetErrorString9(hr));
7465 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7466 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7467 IDirect3DDevice9_SetVertexShader(device, NULL);
7468 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7469
7470 IDirect3DVertexDeclaration9_Release(vdecl);
7471 IDirect3DVertexShader9_Release(shader);
7472 IDirect3DVertexBuffer9_Release(buffer);
7473 }
7474
7475 static void conditional_np2_repeat_test(IDirect3DDevice9 *device)
7476 {
7477 D3DCAPS9 caps;
7478 IDirect3DTexture9 *texture;
7479 HRESULT hr;
7480 D3DLOCKED_RECT rect;
7481 unsigned int x, y;
7482 DWORD *dst, color;
7483 const float quad[] = {
7484 -1.0, -1.0, 0.1, -0.2, -0.2,
7485 1.0, -1.0, 0.1, 1.2, -0.2,
7486 -1.0, 1.0, 0.1, -0.2, 1.2,
7487 1.0, 1.0, 0.1, 1.2, 1.2
7488 };
7489 memset(&caps, 0, sizeof(caps));
7490
7491 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7492 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
7493 if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7494 /* NP2 conditional requires the POW2 flag. Check that while we're at it */
7495 ok((caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) == 0,
7496 "Card has conditional NP2 support without power of two restriction set\n");
7497 skip("Card has unconditional pow2 support, skipping conditional NP2 tests\n");
7498 return;
7499 } else if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7500 skip("No conditional NP2 support, skipping conditional NP2 tests\n");
7501 return;
7502 }
7503
7504 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
7505 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7506
7507 hr = IDirect3DDevice9_CreateTexture(device, 10, 10, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
7508 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%s\n", DXGetErrorString9(hr));
7509
7510 memset(&rect, 0, sizeof(rect));
7511 hr = IDirect3DTexture9_LockRect(texture, 0, &rect, NULL, 0);
7512 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed hr=%s\n", DXGetErrorString9(hr));
7513 for(y = 0; y < 10; y++) {
7514 for(x = 0; x < 10; x++) {
7515 dst = (DWORD *) ((BYTE *) rect.pBits + y * rect.Pitch + x * sizeof(DWORD));
7516 if(x == 0 || x == 9 || y == 0 || y == 9) {
7517 *dst = 0x00ff0000;
7518 } else {
7519 *dst = 0x000000ff;
7520 }
7521 }
7522 }
7523 hr = IDirect3DTexture9_UnlockRect(texture, 0);
7524 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed hr=%s\n", DXGetErrorString9(hr));
7525
7526 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7527 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%s\n", DXGetErrorString9(hr));
7528 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
7529 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%s\n", DXGetErrorString9(hr));
7530 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
7531 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%s\n", DXGetErrorString9(hr));
7532 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7533 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7534
7535 hr = IDirect3DDevice9_BeginScene(device);
7536 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7537 if(SUCCEEDED(hr)) {
7538 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
7539 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7540
7541 hr = IDirect3DDevice9_EndScene(device);
7542 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
7543 }
7544
7545 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7546
7547 color = getPixelColor(device, 1, 1);
7548 ok(color == 0x00ff0000, "NP2: Pixel 1, 1 has color %08x, expected 0x00ff0000\n", color);
7549 color = getPixelColor(device, 639, 479);
7550 ok(color == 0x00ff0000, "NP2: Pixel 639, 479 has color %08x, expected 0x00ff0000\n", color);
7551
7552 color = getPixelColor(device, 135, 101);
7553 ok(color == 0x00ff0000, "NP2: Pixel 135, 101 has color %08x, expected 0x00ff0000\n", color);
7554 color = getPixelColor(device, 140, 101);
7555 ok(color == 0x00ff0000, "NP2: Pixel 140, 101 has color %08x, expected 0x00ff0000\n", color);
7556 color = getPixelColor(device, 135, 105);
7557 ok(color == 0x00ff0000, "NP2: Pixel 135, 105 has color %08x, expected 0x00ff0000\n", color);
7558 color = getPixelColor(device, 140, 105);
7559 ok(color == 0x000000ff, "NP2: Pixel 140, 105 has color %08x, expected 0x000000ff\n", color);
7560
7561 color = getPixelColor(device, 135, 376);
7562 ok(color == 0x00ff0000, "NP2: Pixel 135, 376 has color %08x, expected 0x00ff0000\n", color);
7563 color = getPixelColor(device, 140, 376);
7564 ok(color == 0x000000ff, "NP2: Pixel 140, 376 has color %08x, expected 0x000000ff\n", color);
7565 color = getPixelColor(device, 135, 379);
7566 ok(color == 0x00ff0000, "NP2: Pixel 135, 379 has color %08x, expected 0x00ff0000\n", color);
7567 color = getPixelColor(device, 140, 379);
7568 ok(color == 0x00ff0000, "NP2: Pixel 140, 379 has color %08x, expected 0x00ff0000\n", color);
7569
7570 color = getPixelColor(device, 500, 101);
7571 ok(color == 0x00ff0000, "NP2: Pixel 500, 101 has color %08x, expected 0x00ff0000\n", color);
7572 color = getPixelColor(device, 504, 101);
7573 ok(color == 0x00ff0000, "NP2: Pixel 504, 101 has color %08x, expected 0x00ff0000\n", color);
7574 color = getPixelColor(device, 500, 105);
7575 ok(color == 0x000000ff, "NP2: Pixel 500, 105 has color %08x, expected 0x000000ff\n", color);
7576 color = getPixelColor(device, 504, 105);
7577 ok(color == 0x00ff0000, "NP2: Pixel 504, 105 has color %08x, expected 0x00ff0000\n", color);
7578
7579 color = getPixelColor(device, 500, 376);
7580 ok(color == 0x000000ff, "NP2: Pixel 500, 376 has color %08x, expected 0x000000ff\n", color);
7581 color = getPixelColor(device, 504, 376);
7582 ok(color == 0x00ff0000, "NP2: Pixel 504, 376 has color %08x, expected 0x00ff0000\n", color);
7583 color = getPixelColor(device, 500, 380);
7584 ok(color == 0x00ff0000, "NP2: Pixel 500, 380 has color %08x, expected 0x00ff0000\n", color);
7585 color = getPixelColor(device, 504, 380);
7586 ok(color == 0x00ff0000, "NP2: Pixel 504, 380 has color %08x, expected 0x00ff0000\n", color);
7587
7588 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7589 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%s\n", DXGetErrorString9(hr));
7590 IDirect3DTexture9_Release(texture);
7591 }
7592
7593 static void vFace_register_test(IDirect3DDevice9 *device)
7594 {
7595 HRESULT hr;
7596 DWORD color;
7597 const DWORD shader_code[] = {
7598 0xffff0300, /* ps_3_0 */
7599 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0.0, 1.0, 0.0, 0.0 */
7600 0x05000051, 0xa00f0001, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1.0, 0.0, 0.0, 0.0 */
7601 0x0200001f, 0x80000000, 0x900f1001, /* dcl vFace */
7602 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
7603 0x04000058, 0x800f0000, 0x90e41001, 0xa0e40000, 0x80e40001, /* cmp r0, vFace, c0, r1 */
7604 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
7605 0x0000ffff /* END */
7606 };
7607 IDirect3DPixelShader9 *shader;
7608 IDirect3DTexture9 *texture;
7609 IDirect3DSurface9 *surface, *backbuffer;
7610 const float quad[] = {
7611 -1.0, -1.0, 0.1,
7612 1.0, -1.0, 0.1,
7613 -1.0, 0.0, 0.1,
7614
7615 1.0, -1.0, 0.1,
7616 1.0, 0.0, 0.1,
7617 -1.0, 0.0, 0.1,
7618
7619 -1.0, 0.0, 0.1,
7620 -1.0, 1.0, 0.1,
7621 1.0, 0.0, 0.1,
7622
7623 1.0, 0.0, 0.1,
7624 -1.0, 1.0, 0.1,
7625 1.0, 1.0, 0.1,
7626 };
7627 const float blit[] = {
7628 0.0, -1.0, 0.1, 0.0, 0.0,
7629 1.0, -1.0, 0.1, 1.0, 0.0,
7630 0.0, 1.0, 0.1, 0.0, 1.0,
7631 1.0, 1.0, 0.1, 1.0, 1.0,
7632 };
7633
7634 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
7635 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
7636 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
7637 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%s\n", DXGetErrorString9(hr));
7638 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
7639 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed hr=%s\n", DXGetErrorString9(hr));
7640 hr = IDirect3DDevice9_SetPixelShader(device, shader);
7641 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
7642 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7643 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
7644 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
7645 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%s\n", DXGetErrorString9(hr));
7646
7647 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7648 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7649
7650 hr = IDirect3DDevice9_BeginScene(device);
7651 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7652 if(SUCCEEDED(hr)) {
7653 /* First, draw to the texture and the back buffer to test both offscreen and onscreen cases */
7654 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
7655 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
7656 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7657 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7658 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7659 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7660 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
7661 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
7662 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7663 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7664
7665 /* Blit the texture onto the back buffer to make it visible */
7666 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
7667 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
7668 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7669 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
7670 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7671 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%s\n", DXGetErrorString9(hr));
7672 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7673 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%s\n", DXGetErrorString9(hr));
7674 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7675 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
7676
7677 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, blit, sizeof(float) * 5);
7678 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7679
7680 hr = IDirect3DDevice9_EndScene(device);
7681 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
7682 }
7683
7684 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7685 color = getPixelColor(device, 160, 360);
7686 ok(color == 0x00ff0000, "vFace: Onscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7687 color = getPixelColor(device, 160, 120);
7688 ok(color == 0x0000ff00, "vFace: Onscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7689 color = getPixelColor(device, 480, 360);
7690 ok(color == 0x0000ff00, "vFace: Offscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7691 color = getPixelColor(device, 480, 120);
7692 ok(color == 0x00ff0000, "vFace: Offscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7693
7694 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
7695 IDirect3DDevice9_SetTexture(device, 0, NULL);
7696 IDirect3DPixelShader9_Release(shader);
7697 IDirect3DSurface9_Release(surface);
7698 IDirect3DSurface9_Release(backbuffer);
7699 IDirect3DTexture9_Release(texture);
7700 }
7701
7702 static void fixed_function_bumpmap_test(IDirect3DDevice9 *device)
7703 {
7704 HRESULT hr;
7705 DWORD color;
7706 int i;
7707 D3DCAPS9 caps;
7708
7709 static const float quad[][7] = {
7710 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
7711 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
7712 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
7713 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
7714 };
7715
7716 static const D3DVERTEXELEMENT9 decl_elements[] = {
7717 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7718 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
7719 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
7720 D3DDECL_END()
7721 };
7722
7723 /* use asymmetric matrix to test loading */
7724 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
7725
7726 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
7727 IDirect3DTexture9 *texture = NULL;
7728
7729 memset(&caps, 0, sizeof(caps));
7730 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7731 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
7732 if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)) {
7733 skip("D3DTEXOPCAPS_BUMPENVMAP not set, skipping bumpmap tests\n");
7734 return;
7735 } else {
7736 /* This check is disabled, some Windows drivers do not handle D3DUSAGE_QUERY_LEGACYBUMPMAP properly.
7737 * They report that it is not supported, but after that bump mapping works properly. So just test
7738 * if the format is generally supported, and check the BUMPENVMAP flag
7739 */
7740 IDirect3D9 *d3d9;
7741
7742 IDirect3DDevice9_GetDirect3D(device, &d3d9);
7743 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7744 D3DRTYPE_TEXTURE, D3DFMT_V8U8);
7745 IDirect3D9_Release(d3d9);
7746 if(FAILED(hr)) {
7747 skip("D3DFMT_V8U8 not supported for legacy bump mapping\n");
7748 return;
7749 }
7750 }
7751
7752 /* Generate the textures */
7753 generate_bumpmap_textures(device);
7754
7755 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
7756 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7757 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
7758 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7759 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
7760 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7761 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
7762 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7763
7764 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAP);
7765 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7766 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
7767 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7768 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
7769 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7770
7771 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7772 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7773 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7774 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7775 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
7776 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7777
7778 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
7779 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7780
7781 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
7782 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
7783
7784 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
7785 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
7786
7787
7788 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
7789 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
7790 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
7791 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
7792
7793 hr = IDirect3DDevice9_BeginScene(device);
7794 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7795
7796 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7797 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7798
7799 hr = IDirect3DDevice9_EndScene(device);
7800 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7801
7802 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7803 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7804
7805 color = getPixelColor(device, 320-32, 240);
7806 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7807 color = getPixelColor(device, 320+32, 240);
7808 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7809 color = getPixelColor(device, 320, 240-32);
7810 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7811 color = getPixelColor(device, 320, 240+32);
7812 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7813 color = getPixelColor(device, 320, 240);
7814 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7815 color = getPixelColor(device, 320+32, 240+32);
7816 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7817 color = getPixelColor(device, 320-32, 240+32);
7818 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7819 color = getPixelColor(device, 320+32, 240-32);
7820 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7821 color = getPixelColor(device, 320-32, 240-32);
7822 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7823
7824 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7825 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
7826 IDirect3DVertexDeclaration9_Release(vertex_declaration);
7827
7828 for(i = 0; i < 2; i++) {
7829 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
7830 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
7831 IDirect3DTexture9_Release(texture); /* For the GetTexture */
7832 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
7833 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
7834 IDirect3DTexture9_Release(texture); /* To destroy it */
7835 }
7836
7837 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
7838 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7839 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
7840 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7841
7842 }
7843
7844 static void stencil_cull_test(IDirect3DDevice9 *device) {
7845 HRESULT hr;
7846 IDirect3DSurface9 *depthstencil = NULL;
7847 D3DSURFACE_DESC desc;
7848 float quad1[] = {
7849 -1.0, -1.0, 0.1,
7850 0.0, -1.0, 0.1,
7851 -1.0, 0.0, 0.1,
7852 0.0, 0.0, 0.1,
7853 };
7854 float quad2[] = {
7855 0.0, -1.0, 0.1,
7856 1.0, -1.0, 0.1,
7857 0.0, 0.0, 0.1,
7858 1.0, 0.0, 0.1,
7859 };
7860 float quad3[] = {
7861 0.0, 0.0, 0.1,
7862 1.0, 0.0, 0.1,
7863 0.0, 1.0, 0.1,
7864 1.0, 1.0, 0.1,
7865 };
7866 float quad4[] = {
7867 -1.0, 0.0, 0.1,
7868 0.0, 0.0, 0.1,
7869 -1.0, 1.0, 0.1,
7870 0.0, 1.0, 0.1,
7871 };
7872 struct vertex painter[] = {
7873 {-1.0, -1.0, 0.0, 0x00000000},
7874 { 1.0, -1.0, 0.0, 0x00000000},
7875 {-1.0, 1.0, 0.0, 0x00000000},
7876 { 1.0, 1.0, 0.0, 0x00000000},
7877 };
7878 WORD indices_cw[] = {0, 1, 3};
7879 WORD indices_ccw[] = {0, 2, 3};
7880 unsigned int i;
7881 DWORD color;
7882
7883 IDirect3DDevice9_GetDepthStencilSurface(device, &depthstencil);
7884 if(depthstencil == NULL) {
7885 skip("No depth stencil buffer\n");
7886 return;
7887 }
7888 hr = IDirect3DSurface9_GetDesc(depthstencil, &desc);
7889 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %s\n", DXGetErrorString9(hr));
7890 IDirect3DSurface9_Release(depthstencil);
7891 if(desc.Format != D3DFMT_D24S8 && desc.Format != D3DFMT_D24X4S4) {
7892 skip("No 4 or 8 bit stencil surface\n");
7893 return;
7894 }
7895
7896 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, 0x00ff0000, 0.0, 0x8);
7897 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
7898 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7899
7900 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_INCR);
7901 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7902 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
7903 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7904 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
7905 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7906 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, 0x3);
7907 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7908
7909 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_REPLACE);
7910 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7911 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR);
7912 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7913 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILPASS, D3DSTENCILOP_INCR);
7914 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7915
7916 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, TRUE);
7917 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7918 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
7919 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7920
7921 /* First pass: Fill the stencil buffer with some values... */
7922 hr = IDirect3DDevice9_BeginScene(device);
7923 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
7924 if(SUCCEEDED(hr))
7925 {
7926 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
7927 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7928 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7929 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
7930 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7931 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
7932
7933 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, TRUE);
7934 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7935 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
7936 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7937 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7938 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
7939 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7940 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
7941
7942 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
7943 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7944 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7945 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
7946 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7947 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
7948
7949 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CCW);
7950 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7951 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7952 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
7953 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7954 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
7955
7956 hr = IDirect3DDevice9_EndScene(device);
7957 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
7958 }
7959
7960 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7961 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
7962 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7963 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
7964 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7965 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
7966 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7967 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
7968 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7969 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
7970 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7971 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFUNC, D3DCMP_EQUAL);
7972 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7973
7974 /* 2nd pass: Make the stencil values visible */
7975 hr = IDirect3DDevice9_BeginScene(device);
7976 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
7977 if(SUCCEEDED(hr))
7978 {
7979 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
7980 for(i = 0; i < 16; i++) {
7981 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, i);
7982 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7983
7984 painter[0].diffuse = (i * 16); /* Creates shades of blue */
7985 painter[1].diffuse = (i * 16);
7986 painter[2].diffuse = (i * 16);
7987 painter[3].diffuse = (i * 16);
7988 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, painter, sizeof(painter[0]));
7989 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
7990 }
7991 hr = IDirect3DDevice9_EndScene(device);
7992 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
7993 }
7994
7995 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7996 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
7997
7998 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
7999 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
8000
8001 color = getPixelColor(device, 160, 420);
8002 ok(color == 0x00000030, "CCW triangle, twoside FALSE, cull cw, replace, has color 0x%08x, expected 0x00000030\n", color);
8003 color = getPixelColor(device, 160, 300);
8004 ok(color == 0x00000080, "CW triangle, twoside FALSE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8005
8006 color = getPixelColor(device, 480, 420);
8007 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull off, incr, has color 0x%08x, expected 0x00000090\n", color);
8008 color = getPixelColor(device, 480, 300);
8009 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull off, replace, has color 0x%08x, expected 0x00000030\n", color);
8010
8011 color = getPixelColor(device, 160, 180);
8012 ok(color == 0x00000080, "CCW triangle, twoside TRUE, cull ccw, culled, has color 0x%08x, expected 0x00000080\n", color);
8013 color = getPixelColor(device, 160, 60);
8014 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull ccw, replace, has color 0x%08x, expected 0x00000030\n", color);
8015
8016 color = getPixelColor(device, 480, 180);
8017 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull cw, incr, has color 0x%08x, expected 0x00000090\n", color);
8018 color = getPixelColor(device, 480, 60);
8019 ok(color == 0x00000080, "CW triangle, twoside TRUE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8020 }
8021
8022 static void vpos_register_test(IDirect3DDevice9 *device)
8023 {
8024 HRESULT hr;
8025 DWORD color;
8026 const DWORD shader_code[] = {
8027 0xffff0300, /* ps_3_0 */
8028 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8029 0x03000002, 0x80030000, 0x90541000, 0xa1fe0000, /* sub r0.xy, vPos.xy, c0.zw */
8030 0x02000001, 0x800f0001, 0xa0e40000, /* mov r1, c0 */
8031 0x02000001, 0x80080002, 0xa0550000, /* mov r2.a, c0.y */
8032 0x02000001, 0x80010002, 0xa0550000, /* mov r2.r, c0.y */
8033 0x04000058, 0x80020002, 0x80000000, 0x80000001, 0x80550001, /* cmp r2.g, r0.x, r1.x, r1.y */
8034 0x04000058, 0x80040002, 0x80550000, 0x80000001, 0x80550001, /* cmp r2.b, r0.y, r1.x, r1.y */
8035 0x02000001, 0x800f0800, 0x80e40002, /* mov oC0, r2 */
8036 0x0000ffff /* end */
8037 };
8038 const DWORD shader_frac_code[] = {
8039 0xffff0300, /* ps_3_0 */
8040 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
8041 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8042 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
8043 0x02000013, 0x80030000, 0x90541000, /* frc r0.xy, vPos.xy */
8044 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
8045 0x0000ffff /* end */
8046 };
8047 IDirect3DPixelShader9 *shader, *shader_frac;
8048 IDirect3DSurface9 *surface = NULL, *backbuffer;
8049 const float quad[] = {
8050 -1.0, -1.0, 0.1, 0.0, 0.0,
8051 1.0, -1.0, 0.1, 1.0, 0.0,
8052 -1.0, 1.0, 0.1, 0.0, 1.0,
8053 1.0, 1.0, 0.1, 1.0, 1.0,
8054 };
8055 D3DLOCKED_RECT lr;
8056 float constant[4] = {1.0, 0.0, 320, 240};
8057 DWORD *pos;
8058
8059 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8060 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8061 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
8062 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
8063 hr = IDirect3DDevice9_CreatePixelShader(device, shader_frac_code, &shader_frac);
8064 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
8065 hr = IDirect3DDevice9_SetPixelShader(device, shader);
8066 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8067 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8068 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
8069 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8070 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%s\n", DXGetErrorString9(hr));
8071
8072 hr = IDirect3DDevice9_BeginScene(device);
8073 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8074 if(SUCCEEDED(hr)) {
8075 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8076 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%s\n", DXGetErrorString9(hr));
8077 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8078 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8079 hr = IDirect3DDevice9_EndScene(device);
8080 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8081 }
8082
8083 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8084 /* This has to be pixel exact */
8085 color = getPixelColor(device, 319, 239);
8086 ok(color == 0x00000000, "vPos: Pixel 319,239 has color 0x%08x, expected 0x00000000\n", color);
8087 color = getPixelColor(device, 320, 239);
8088 ok(color == 0x0000ff00, "vPos: Pixel 320,239 has color 0x%08x, expected 0x0000ff00\n", color);
8089 color = getPixelColor(device, 319, 240);
8090 ok(color == 0x000000ff, "vPos: Pixel 319,240 has color 0x%08x, expected 0x000000ff\n", color);
8091 color = getPixelColor(device, 320, 240);
8092 ok(color == 0x0000ffff, "vPos: Pixel 320,240 has color 0x%08x, expected 0x0000ffff\n", color);
8093
8094 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_X8R8G8B8, 0, 0, TRUE,
8095 &surface, NULL);
8096 ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget failed hr=%s\n", DXGetErrorString9(hr));
8097 hr = IDirect3DDevice9_BeginScene(device);
8098 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8099 if(SUCCEEDED(hr)) {
8100 constant[2] = 16; constant[3] = 16;
8101 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8102 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%s\n", DXGetErrorString9(hr));
8103 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
8104 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8105 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8106 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8107 hr = IDirect3DDevice9_EndScene(device);
8108 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8109 }
8110 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8111 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%s\n", DXGetErrorString9(hr));
8112
8113 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8114 color = *pos & 0x00ffffff;
8115 ok(color == 0x00000000, "Pixel 14/14 has color 0x%08x, expected 0x00000000\n", color);
8116 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 18 * sizeof(DWORD));
8117 color = *pos & 0x00ffffff;
8118 ok(color == 0x0000ff00, "Pixel 14/18 has color 0x%08x, expected 0x0000ff00\n", color);
8119 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 14 * sizeof(DWORD));
8120 color = *pos & 0x00ffffff;
8121 ok(color == 0x000000ff, "Pixel 18/14 has color 0x%08x, expected 0x000000ff\n", color);
8122 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 18 * sizeof(DWORD));
8123 color = *pos & 0x00ffffff;
8124 ok(color == 0x0000ffff, "Pixel 18/18 has color 0x%08x, expected 0x0000ffff\n", color);
8125
8126 hr = IDirect3DSurface9_UnlockRect(surface);
8127 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%s\n", DXGetErrorString9(hr));
8128
8129 /* Test the fraction value of vPos. This is tested with the offscreen target and not the backbuffer to
8130 * have full control over the multisampling setting inside this test
8131 */
8132 hr = IDirect3DDevice9_SetPixelShader(device, shader_frac);
8133 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8134 hr = IDirect3DDevice9_BeginScene(device);
8135 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8136 if(SUCCEEDED(hr)) {
8137 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8138 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8139 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8140 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8141 hr = IDirect3DDevice9_EndScene(device);
8142 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8143 }
8144 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8145 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8146
8147 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8148 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%s\n", DXGetErrorString9(hr));
8149
8150 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8151 color = *pos & 0x00ffffff;
8152 ok(color == 0x00000000, "vPos fraction test has color 0x%08x, expected 0x00000000\n", color);
8153
8154 hr = IDirect3DSurface9_UnlockRect(surface);
8155 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%s\n", DXGetErrorString9(hr));
8156
8157 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8158 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8159 IDirect3DPixelShader9_Release(shader);
8160 IDirect3DPixelShader9_Release(shader_frac);
8161 if(surface) IDirect3DSurface9_Release(surface);
8162 IDirect3DSurface9_Release(backbuffer);
8163 }
8164
8165 static void pointsize_test(IDirect3DDevice9 *device)
8166 {
8167 HRESULT hr;
8168 D3DCAPS9 caps;
8169 D3DMATRIX matrix;
8170 D3DMATRIX identity;
8171 float ptsize, ptsize_orig;
8172 DWORD color;
8173
8174 const float vertices[] = {
8175 64, 64, 0.1,
8176 128, 64, 0.1,
8177 192, 64, 0.1,
8178 256, 64, 0.1,
8179 320, 64, 0.1,
8180 384, 64, 0.1
8181 };
8182
8183 /* Transforms the coordinate system [-1.0;1.0]x[-1.0;1.0] to [0.0;0.0]x[640.0;480.0]. Z is untouched */
8184 U(matrix).m[0][0] = 2.0/640.0; U(matrix).m[1][0] = 0.0; U(matrix).m[2][0] = 0.0; U(matrix).m[3][0] =-1.0;
8185 U(matrix).m[0][1] = 0.0; U(matrix).m[1][1] =-2.0/480.0; U(matrix).m[2][1] = 0.0; U(matrix).m[3][1] = 1.0;
8186 U(matrix).m[0][2] = 0.0; U(matrix).m[1][2] = 0.0; U(matrix).m[2][2] = 1.0; U(matrix).m[3][2] = 0.0;
8187 U(matrix).m[0][3] = 0.0; U(matrix).m[1][3] = 0.0; U(matrix).m[2][3] = 0.0; U(matrix).m[3][3] = 1.0;
8188
8189 U(identity).m[0][0] = 1.0; U(identity).m[1][0] = 0.0; U(identity).m[2][0] = 0.0; U(identity).m[3][0] = 0.0;
8190 U(identity).m[0][1] = 0.0; U(identity).m[1][1] = 1.0; U(identity).m[2][1] = 0.0; U(identity).m[3][1] = 0.0;
8191 U(identity).m[0][2] = 0.0; U(identity).m[1][2] = 0.0; U(identity).m[2][2] = 1.0; U(identity).m[3][2] = 0.0;
8192 U(identity).m[0][3] = 0.0; U(identity).m[1][3] = 0.0; U(identity).m[2][3] = 0.0; U(identity).m[3][3] = 1.0;
8193
8194 memset(&caps, 0, sizeof(caps));
8195 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8196 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
8197 if(caps.MaxPointSize < 32.0) {
8198 skip("MaxPointSize < 32.0, skipping(MaxPointsize = %f)\n", caps.MaxPointSize);
8199 return;
8200 }
8201
8202 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 0.0, 0);
8203 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8204 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &matrix);
8205 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%s\n", DXGetErrorString9(hr));
8206 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8207 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
8208 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE, (DWORD *) &ptsize_orig);
8209 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed hr=%s\n", DXGetErrorString9(hr));
8210
8211 hr = IDirect3DDevice9_BeginScene(device);
8212 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8213 if(SUCCEEDED(hr)) {
8214 ptsize = 16.0;
8215 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8216 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8217 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[0], sizeof(float) * 3);
8218 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8219
8220 ptsize = 32.0;
8221 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8222 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8223 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[3], sizeof(float) * 3);
8224 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8225
8226 ptsize = 31.5;
8227 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8228 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8229 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[6], sizeof(float) * 3);
8230 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8231
8232 if(caps.MaxPointSize >= 64.0) {
8233 ptsize = 64.0;
8234 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8235 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8236 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[9], sizeof(float) * 3);
8237 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8238
8239 ptsize = 63.75;
8240 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8241 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8242 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[15], sizeof(float) * 3);
8243 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8244 }
8245
8246 ptsize = 1.0;
8247 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8248 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8249 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[12], sizeof(float) * 3);
8250 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8251
8252 hr = IDirect3DDevice9_EndScene(device);
8253 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8254 }
8255 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8256 color = getPixelColor(device, 64-9, 64-9);
8257 ok(color == 0x000000ff, "pSize: Pixel (64-9),(64-9) has color 0x%08x, expected 0x000000ff\n", color);
8258 color = getPixelColor(device, 64-8, 64-8);
8259 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (64-8),(64-8) has color 0x%08x, expected 0x00ffffff\n", color);
8260 color = getPixelColor(device, 64-7, 64-7);
8261 ok(color == 0x00ffffff, "pSize: Pixel (64-7),(64-7) has color 0x%08x, expected 0x00ffffff\n", color);
8262 color = getPixelColor(device, 64+7, 64+7);
8263 ok(color == 0x00ffffff, "pSize: Pixel (64+7),(64+7) has color 0x%08x, expected 0x00ffffff\n", color);
8264 color = getPixelColor(device, 64+8, 64+8);
8265 ok(color == 0x000000ff, "pSize: Pixel (64+8),(64+8) has color 0x%08x, expected 0x000000ff\n", color);
8266 color = getPixelColor(device, 64+9, 64+9);
8267 ok(color == 0x000000ff, "pSize: Pixel (64+9),(64+9) has color 0x%08x, expected 0x000000ff\n", color);
8268
8269 color = getPixelColor(device, 128-17, 64-17);
8270 ok(color == 0x000000ff, "pSize: Pixel (128-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8271 color = getPixelColor(device, 128-16, 64-16);
8272 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (128-16),(64-16) has color 0x%08x, expected 0x00ffffff\n", color);
8273 color = getPixelColor(device, 128-15, 64-15);
8274 ok(color == 0x00ffffff, "pSize: Pixel (128-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8275 color = getPixelColor(device, 128+15, 64+15);
8276 ok(color == 0x00ffffff, "pSize: Pixel (128+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8277 color = getPixelColor(device, 128+16, 64+16);
8278 ok(color == 0x000000ff, "pSize: Pixel (128+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8279 color = getPixelColor(device, 128+17, 64+17);
8280 ok(color == 0x000000ff, "pSize: Pixel (128+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8281
8282 color = getPixelColor(device, 192-17, 64-17);
8283 ok(color == 0x000000ff, "pSize: Pixel (192-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8284 color = getPixelColor(device, 192-16, 64-16);
8285 ok(color == 0x000000ff, "pSize: Pixel (192-16),(64-16) has color 0x%08x, expected 0x000000ff\n", color);
8286 color = getPixelColor(device, 192-15, 64-15);
8287 ok(color == 0x00ffffff, "pSize: Pixel (192-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8288 color = getPixelColor(device, 192+15, 64+15);
8289 ok(color == 0x00ffffff, "pSize: Pixel (192+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8290 color = getPixelColor(device, 192+16, 64+16);
8291 ok(color == 0x000000ff, "pSize: Pixel (192+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8292 color = getPixelColor(device, 192+17, 64+17);
8293 ok(color == 0x000000ff, "pSize: Pixel (192+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8294
8295 if(caps.MaxPointSize >= 64.0) {
8296 color = getPixelColor(device, 256-33, 64-33);
8297 ok(color == 0x000000ff, "pSize: Pixel (256-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8298 color = getPixelColor(device, 256-32, 64-32);
8299 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (256-32),(64-32) has color 0x%08x, expected 0x00ffffff\n", color);
8300 color = getPixelColor(device, 256-31, 64-31);
8301 ok(color == 0x00ffffff, "pSize: Pixel (256-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8302 color = getPixelColor(device, 256+31, 64+31);
8303 ok(color == 0x00ffffff, "pSize: Pixel (256+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8304 color = getPixelColor(device, 256+32, 64+32);
8305 ok(color == 0x000000ff, "pSize: Pixel (256+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8306 color = getPixelColor(device, 256+33, 64+33);
8307 ok(color == 0x000000ff, "pSize: Pixel (256+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8308
8309 color = getPixelColor(device, 384-33, 64-33);
8310 ok(color == 0x000000ff, "pSize: Pixel (384-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8311 color = getPixelColor(device, 384-32, 64-32);
8312 ok(color == 0x000000ff, "pSize: Pixel (384-32),(64-32) has color 0x%08x, expected 0x000000ff\n", color);
8313 color = getPixelColor(device, 384-31, 64-31);
8314 ok(color == 0x00ffffff, "pSize: Pixel (384-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8315 color = getPixelColor(device, 384+31, 64+31);
8316 ok(color == 0x00ffffff, "pSize: Pixel (384+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8317 color = getPixelColor(device, 384+32, 64+32);
8318 ok(color == 0x000000ff, "pSize: Pixel (384+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8319 color = getPixelColor(device, 384+33, 64+33);
8320 ok(color == 0x000000ff, "pSize: Pixel (384+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8321 }
8322
8323 color = getPixelColor(device, 320-1, 64-1);
8324 ok(color == 0x000000ff, "pSize: Pixel (320-1),(64-1) has color 0x%08x, expected 0x000000ff\n", color);
8325 color = getPixelColor(device, 320-0, 64-0);
8326 ok(color == 0x00ffffff, "pSize: Pixel (320-0),(64-0) has color 0x%08x, expected 0x00ffffff\n", color);
8327 color = getPixelColor(device, 320+1, 64+1);
8328 ok(color == 0x000000ff, "pSize: Pixel (320+1),(64+1) has color 0x%08x, expected 0x000000ff\n", color);
8329
8330 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize_orig)));
8331 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed hr=%s\n", DXGetErrorString9(hr));
8332 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &identity);
8333 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%s\n", DXGetErrorString9(hr));
8334 }
8335
8336 static void multiple_rendertargets_test(IDirect3DDevice9 *device)
8337 {
8338 HRESULT hr;
8339 IDirect3DPixelShader9 *ps;
8340 IDirect3DTexture9 *tex1, *tex2;
8341 IDirect3DSurface9 *surf1, *surf2, *backbuf;
8342 D3DCAPS9 caps;
8343 DWORD color;
8344 DWORD shader_code[] = {
8345 0xffff0300, /* ps_3_0 */
8346 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0, 1, 0, 0 */
8347 0x05000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x00000000, /* def c1, 0, 0, 1, 0 */
8348 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
8349 0x02000001, 0x800f0801, 0xa0e40001, /* mov oC1, c1 */
8350 0x0000ffff /* END */
8351 };
8352 float quad[] = {
8353 -1.0, -1.0, 0.1,
8354 1.0, -1.0, 0.1,
8355 -1.0, 1.0, 0.1,
8356 1.0, 1.0, 0.1,
8357 };
8358 float texquad[] = {
8359 -1.0, -1.0, 0.1, 0.0, 0.0,
8360 0.0, -1.0, 0.1, 1.0, 0.0,
8361 -1.0, 1.0, 0.1, 0.0, 1.0,
8362 0.0, 1.0, 0.1, 1.0, 1.0,
8363
8364 0.0, -1.0, 0.1, 0.0, 0.0,
8365 1.0, -1.0, 0.1, 1.0, 0.0,
8366 0.0, 1.0, 0.1, 0.0, 1.0,
8367 1.0, 1.0, 0.1, 1.0, 1.0,
8368 };
8369
8370 memset(&caps, 0, sizeof(caps));
8371 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8372 ok(hr == D3D_OK, "IDirect3DDevice9_GetCaps failed, hr=%s\n", DXGetErrorString9(hr));
8373 if(caps.NumSimultaneousRTs < 2) {
8374 skip("Only 1 simultaneous render target supported, skipping MRT test\n");
8375 return;
8376 }
8377
8378 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 0.0, 0);
8379 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8380
8381 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex1, NULL);
8382 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%s\n", DXGetErrorString9(hr));
8383 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex2, NULL);
8384 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%s\n", DXGetErrorString9(hr));
8385 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &ps);
8386 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8387
8388 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &backbuf);
8389 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8390 hr = IDirect3DTexture9_GetSurfaceLevel(tex1, 0, &surf1);
8391 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%s\n", DXGetErrorString9(hr));
8392 hr = IDirect3DTexture9_GetSurfaceLevel(tex2, 0, &surf2);
8393 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%s\n", DXGetErrorString9(hr));
8394
8395 hr = IDirect3DDevice9_SetPixelShader(device, ps);
8396 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8397 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surf1);
8398 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8399 hr = IDirect3DDevice9_SetRenderTarget(device, 1, surf2);
8400 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8401 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8402 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%s\n", DXGetErrorString9(hr));
8403
8404 hr = IDirect3DDevice9_BeginScene(device);
8405 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr=%s\n", DXGetErrorString9(hr));
8406 if(SUCCEEDED(hr)) {
8407 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
8408 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8409
8410 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8411 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8412 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuf);
8413 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8414 hr = IDirect3DDevice9_SetRenderTarget(device, 1, NULL);
8415 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8416 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8417 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%s\n", DXGetErrorString9(hr));
8418
8419 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
8420 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8421 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[0], 5 * sizeof(float));
8422 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8423
8424 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex2);
8425 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8426 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[20], 5 * sizeof(float));
8427 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8428
8429 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
8430 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8431
8432 hr = IDirect3DDevice9_EndScene(device);
8433 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
8434 }
8435
8436 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8437 color = getPixelColor(device, 160, 240);
8438 ok(color == 0x0000ff00, "Texture 1(output color 1) has color 0x%08x, expected 0x0000ff00\n", color);
8439 color = getPixelColor(device, 480, 240);
8440 ok(color == 0x000000ff, "Texture 2(output color 2) has color 0x%08x, expected 0x000000ff\n", color);
8441
8442 IDirect3DPixelShader9_Release(ps);
8443 IDirect3DTexture9_Release(tex1);
8444 IDirect3DTexture9_Release(tex2);
8445 IDirect3DSurface9_Release(surf1);
8446 IDirect3DSurface9_Release(surf2);
8447 IDirect3DSurface9_Release(backbuf);
8448 }
8449
8450 struct formats {
8451 const char *fmtName;
8452 D3DFORMAT textureFormat;
8453 DWORD resultColorBlending;
8454 DWORD resultColorNoBlending;
8455 };
8456
8457 const struct formats test_formats[] = {
8458 { "D3DFMT_G16R16", D3DFMT_G16R16, 0x00181800, 0x002010ff},
8459 { "D3DFMT_R16F", D3DFMT_R16F, 0x0018ffff, 0x0020ffff },
8460 { "D3DFMT_G16R16F", D3DFMT_G16R16F, 0x001818ff, 0x002010ff },
8461 { "D3DFMT_A16B16G16R16F", D3DFMT_A16B16G16R16F, 0x00181800, 0x00201000 },
8462 { "D3DFMT_R32F", D3DFMT_R32F, 0x0018ffff, 0x0020ffff },
8463 { "D3DFMT_G32R32F", D3DFMT_G32R32F, 0x001818ff, 0x002010ff },
8464 { "D3DFMT_A32B32G32R32F", D3DFMT_A32B32G32R32F, 0x00181800, 0x00201000 },
8465 { NULL, 0 }
8466 };
8467
8468 static void pixelshader_blending_test(IDirect3DDevice9 *device)
8469 {
8470 HRESULT hr;
8471 IDirect3DTexture9 *offscreenTexture = NULL;
8472 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
8473 IDirect3D9 *d3d = NULL;
8474 DWORD color;
8475 DWORD r0, g0, b0, r1, g1, b1;
8476 int fmt_index;
8477
8478 static const float quad[][5] = {
8479 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
8480 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
8481 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
8482 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
8483 };
8484
8485 /* Quad with R=0x10, G=0x20 */
8486 static const struct vertex quad1[] = {
8487 {-1.0f, -1.0f, 0.1f, 0x80102000},
8488 {-1.0f, 1.0f, 0.1f, 0x80102000},
8489 { 1.0f, -1.0f, 0.1f, 0x80102000},
8490 { 1.0f, 1.0f, 0.1f, 0x80102000},
8491 };
8492
8493 /* Quad with R=0x20, G=0x10 */
8494 static const struct vertex quad2[] = {
8495 {-1.0f, -1.0f, 0.1f, 0x80201000},
8496 {-1.0f, 1.0f, 0.1f, 0x80201000},
8497 { 1.0f, -1.0f, 0.1f, 0x80201000},
8498 { 1.0f, 1.0f, 0.1f, 0x80201000},
8499 };
8500
8501 IDirect3DDevice9_GetDirect3D(device, &d3d);
8502
8503 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8504 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
8505 if(!backbuffer) {
8506 goto out;
8507 }
8508
8509 for(fmt_index=0; test_formats[fmt_index].textureFormat != 0; fmt_index++)
8510 {
8511 D3DFORMAT fmt = test_formats[fmt_index].textureFormat;
8512 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0, D3DRTYPE_TEXTURE, fmt) != D3D_OK) {
8513 skip("%s textures not supported\n", test_formats[fmt_index].fmtName);
8514 continue;
8515 }
8516
8517 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8518 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
8519
8520 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, fmt, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
8521 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
8522 if(!offscreenTexture) {
8523 continue;
8524 }
8525
8526 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
8527 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
8528 if(!offscreen) {
8529 continue;
8530 }
8531
8532 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8533 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8534
8535 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8536 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8537 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
8538 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8539 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
8540 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
8541 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
8542 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
8543 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
8544 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
8545
8546 /* Below we will draw two quads with different colors and try to blend them together.
8547 * The result color is compared with the expected outcome.
8548 */
8549 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
8550 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
8551 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
8552 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 0.0, 0);
8553 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
8554
8555 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
8556 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8557
8558 /* Draw a quad using color 0x0010200 */
8559 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_ONE);
8560 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8561 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_ZERO);
8562 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8563 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
8564 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8565
8566 /* Draw a quad using color 0x0020100 */
8567 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
8568 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8569 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
8570 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8571 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
8572 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8573
8574 /* We don't want to blend the result on the backbuffer */
8575 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
8576 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8577
8578 /* Prepare rendering the 'blended' texture quad to the backbuffer */
8579 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8580 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
8581 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
8582 ok(hr == D3D_OK, "SetTexture failed, %s\n", DXGetErrorString9(hr));
8583
8584 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8585 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8586
8587 /* This time with the texture */
8588 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8589 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
8590
8591 IDirect3DDevice9_EndScene(device);
8592 }
8593 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8594
8595
8596 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, fmt) == D3D_OK) {
8597 /* Compare the color of the center quad with our expectation */
8598 color = getPixelColor(device, 320, 240);
8599 r0 = (color & 0x00ff0000) >> 16;
8600 g0 = (color & 0x0000ff00) >> 8;
8601 b0 = (color & 0x000000ff) >> 0;
8602
8603 r1 = (test_formats[fmt_index].resultColorBlending & 0x00ff0000) >> 16;
8604 g1 = (test_formats[fmt_index].resultColorBlending & 0x0000ff00) >> 8;
8605 b1 = (test_formats[fmt_index].resultColorBlending & 0x000000ff) >> 0;
8606
8607 ok(r0 >= max(r1, 1) - 1 && r0 <= r1 + 1 &&
8608 g0 >= max(g1, 1) - 1 && g0 <= g1 + 1 &&
8609 b0 >= max(b1, 1) - 1 && b0 <= b1 + 1,
8610 "Offscreen failed for %s: Got color %#08x, expected %#08x.\n", test_formats[fmt_index].fmtName, color, test_formats[fmt_index].resultColorBlending);
8611 } else {
8612 /* No pixel shader blending is supported so expected garbage.The type of 'garbage' depends on the driver version and OS.
8613 * E.g. on G16R16 ati reports (on old r9600 drivers) 0x00ffffff and on modern ones 0x002010ff which is also what Nvidia
8614 * reports. On Vista Nvidia seems to report 0x00ffffff on Geforce7 cards. */
8615 color = getPixelColor(device, 320, 240);
8616 ok((color == 0x00ffffff) || (color == test_formats[fmt_index].resultColorNoBlending), "Offscreen failed for %s: expected no color blending but received it anyway.\n", test_formats[fmt_index].fmtName);
8617 }
8618
8619 IDirect3DDevice9_SetTexture(device, 0, NULL);
8620 if(offscreenTexture) {
8621 IDirect3DTexture9_Release(offscreenTexture);
8622 }
8623 if(offscreen) {
8624 IDirect3DSurface9_Release(offscreen);
8625 }
8626 }
8627
8628 out:
8629 /* restore things */
8630 if(backbuffer) {
8631 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8632 IDirect3DSurface9_Release(backbuffer);
8633 }
8634 }
8635
8636 static void tssargtemp_test(IDirect3DDevice9 *device)
8637 {
8638 HRESULT hr;
8639 DWORD color;
8640 static const struct vertex quad[] = {
8641 {-1.0, -1.0, 0.1, 0x00ff0000},
8642 { 1.0, -1.0, 0.1, 0x00ff0000},
8643 {-1.0, 1.0, 0.1, 0x00ff0000},
8644 { 1.0, 1.0, 0.1, 0x00ff0000}
8645 };
8646 D3DCAPS9 caps;
8647
8648 memset(&caps, 0, sizeof(caps));
8649 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8650 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed with %s\n", DXGetErrorString9(hr));
8651 if(!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_TSSARGTEMP)) {
8652 skip("D3DPMISCCAPS_TSSARGTEMP not supported\n");
8653 return;
8654 }
8655
8656 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
8657 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
8658
8659 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8660 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8661 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
8662 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8663
8664 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8665 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8666 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TFACTOR);
8667 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8668 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_TEMP);
8669 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8670
8671 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_ADD);
8672 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8673 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG1, D3DTA_CURRENT);
8674 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8675 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG2, D3DTA_TEMP);
8676 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8677
8678 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8679 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8680
8681 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x0000ff00);
8682 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %s\n", DXGetErrorString9(hr));
8683 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8684 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8685
8686 hr = IDirect3DDevice9_BeginScene(device);
8687 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr = %s\n", DXGetErrorString9(hr));
8688 if(SUCCEEDED(hr)) {
8689
8690 hr = IDirect3DDevice9_EndScene(device);
8691 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %s\n", DXGetErrorString9(hr));
8692 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8693 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
8694 }
8695 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8696 color = getPixelColor(device, 320, 240);
8697 ok(color == 0x00FFFF00, "TSSARGTEMP test returned color 0x%08x, expected 0x00FFFF00\n", color);
8698
8699 /* Set stage 1 back to default */
8700 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_CURRENT);
8701 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8702 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
8703 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8704 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
8705 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8706 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
8707 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8708 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8709 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8710 }
8711
8712 struct testdata
8713 {
8714 DWORD idxVertex; /* number of instances in the first stream */
8715 DWORD idxColor; /* number of instances in the second stream */
8716 DWORD idxInstance; /* should be 1 ?? */
8717 DWORD color1; /* color 1 instance */
8718 DWORD color2; /* color 2 instance */
8719 DWORD color3; /* color 3 instance */
8720 DWORD color4; /* color 4 instance */
8721 WORD strVertex; /* specify which stream to use 0-2*/
8722 WORD strColor;
8723 WORD strInstance;
8724 };
8725
8726 static const struct testdata testcases[]=
8727 {
8728 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 0 */
8729 {3, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 1 */
8730 {2, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 2 */
8731 {1, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 3 */
8732 {0, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 4 */
8733 {4, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 5 */
8734 {4, 2, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 6 */
8735 {4, 1, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 7 */
8736 {4, 0, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 8 */
8737 {3, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 9 */
8738 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 0, 2}, /* 10 */
8739 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 2, 1}, /* 11 */
8740 {4, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 3, 1}, /* 12 */
8741 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 2, 0, 1}, /* 13 */
8742 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 2, 3}, /* 14 */
8743 /*
8744 This case is handled in a stand alone test, SetStreamSourceFreq(0,(D3DSTREAMSOURCE_INSTANCEDATA | 1)) has to return D3DERR_INVALIDCALL!
8745 {4, 4, 1, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 1, 0, D3DERR_INVALIDCALL},
8746 */
8747 };
8748
8749 /* Drawing Indexed Geometry with instances*/
8750 static void stream_test(IDirect3DDevice9 *device)
8751 {
8752 IDirect3DVertexBuffer9 *vb = NULL;
8753 IDirect3DVertexBuffer9 *vb2 = NULL;
8754 IDirect3DVertexBuffer9 *vb3 = NULL;
8755 IDirect3DIndexBuffer9 *ib = NULL;
8756 IDirect3DVertexDeclaration9 *pDecl = NULL;
8757 IDirect3DVertexShader9 *shader = NULL;
8758 HRESULT hr;
8759 BYTE *data;
8760 DWORD color;
8761 DWORD ind;
8762 int i;
8763
8764 const DWORD shader_code[] =
8765 {
8766 0xfffe0101, /* vs_1_1 */
8767 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
8768 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
8769 0x0000001f, 0x80000005, 0x900f0002, /* dcl_texcoord v2 */
8770 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
8771 0x00000002, 0xc00f0000, 0x80e40000, 0x90e40002, /* add oPos, r0, v2 */
8772 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
8773 0x0000ffff
8774 };
8775
8776 const float quad[][3] =
8777 {
8778 {-0.5f, -0.5f, 1.1f}, /*0 */
8779 {-0.5f, 0.5f, 1.1f}, /*1 */
8780 { 0.5f, -0.5f, 1.1f}, /*2 */
8781 { 0.5f, 0.5f, 1.1f}, /*3 */
8782 };
8783
8784 const float vertcolor[][4] =
8785 {
8786 {1.0f, 0.0f, 0.0f, 1.0f}, /*0 */
8787 {1.0f, 0.0f, 0.0f, 1.0f}, /*1 */
8788 {1.0f, 0.0f, 0.0f, 1.0f}, /*2 */
8789 {1.0f, 0.0f, 0.0f, 1.0f}, /*3 */
8790 };
8791
8792 /* 4 position for 4 instances */
8793 const float instancepos[][3] =
8794 {
8795 {-0.6f,-0.6f, 0.0f},
8796 { 0.6f,-0.6f, 0.0f},
8797 { 0.6f, 0.6f, 0.0f},
8798 {-0.6f, 0.6f, 0.0f},
8799 };
8800
8801 short indices[] = {0, 1, 2, 1, 2, 3};
8802
8803 D3DVERTEXELEMENT9 decl[] =
8804 {
8805 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
8806 {1, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
8807 {2, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
8808 D3DDECL_END()
8809 };
8810
8811 /* set the default value because it isn't done in wine? */
8812 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
8813 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8814
8815 /* check for D3DSTREAMSOURCE_INDEXEDDATA at stream0 */
8816 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 0, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
8817 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8818
8819 /* check wrong cases */
8820 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 0);
8821 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8822 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8823 ok(hr == D3D_OK && ind == 1, "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8824 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 2);
8825 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8826 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8827 ok(hr == D3D_OK && ind == 2, "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8828 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INDEXEDDATA | 0));
8829 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8830 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8831 ok(hr == D3D_OK && ind == (D3DSTREAMSOURCE_INDEXEDDATA | 0), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8832 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | 0));
8833 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8834 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8835 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8836 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA | 0));
8837 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8838 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8839 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8840
8841 /* set the default value back */
8842 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
8843 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8844
8845 /* create all VertexBuffers*/
8846 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0, D3DPOOL_MANAGED, &vb, NULL);
8847 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8848 if(!vb) {
8849 skip("Failed to create a vertex buffer\n");
8850 return;
8851 }
8852 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(vertcolor), 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
8853 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8854 if(!vb2) {
8855 skip("Failed to create a vertex buffer\n");
8856 goto out;
8857 }
8858 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(instancepos), 0, 0, D3DPOOL_MANAGED, &vb3, NULL);
8859 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8860 if(!vb3) {
8861 skip("Failed to create a vertex buffer\n");
8862 goto out;
8863 }
8864
8865 /* create IndexBuffer*/
8866 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
8867 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %s\n", DXGetErrorString9(hr));
8868 if(!ib) {
8869 skip("Failed to create a index buffer\n");
8870 goto out;
8871 }
8872
8873 /* copy all Buffers (Vertex + Index)*/
8874 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
8875 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8876 memcpy(data, quad, sizeof(quad));
8877 hr = IDirect3DVertexBuffer9_Unlock(vb);
8878 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8879 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(vertcolor), (void **) &data, 0);
8880 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8881 memcpy(data, vertcolor, sizeof(vertcolor));
8882 hr = IDirect3DVertexBuffer9_Unlock(vb2);
8883 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8884 hr = IDirect3DVertexBuffer9_Lock(vb3, 0, sizeof(instancepos), (void **) &data, 0);
8885 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8886 memcpy(data, instancepos, sizeof(instancepos));
8887 hr = IDirect3DVertexBuffer9_Unlock(vb3);
8888 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8889 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
8890 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8891 memcpy(data, indices, sizeof(indices));
8892 hr = IDirect3DIndexBuffer9_Unlock(ib);
8893 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8894
8895 /* create VertexShader */
8896 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
8897 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%s\n", DXGetErrorString9(hr));
8898 if(!shader) {
8899 skip("Failed to create a vetex shader\n");
8900 goto out;
8901 }
8902
8903 hr = IDirect3DDevice9_SetVertexShader(device, shader);
8904 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
8905
8906 hr = IDirect3DDevice9_SetIndices(device, ib);
8907 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8908
8909 /* run all tests */
8910 for( i = 0; i < sizeof(testcases)/sizeof(testcases[0]); ++i)
8911 {
8912 struct testdata act = testcases[i];
8913 decl[0].Stream = act.strVertex;
8914 decl[1].Stream = act.strColor;
8915 decl[2].Stream = act.strInstance;
8916 /* create VertexDeclarations */
8917 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl, &pDecl);
8918 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%s (case %i)\n", DXGetErrorString9(hr), i);
8919
8920 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8921 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x (case %i)\n", hr, i);
8922
8923 hr = IDirect3DDevice9_BeginScene(device);
8924 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x (case %i)\n", hr, i);
8925 if(SUCCEEDED(hr))
8926 {
8927 hr = IDirect3DDevice9_SetVertexDeclaration(device, pDecl);
8928 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x (case %i)\n", hr, i);
8929
8930 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxVertex));
8931 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8932 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, vb, 0, sizeof(quad[0]));
8933 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8934
8935 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strColor, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxColor));
8936 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8937 hr = IDirect3DDevice9_SetStreamSource(device, act.strColor, vb2, 0, sizeof(vertcolor[0]));
8938 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8939
8940 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strInstance, (D3DSTREAMSOURCE_INSTANCEDATA | act.idxInstance));
8941 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8942 hr = IDirect3DDevice9_SetStreamSource(device, act.strInstance, vb3, 0, sizeof(instancepos[0]));
8943 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8944
8945 /* don't know if this is right (1*3 and 4*1)*/
8946 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 0, 1 * 3 , 0, 4*1);
8947 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x (case %i)\n", hr, i);
8948 hr = IDirect3DDevice9_EndScene(device);
8949 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x (case %i)\n", hr, i);
8950
8951 /* set all StreamSource && StreamSourceFreq back to default */
8952 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, 1);
8953 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8954 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, NULL, 0, 0);
8955 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8956 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxColor, 1);
8957 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8958 hr = IDirect3DDevice9_SetStreamSource(device, act.idxColor, NULL, 0, 0);
8959 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8960 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxInstance, 1);
8961 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8962 hr = IDirect3DDevice9_SetStreamSource(device, act.idxInstance, NULL, 0, 0);
8963 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8964 }
8965
8966 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8967 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x (case %i)\n", hr, i);
8968
8969 hr = IDirect3DVertexDeclaration9_Release(pDecl);
8970 ok(hr == D3D_OK, "IDirect3DVertexDeclaration9_Release failed with %08x (case %i)\n", hr, i);
8971
8972 color = getPixelColor(device, 160, 360);
8973 ok(color == act.color1, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color1, i);
8974 color = getPixelColor(device, 480, 360);
8975 ok(color == act.color2, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color2, i);
8976 color = getPixelColor(device, 480, 120);
8977 ok(color == act.color3, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color3, i);
8978 color = getPixelColor(device, 160, 120);
8979 ok(color == act.color4, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color4, i);
8980 }
8981
8982 hr = IDirect3DDevice9_SetIndices(device, NULL);
8983 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
8984
8985 out:
8986 if(vb) IDirect3DVertexBuffer9_Release(vb);
8987 if(vb2)IDirect3DVertexBuffer9_Release(vb2);
8988 if(vb3)IDirect3DVertexBuffer9_Release(vb3);
8989 if(ib)IDirect3DIndexBuffer9_Release(ib);
8990 if(shader)IDirect3DVertexShader9_Release(shader);
8991 }
8992
8993 static void np2_stretch_rect_test(IDirect3DDevice9 *device) {
8994 IDirect3DSurface9 *src = NULL, *dst = NULL, *backbuffer = NULL;
8995 IDirect3DTexture9 *dsttex = NULL;
8996 HRESULT hr;
8997 DWORD color;
8998 D3DRECT r1 = {0, 0, 50, 50 };
8999 D3DRECT r2 = {50, 0, 100, 50 };
9000 D3DRECT r3 = {50, 50, 100, 100};
9001 D3DRECT r4 = {0, 50, 50, 100};
9002 const float quad[] = {
9003 -1.0, -1.0, 0.1, 0.0, 0.0,
9004 1.0, -1.0, 0.1, 1.0, 0.0,
9005 -1.0, 1.0, 0.1, 0.0, 1.0,
9006 1.0, 1.0, 0.1, 1.0, 1.0,
9007 };
9008
9009 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
9010 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %s\n", DXGetErrorString9(hr));
9011
9012 hr = IDirect3DDevice9_CreateRenderTarget(device, 100, 100, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &src, NULL );
9013 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateRenderTarget failed with %s\n", DXGetErrorString9(hr));
9014 hr = IDirect3DDevice9_CreateTexture(device, 25, 25, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &dsttex, NULL);
9015 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
9016
9017 if(!src || !dsttex) {
9018 skip("One or more test resources could not be created\n");
9019 goto cleanup;
9020 }
9021
9022 hr = IDirect3DTexture9_GetSurfaceLevel(dsttex, 0, &dst);
9023 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
9024
9025 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
9026 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9027
9028 /* Clear the StretchRect destination for debugging */
9029 hr = IDirect3DDevice9_SetRenderTarget(device, 0, dst);
9030 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9031 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
9032 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9033
9034 hr = IDirect3DDevice9_SetRenderTarget(device, 0, src);
9035 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9036
9037 hr = IDirect3DDevice9_Clear(device, 1, &r1, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9038 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9039 hr = IDirect3DDevice9_Clear(device, 1, &r2, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
9040 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9041 hr = IDirect3DDevice9_Clear(device, 1, &r3, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
9042 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9043 hr = IDirect3DDevice9_Clear(device, 1, &r4, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
9044 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9045
9046 /* Stretchrect before setting the render target back to the backbuffer. This will make Wine use
9047 * the target -> texture GL blit path
9048 */
9049 hr = IDirect3DDevice9_StretchRect(device, src, NULL, dst, NULL, D3DTEXF_POINT);
9050 ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
9051 IDirect3DSurface9_Release(dst);
9052
9053 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
9054 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9055
9056 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) dsttex);
9057 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9058 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
9059 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
9060 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9061 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9062 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9063 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9064
9065 hr = IDirect3DDevice9_BeginScene(device);
9066 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
9067 if(SUCCEEDED(hr)) {
9068 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
9069 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
9070 hr = IDirect3DDevice9_EndScene(device);
9071 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
9072 }
9073
9074 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9075 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
9076 color = getPixelColor(device, 160, 360);
9077 ok(color == 0x00ff0000, "stretchrect: Pixel 160,360 has color 0x%08x, expected 0x00ff0000\n", color);
9078 color = getPixelColor(device, 480, 360);
9079 ok(color == 0x0000ff00, "stretchrect: Pixel 480,360 has color 0x%08x, expected 0x0000ff00\n", color);
9080 color = getPixelColor(device, 480, 120);
9081 ok(color == 0x000000ff, "stretchrect: Pixel 480,120 has color 0x%08x, expected 0x000000ff\n", color);
9082 color = getPixelColor(device, 160, 120);
9083 ok(color == 0x00000000, "stretchrect: Pixel 160,120 has color 0x%08x, expected 0x00000000\n", color);
9084
9085 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
9086 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9087 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9088 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9089
9090 cleanup:
9091 if(src) IDirect3DSurface9_Release(src);
9092 if(backbuffer) IDirect3DSurface9_Release(backbuffer);
9093 if(dsttex) IDirect3DTexture9_Release(dsttex);
9094 }
9095
9096 static void texop_test(IDirect3DDevice9 *device)
9097 {
9098 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
9099 IDirect3DTexture9 *texture = NULL;
9100 D3DLOCKED_RECT locked_rect;
9101 D3DCOLOR color;
9102 D3DCAPS9 caps;
9103 HRESULT hr;
9104 int i;
9105
9106 static const struct {
9107 float x, y, z;
9108 float s, t;
9109 D3DCOLOR diffuse;
9110 } quad[] = {
9111 {-1.0f, -1.0f, 0.1f, -1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9112 {-1.0f, 1.0f, 0.1f, -1.0f, 1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9113 { 1.0f, -1.0f, 0.1f, 1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9114 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)}
9115 };
9116
9117 static const D3DVERTEXELEMENT9 decl_elements[] = {
9118 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
9119 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
9120 {0, 20, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
9121 D3DDECL_END()
9122 };
9123
9124 static const struct {
9125 D3DTEXTUREOP op;
9126 const char *name;
9127 DWORD caps_flag;
9128 D3DCOLOR result;
9129 } test_data[] = {
9130 {D3DTOP_SELECTARG1, "SELECTARG1", D3DTEXOPCAPS_SELECTARG1, D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9131 {D3DTOP_SELECTARG2, "SELECTARG2", D3DTEXOPCAPS_SELECTARG2, D3DCOLOR_ARGB(0x00, 0x33, 0x33, 0x33)},
9132 {D3DTOP_MODULATE, "MODULATE", D3DTEXOPCAPS_MODULATE, D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x00)},
9133 {D3DTOP_MODULATE2X, "MODULATE2X", D3DTEXOPCAPS_MODULATE2X, D3DCOLOR_ARGB(0x00, 0x00, 0x66, 0x00)},
9134 {D3DTOP_MODULATE4X, "MODULATE4X", D3DTEXOPCAPS_MODULATE4X, D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9135 {D3DTOP_ADD, "ADD", D3DTEXOPCAPS_ADD, D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9136 {D3DTOP_ADDSIGNED, "ADDSIGNED", D3DTEXOPCAPS_ADDSIGNED, D3DCOLOR_ARGB(0x00, 0x00, 0xb2, 0x00)},
9137 {D3DTOP_ADDSIGNED2X, "ADDSIGNED2X", D3DTEXOPCAPS_ADDSIGNED2X, D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9138 {D3DTOP_SUBTRACT, "SUBTRACT", D3DTEXOPCAPS_SUBTRACT, D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9139 {D3DTOP_ADDSMOOTH, "ADDSMOOTH", D3DTEXOPCAPS_ADDSMOOTH, D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9140 {D3DTOP_BLENDDIFFUSEALPHA, "BLENDDIFFUSEALPHA", D3DTEXOPCAPS_BLENDDIFFUSEALPHA, D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9141 {D3DTOP_BLENDTEXTUREALPHA, "BLENDTEXTUREALPHA", D3DTEXOPCAPS_BLENDTEXTUREALPHA, D3DCOLOR_ARGB(0x00, 0x14, 0xad, 0x14)},
9142 {D3DTOP_BLENDFACTORALPHA, "BLENDFACTORALPHA", D3DTEXOPCAPS_BLENDFACTORALPHA, D3DCOLOR_ARGB(0x00, 0x07, 0xe4, 0x07)},
9143 {D3DTOP_BLENDTEXTUREALPHAPM, "BLENDTEXTUREALPHAPM", D3DTEXOPCAPS_BLENDTEXTUREALPHAPM, D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9144 {D3DTOP_BLENDCURRENTALPHA, "BLENDCURRENTALPHA", D3DTEXOPCAPS_BLENDCURRENTALPHA, D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9145 {D3DTOP_MODULATEALPHA_ADDCOLOR, "MODULATEALPHA_ADDCOLOR", D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR, D3DCOLOR_ARGB(0x00, 0x1f, 0xff, 0x1f)},
9146 {D3DTOP_MODULATECOLOR_ADDALPHA, "MODULATECOLOR_ADDALPHA", D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA, D3DCOLOR_ARGB(0x00, 0x99, 0xcc, 0x99)},
9147 {D3DTOP_MODULATEINVALPHA_ADDCOLOR, "MODULATEINVALPHA_ADDCOLOR", D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR, D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9148 {D3DTOP_MODULATEINVCOLOR_ADDALPHA, "MODULATEINVCOLOR_ADDALPHA", D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA, D3DCOLOR_ARGB(0x00, 0xcc, 0x99, 0xcc)},
9149 /* BUMPENVMAP & BUMPENVMAPLUMINANCE have their own tests */
9150 {D3DTOP_DOTPRODUCT3, "DOTPRODUCT2", D3DTEXOPCAPS_DOTPRODUCT3, D3DCOLOR_ARGB(0x00, 0x99, 0x99, 0x99)},
9151 {D3DTOP_MULTIPLYADD, "MULTIPLYADD", D3DTEXOPCAPS_MULTIPLYADD, D3DCOLOR_ARGB(0x00, 0xff, 0x33, 0x00)},
9152 {D3DTOP_LERP, "LERP", D3DTEXOPCAPS_LERP, D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x33)},
9153 };
9154
9155 memset(&caps, 0, sizeof(caps));
9156 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9157 ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9158
9159 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
9160 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9161 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
9162 ok(SUCCEEDED(hr), "SetVertexDeclaration failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9163
9164 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
9165 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9166 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
9167 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9168 *((DWORD *)locked_rect.pBits) = D3DCOLOR_ARGB(0x99, 0x00, 0xff, 0x00);
9169 hr = IDirect3DTexture9_UnlockRect(texture, 0);
9170 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9171 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
9172 ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9173
9174 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG0, D3DTA_DIFFUSE);
9175 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9176 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9177 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9178 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9179 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9180
9181 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9182 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9183
9184 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
9185 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9186 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0xdd333333);
9187 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9188 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA);
9189 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9190
9191 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9192 ok(SUCCEEDED(hr), "IDirect3DDevice9_Clear failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9193
9194 for (i = 0; i < sizeof(test_data) / sizeof(*test_data); ++i)
9195 {
9196 if (!(caps.TextureOpCaps & test_data[i].caps_flag))
9197 {
9198 skip("tex operation %s not supported\n", test_data[i].name);
9199 continue;
9200 }
9201
9202 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, test_data[i].op);
9203 ok(SUCCEEDED(hr), "SetTextureStageState (%s) failed with 0x%08x (%s)\n",
9204 test_data[i].name, hr, DXGetErrorString9(hr));
9205
9206 hr = IDirect3DDevice9_BeginScene(device);
9207 ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9208
9209 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9210 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9211
9212 hr = IDirect3DDevice9_EndScene(device);
9213 ok(SUCCEEDED(hr), "EndScene failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9214
9215 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9216 ok(SUCCEEDED(hr), "Present failed with 0x%08x (%s)\n", hr, DXGetErrorString9(hr));
9217
9218 color = getPixelColor(device, 320, 240);
9219 ok(color_match(color, test_data[i].result, 1), "Operation %s returned color 0x%08x, expected 0x%08x\n",
9220 test_data[i].name, color, test_data[i].result);
9221 }
9222
9223 if (texture) IDirect3DTexture9_Release(texture);
9224 if (vertex_declaration) IDirect3DVertexDeclaration9_Release(vertex_declaration);
9225 }
9226
9227 START_TEST(visual)
9228 {
9229 IDirect3DDevice9 *device_ptr;
9230 D3DCAPS9 caps;
9231 HRESULT hr;
9232 DWORD color;
9233
9234 d3d9_handle = LoadLibraryA("d3d9.dll");
9235 if (!d3d9_handle)
9236 {
9237 skip("Could not load d3d9.dll\n");
9238 return;
9239 }
9240
9241 device_ptr = init_d3d9();
9242 if (!device_ptr)
9243 {
9244 skip("Creating the device failed\n");
9245 return;
9246 }
9247
9248 IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps);
9249
9250 /* Check for the reliability of the returned data */
9251 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9252 if(FAILED(hr))
9253 {
9254 skip("Clear failed, can't assure correctness of the test results, skipping\n");
9255 goto cleanup;
9256 }
9257 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9258
9259 color = getPixelColor(device_ptr, 1, 1);
9260 if(color !=0x00ff0000)
9261 {
9262 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9263 goto cleanup;
9264 }
9265
9266 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
9267 if(FAILED(hr))
9268 {
9269 skip("Clear failed, can't assure correctness of the test results, skipping\n");
9270 goto cleanup;
9271 }
9272 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9273
9274 color = getPixelColor(device_ptr, 639, 479);
9275 if(color != 0x0000ddee)
9276 {
9277 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9278 goto cleanup;
9279 }
9280
9281 /* Now execute the real tests */
9282 stretchrect_test(device_ptr);
9283 lighting_test(device_ptr);
9284 clear_test(device_ptr);
9285 fog_test(device_ptr);
9286 if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
9287 {
9288 test_cube_wrap(device_ptr);
9289 } else {
9290 skip("No cube texture support\n");
9291 }
9292 z_range_test(device_ptr);
9293 if(caps.TextureCaps & D3DPTEXTURECAPS_MIPMAP)
9294 {
9295 maxmip_test(device_ptr);
9296 }
9297 else
9298 {
9299 skip("No mipmap support\n");
9300 }
9301 offscreen_test(device_ptr);
9302 alpha_test(device_ptr);
9303 shademode_test(device_ptr);
9304 srgbtexture_test(device_ptr);
9305 release_buffer_test(device_ptr);
9306 float_texture_test(device_ptr);
9307 g16r16_texture_test(device_ptr);
9308 pixelshader_blending_test(device_ptr);
9309 texture_transform_flags_test(device_ptr);
9310 autogen_mipmap_test(device_ptr);
9311 fixed_function_decl_test(device_ptr);
9312 conditional_np2_repeat_test(device_ptr);
9313 fixed_function_bumpmap_test(device_ptr);
9314 if(caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) {
9315 stencil_cull_test(device_ptr);
9316 } else {
9317 skip("No two sided stencil support\n");
9318 }
9319 pointsize_test(device_ptr);
9320 tssargtemp_test(device_ptr);
9321 np2_stretch_rect_test(device_ptr);
9322
9323 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
9324 {
9325 test_constant_clamp_vs(device_ptr);
9326 test_compare_instructions(device_ptr);
9327 }
9328 else skip("No vs_1_1 support\n");
9329
9330 if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
9331 {
9332 test_mova(device_ptr);
9333 if (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9334 test_vshader_input(device_ptr);
9335 test_vshader_float16(device_ptr);
9336 stream_test(device_ptr);
9337 } else {
9338 skip("No vs_3_0 support\n");
9339 }
9340 }
9341 else skip("No vs_2_0 support\n");
9342
9343 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1) && caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9344 {
9345 fog_with_shader_test(device_ptr);
9346 fog_srgbwrite_test(device_ptr);
9347 }
9348 else skip("No vs_1_1 and ps_1_1 support\n");
9349
9350 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9351 {
9352 texbem_test(device_ptr);
9353 texdepth_test(device_ptr);
9354 texkill_test(device_ptr);
9355 x8l8v8u8_test(device_ptr);
9356 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 4)) {
9357 constant_clamp_ps_test(device_ptr);
9358 cnd_test(device_ptr);
9359 if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) {
9360 dp2add_ps_test(device_ptr);
9361 if (caps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) {
9362 nested_loop_test(device_ptr);
9363 fixed_function_varying_test(device_ptr);
9364 vFace_register_test(device_ptr);
9365 vpos_register_test(device_ptr);
9366 multiple_rendertargets_test(device_ptr);
9367 if(caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9368 vshader_version_varying_test(device_ptr);
9369 pshader_version_varying_test(device_ptr);
9370 } else {
9371 skip("No vs_3_0 support\n");
9372 }
9373 } else {
9374 skip("No ps_3_0 support\n");
9375 }
9376 } else {
9377 skip("No ps_2_0 support\n");
9378 }
9379 }
9380 }
9381 else skip("No ps_1_1 support\n");
9382 texop_test(device_ptr);
9383
9384 cleanup:
9385 if(device_ptr) {
9386 ULONG ref;
9387
9388 D3DPRESENT_PARAMETERS present_parameters;
9389 IDirect3DSwapChain9 *swapchain;
9390 IDirect3DDevice9_GetSwapChain(device_ptr, 0, &swapchain);
9391 IDirect3DSwapChain9_GetPresentParameters(swapchain, &present_parameters);
9392 IDirect3DSwapChain9_Release(swapchain);
9393 ref = IDirect3DDevice9_Release(device_ptr);
9394 DestroyWindow(present_parameters.hDeviceWindow);
9395 ok(ref == 0, "The device was not properly freed: refcount %u\n", ref);
9396 }
9397 }
useful hacks and other patches not (yet) suitable for mainline