?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.61.
[wine/gsoc-2012-control.git] / dlls / d3d9 / tests / visual.c
blobc95480680c36a66f3d3683a0d722349c122d1d60
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 /* Locks a given surface and returns the color at (x,y). It's the caller's
52 * responsibility to only pass in lockable surfaces and valid x,y coordinates */
53 static DWORD getPixelColorFromSurface(IDirect3DSurface9 *surface, UINT x, UINT y)
54 {
55 DWORD color;
56 HRESULT hr;
57 D3DSURFACE_DESC desc;
58 RECT rectToLock = {x, y, x+1, y+1};
59 D3DLOCKED_RECT lockedRect;
60
61 hr = IDirect3DSurface9_GetDesc(surface, &desc);
62 if(FAILED(hr)) /* This is not a test */
63 {
64 trace("Can't get the surface description, hr=%s\n", DXGetErrorString9(hr));
65 return 0xdeadbeef;
66 }
67
68 hr = IDirect3DSurface9_LockRect(surface, &lockedRect, &rectToLock, D3DLOCK_READONLY);
69 if(FAILED(hr)) /* This is not a test */
70 {
71 trace("Can't lock the surface, hr=%s\n", DXGetErrorString9(hr));
72 return 0xdeadbeef;
73 }
74 switch(desc.Format) {
75 case D3DFMT_A8R8G8B8:
76 {
77 color = ((DWORD *) lockedRect.pBits)[0] & 0xffffffff;
78 break;
79 }
80 default:
81 trace("Error: unknown surface format: %d\n", desc.Format);
82 color = 0xdeadbeef;
83 break;
84 }
85 hr = IDirect3DSurface9_UnlockRect(surface);
86 if(FAILED(hr))
87 {
88 trace("Can't unlock the surface, hr=%s\n", DXGetErrorString9(hr));
89 }
90 return color;
91 }
92
93 static DWORD getPixelColor(IDirect3DDevice9 *device, UINT x, UINT y)
94 {
95 DWORD ret;
96 IDirect3DSurface9 *surf;
97 HRESULT hr;
98 D3DLOCKED_RECT lockedRect;
99 RECT rectToLock = {x, y, x+1, y+1};
100
101 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 640, 480, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf, NULL);
102 if(FAILED(hr) || !surf ) /* This is not a test */
103 {
104 trace("Can't create an offscreen plain surface to read the render target data, hr=%s\n", DXGetErrorString9(hr));
105 return 0xdeadbeef;
106 }
107
108 hr = IDirect3DDevice9_GetFrontBufferData(device, 0, surf);
109 if(FAILED(hr))
110 {
111 trace("Can't read the front buffer data, hr=%s\n", DXGetErrorString9(hr));
112 ret = 0xdeadbeed;
113 goto out;
114 }
115
116 hr = IDirect3DSurface9_LockRect(surf, &lockedRect, &rectToLock, D3DLOCK_READONLY);
117 if(FAILED(hr))
118 {
119 trace("Can't lock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
120 ret = 0xdeadbeec;
121 goto out;
122 }
123
124 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
125 * really important for these tests
126 */
127 ret = ((DWORD *) lockedRect.pBits)[0] & 0x00ffffff;
128 hr = IDirect3DSurface9_UnlockRect(surf);
129 if(FAILED(hr))
130 {
131 trace("Can't unlock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
132 }
133
134 out:
135 if(surf) IDirect3DSurface9_Release(surf);
136 return ret;
137 }
138
139 static IDirect3DDevice9 *init_d3d9(void)
140 {
141 IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
142 IDirect3D9 *d3d9_ptr = 0;
143 IDirect3DDevice9 *device_ptr = 0;
144 D3DPRESENT_PARAMETERS present_parameters;
145 HRESULT hr;
146 D3DADAPTER_IDENTIFIER9 identifier;
147
148 d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
149 ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
150 if (!d3d9_create) return NULL;
151
152 d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
153 ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
154 if (!d3d9_ptr) return NULL;
155
156 ZeroMemory(&present_parameters, sizeof(present_parameters));
157 present_parameters.Windowed = FALSE;
158 present_parameters.hDeviceWindow = create_window();
159 present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
160 present_parameters.BackBufferWidth = 640;
161 present_parameters.BackBufferHeight = 480;
162 present_parameters.BackBufferFormat = D3DFMT_X8R8G8B8;
163 present_parameters.EnableAutoDepthStencil = TRUE;
164 present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
165
166 memset(&identifier, 0, sizeof(identifier));
167 hr = IDirect3D9_GetAdapterIdentifier(d3d9_ptr, 0, 0, &identifier);
168 ok(hr == D3D_OK, "Failed to get adapter identifier description\n");
169 trace("Driver string: \"%s\"\n", identifier.Driver);
170 trace("Description string: \"%s\"\n", identifier.Description);
171 trace("Device name string: \"%s\"\n", identifier.DeviceName);
172 trace("Driver version %d.%d.%d.%d\n",
173 HIWORD(identifier.DriverVersion.HighPart), LOWORD(identifier.DriverVersion.HighPart),
174 HIWORD(identifier.DriverVersion.LowPart), LOWORD(identifier.DriverVersion.LowPart));
175
176 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
177 if(FAILED(hr)) {
178 present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
179 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
180 if(FAILED(hr)) {
181 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
182 }
183 }
184 ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D_CreateDevice returned: %s\n", DXGetErrorString9(hr));
185
186 return device_ptr;
187 }
188
189 struct vertex
190 {
191 float x, y, z;
192 DWORD diffuse;
193 };
194
195 struct tvertex
196 {
197 float x, y, z, rhw;
198 DWORD diffuse;
199 };
200
201 struct nvertex
202 {
203 float x, y, z;
204 float nx, ny, nz;
205 DWORD diffuse;
206 };
207
208 static void lighting_test(IDirect3DDevice9 *device)
209 {
210 HRESULT hr;
211 DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
212 DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
213 DWORD color;
214
215 float mat[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
216 0.0f, 1.0f, 0.0f, 0.0f,
217 0.0f, 0.0f, 1.0f, 0.0f,
218 0.0f, 0.0f, 0.0f, 1.0f };
219
220 struct vertex unlitquad[] =
221 {
222 {-1.0f, -1.0f, 0.1f, 0xffff0000},
223 {-1.0f, 0.0f, 0.1f, 0xffff0000},
224 { 0.0f, 0.0f, 0.1f, 0xffff0000},
225 { 0.0f, -1.0f, 0.1f, 0xffff0000},
226 };
227 struct vertex litquad[] =
228 {
229 {-1.0f, 0.0f, 0.1f, 0xff00ff00},
230 {-1.0f, 1.0f, 0.1f, 0xff00ff00},
231 { 0.0f, 1.0f, 0.1f, 0xff00ff00},
232 { 0.0f, 0.0f, 0.1f, 0xff00ff00},
233 };
234 struct nvertex unlitnquad[] =
235 {
236 { 0.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
237 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
238 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
239 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
240 };
241 struct nvertex litnquad[] =
242 {
243 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
244 { 0.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
245 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
246 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
247 };
248 WORD Indices[] = {0, 1, 2, 2, 3, 0};
249
250 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
251 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
252
253 /* Setup some states that may cause issues */
254 hr = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(0), (D3DMATRIX *) mat);
255 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
256 hr = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, (D3DMATRIX *)mat);
257 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
258 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, (D3DMATRIX *) mat);
259 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
260 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
261 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
262 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE);
263 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
264 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
265 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
266 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
267 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
268 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHATESTENABLE, FALSE);
269 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
270 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
271 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
272 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
273 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
274 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
275 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
276 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
277 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
278
279 hr = IDirect3DDevice9_SetFVF(device, fvf);
280 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
281
282 hr = IDirect3DDevice9_BeginScene(device);
283 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
284 if(hr == D3D_OK)
285 {
286 /* No lights are defined... That means, lit vertices should be entirely black */
287 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
288 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
289 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
290 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitquad, sizeof(unlitquad[0]));
291 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
292
293 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
294 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
295 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
296 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litquad, sizeof(litquad[0]));
297 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
298
299 hr = IDirect3DDevice9_SetFVF(device, nfvf);
300 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
301
302 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
303 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
304 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
305 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitnquad, sizeof(unlitnquad[0]));
306 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
307
308 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
309 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
310 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
311 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litnquad, sizeof(litnquad[0]));
312 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
313
314 IDirect3DDevice9_EndScene(device);
315 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
316 }
317
318 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
319
320 color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
321 ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
322 color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
323 ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
324 color = getPixelColor(device, 480, 360); /* lower left quad - unlit with normals */
325 ok(color == 0x000000ff, "Unlit quad with normals has color %08x\n", color);
326 color = getPixelColor(device, 480, 120); /* upper left quad - lit with normals */
327 ok(color == 0x00000000, "Lit quad with normals has color %08x\n", color);
328
329 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
330 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
331 }
332
333 static void clear_test(IDirect3DDevice9 *device)
334 {
335 /* Tests the correctness of clearing parameters */
336 HRESULT hr;
337 D3DRECT rect[2];
338 D3DRECT rect_negneg;
339 DWORD color;
340 D3DVIEWPORT9 old_vp, vp;
341 RECT scissor;
342 DWORD oldColorWrite;
343 BOOL invalid_clear_failed = FALSE;
344
345 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
346 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
347
348 /* Positive x, negative y */
349 rect[0].x1 = 0;
350 rect[0].y1 = 480;
351 rect[0].x2 = 320;
352 rect[0].y2 = 240;
353
354 /* Positive x, positive y */
355 rect[1].x1 = 0;
356 rect[1].y1 = 0;
357 rect[1].x2 = 320;
358 rect[1].y2 = 240;
359 /* Clear 2 rectangles with one call. The refrast returns an error in this case, every real driver tested so far
360 * returns D3D_OK, but ignores the rectangle silently
361 */
362 hr = IDirect3DDevice9_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
363 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
364 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
365
366 /* negative x, negative y */
367 rect_negneg.x1 = 640;
368 rect_negneg.y1 = 240;
369 rect_negneg.x2 = 320;
370 rect_negneg.y2 = 0;
371 hr = IDirect3DDevice9_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
372 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
373 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
374
375 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
376
377 color = getPixelColor(device, 160, 360); /* lower left quad */
378 ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
379 color = getPixelColor(device, 160, 120); /* upper left quad */
380 if(invalid_clear_failed) {
381 /* If the negative rectangle was refused, the other rectangles in the list shouldn't be cleared either */
382 ok(color == 0x00ffffff, "Clear rectangle 1(pos, pos) has color %08x\n", color);
383 } else {
384 /* If the negative rectangle was dropped silently, the correct ones are cleared */
385 ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
386 }
387 color = getPixelColor(device, 480, 360); /* lower right quad */
388 ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
389 color = getPixelColor(device, 480, 120); /* upper right quad */
390 ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
391
392 /* Test how the viewport affects clears */
393 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
394 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
395 hr = IDirect3DDevice9_GetViewport(device, &old_vp);
396 ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %s\n", DXGetErrorString9(hr));
397
398 vp.X = 160;
399 vp.Y = 120;
400 vp.Width = 160;
401 vp.Height = 120;
402 vp.MinZ = 0.0;
403 vp.MaxZ = 1.0;
404 hr = IDirect3DDevice9_SetViewport(device, &vp);
405 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
406 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
407 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
408
409 vp.X = 320;
410 vp.Y = 240;
411 vp.Width = 320;
412 vp.Height = 240;
413 vp.MinZ = 0.0;
414 vp.MaxZ = 1.0;
415 hr = IDirect3DDevice9_SetViewport(device, &vp);
416 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
417 rect[0].x1 = 160;
418 rect[0].y1 = 120;
419 rect[0].x2 = 480;
420 rect[0].y2 = 360;
421 hr = IDirect3DDevice9_Clear(device, 1, &rect[0], D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
422 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
423
424 hr = IDirect3DDevice9_SetViewport(device, &old_vp);
425 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %s\n", DXGetErrorString9(hr));
426
427 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
428 color = getPixelColor(device, 158, 118);
429 ok(color == 0x00ffffff, "(158,118) has color %08x\n", color);
430 color = getPixelColor(device, 162, 118);
431 ok(color == 0x00ffffff, "(162,118) has color %08x\n", color);
432 color = getPixelColor(device, 158, 122);
433 ok(color == 0x00ffffff, "(158,122) has color %08x\n", color);
434 color = getPixelColor(device, 162, 122);
435 ok(color == 0x000000ff, "(162,122) has color %08x\n", color);
436
437 color = getPixelColor(device, 318, 238);
438 ok(color == 0x000000ff, "(318,238) has color %08x\n", color);
439 color = getPixelColor(device, 322, 238);
440 ok(color == 0x00ffffff, "(322,328) has color %08x\n", color);
441 color = getPixelColor(device, 318, 242);
442 ok(color == 0x00ffffff, "(318,242) has color %08x\n", color);
443 color = getPixelColor(device, 322, 242);
444 ok(color == 0x0000ff00, "(322,242) has color %08x\n", color);
445
446 color = getPixelColor(device, 478, 358);
447 ok(color == 0x0000ff00, "(478,358 has color %08x\n", color);
448 color = getPixelColor(device, 482, 358);
449 ok(color == 0x00ffffff, "(482,358) has color %08x\n", color);
450 color = getPixelColor(device, 478, 362);
451 ok(color == 0x00ffffff, "(478,362) has color %08x\n", color);
452 color = getPixelColor(device, 482, 362);
453 ok(color == 0x00ffffff, "(482,362) has color %08x\n", color);
454
455 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
456 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
457
458 scissor.left = 160;
459 scissor.right = 480;
460 scissor.top = 120;
461 scissor.bottom = 360;
462 hr = IDirect3DDevice9_SetScissorRect(device, &scissor);
463 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
464 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, TRUE);
465 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
466
467 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
468 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
469 hr = IDirect3DDevice9_Clear(device, 1, &rect[1], D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
470 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
471
472 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
473 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %s\n", DXGetErrorString9(hr));
474
475 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
476 color = getPixelColor(device, 158, 118);
477 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
478 color = getPixelColor(device, 162, 118);
479 ok(color == 0x00ffffff, "Pixel 162/118 has color %08x\n", color);
480 color = getPixelColor(device, 158, 122);
481 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
482 color = getPixelColor(device, 162, 122);
483 ok(color == 0x00ff0000, "Pixel 162/122 has color %08x\n", color);
484
485 color = getPixelColor(device, 158, 358);
486 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
487 color = getPixelColor(device, 162, 358);
488 ok(color == 0x0000ff00, "Pixel 162/358 has color %08x\n", color);
489 color = getPixelColor(device, 158, 358);
490 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
491 color = getPixelColor(device, 162, 362);
492 ok(color == 0x00ffffff, "Pixel 162/362 has color %08x\n", color);
493
494 color = getPixelColor(device, 478, 118);
495 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
496 color = getPixelColor(device, 478, 122);
497 ok(color == 0x0000ff00, "Pixel 162/118 has color %08x\n", color);
498 color = getPixelColor(device, 482, 122);
499 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
500 color = getPixelColor(device, 482, 358);
501 ok(color == 0x00ffffff, "Pixel 162/122 has color %08x\n", color);
502
503 color = getPixelColor(device, 478, 358);
504 ok(color == 0x0000ff00, "Pixel 478/358 has color %08x\n", color);
505 color = getPixelColor(device, 478, 362);
506 ok(color == 0x00ffffff, "Pixel 478/118 has color %08x\n", color);
507 color = getPixelColor(device, 482, 358);
508 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
509 color = getPixelColor(device, 482, 362);
510 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
511
512 color = getPixelColor(device, 318, 238);
513 ok(color == 0x00ff0000, "Pixel 318/238 has color %08x\n", color);
514 color = getPixelColor(device, 318, 242);
515 ok(color == 0x0000ff00, "Pixel 318/242 has color %08x\n", color);
516 color = getPixelColor(device, 322, 238);
517 ok(color == 0x0000ff00, "Pixel 322/238 has color %08x\n", color);
518 color = getPixelColor(device, 322, 242);
519 ok(color == 0x0000ff00, "Pixel 322/242 has color %08x\n", color);
520
521 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_COLORWRITEENABLE, &oldColorWrite);
522 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %s\n", DXGetErrorString9(hr));
523 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
524 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
525
526 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
527 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
528
529 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, oldColorWrite);
530 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
531
532 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
533
534 /* Colorwriteenable does not affect the clear */
535 color = getPixelColor(device, 320, 240);
536 ok(color == 0x00ffffff, "Color write protected clear returned color %08x\n", color);
537 }
538
539 typedef struct {
540 float in[4];
541 DWORD out;
542 } test_data_t;
543
544 /*
545 * c7 mova ARGB mov ARGB
546 * -2.4 -2 0x00ffff00 -3 0x00ff0000
547 * -1.6 -2 0x00ffff00 -2 0x00ffff00
548 * -0.4 0 0x0000ffff -1 0x0000ff00
549 * 0.4 0 0x0000ffff 0 0x0000ffff
550 * 1.6 2 0x00ff00ff 1 0x000000ff
551 * 2.4 2 0x00ff00ff 2 0x00ff00ff
552 */
553 static void test_mova(IDirect3DDevice9 *device)
554 {
555 static const DWORD mova_test[] = {
556 0xfffe0200, /* vs_2_0 */
557 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
558 0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
559 0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
560 0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
561 0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
562 0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
563 0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
564 0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
565 0x0200002e, 0xb0010000, 0xa0000007, /* mova a0.x, c7.x */
566 0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000, /* mov oD0, c[a0.x + 3] */
567 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
568 0x0000ffff /* END */
569 };
570 static const DWORD mov_test[] = {
571 0xfffe0101, /* vs_1_1 */
572 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
573 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
574 0x00000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
575 0x00000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
576 0x00000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
577 0x00000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
578 0x00000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
579 0x00000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
580 0x00000001, 0xb0010000, 0xa0000007, /* mov a0.x, c7.x */
581 0x00000001, 0xd00f0000, 0xa0e42003, /* mov oD0, c[a0.x + 3] */
582 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
583 0x0000ffff /* END */
584 };
585
586 static const test_data_t test_data[2][6] = {
587 {
588 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff0000},
589 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
590 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ff00},
591 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
592 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x000000ff},
593 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
594 },
595 {
596 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
597 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
598 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
599 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
600 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff},
601 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
602 }
603 };
604
605 static const float quad[][3] = {
606 {-1.0f, -1.0f, 0.0f},
607 {-1.0f, 1.0f, 0.0f},
608 { 1.0f, -1.0f, 0.0f},
609 { 1.0f, 1.0f, 0.0f},
610 };
611
612 static const D3DVERTEXELEMENT9 decl_elements[] = {
613 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
614 D3DDECL_END()
615 };
616
617 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
618 IDirect3DVertexShader9 *mova_shader = NULL;
619 IDirect3DVertexShader9 *mov_shader = NULL;
620 HRESULT hr;
621 UINT i, j;
622
623 hr = IDirect3DDevice9_CreateVertexShader(device, mova_test, &mova_shader);
624 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
625 hr = IDirect3DDevice9_CreateVertexShader(device, mov_test, &mov_shader);
626 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
627 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
628 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
629 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
630 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
631
632 hr = IDirect3DDevice9_SetVertexShader(device, mov_shader);
633 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
634 for(j = 0; j < 2; ++j)
635 {
636 for (i = 0; i < (sizeof(test_data[0]) / sizeof(test_data_t)); ++i)
637 {
638 DWORD color;
639
640 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 7, test_data[j][i].in, 1);
641 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
642
643 hr = IDirect3DDevice9_BeginScene(device);
644 ok(SUCCEEDED(hr), "BeginScene failed (%08x)\n", hr);
645
646 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], 3 * sizeof(float));
647 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
648
649 hr = IDirect3DDevice9_EndScene(device);
650 ok(SUCCEEDED(hr), "EndScene failed (%08x)\n", hr);
651
652 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
653 ok(SUCCEEDED(hr), "Present failed (%08x)\n", hr);
654
655 color = getPixelColor(device, 320, 240);
656 ok(color == test_data[j][i].out, "Expected color %08x, got %08x (for input %f, instruction %s)\n",
657 test_data[j][i].out, color, test_data[j][i].in[0], j == 0 ? "mov" : "mova");
658
659 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
660 ok(SUCCEEDED(hr), "Clear failed (%08x)\n", hr);
661 }
662 hr = IDirect3DDevice9_SetVertexShader(device, mova_shader);
663 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
664 }
665
666 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
667 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
668
669 IDirect3DVertexDeclaration9_Release(vertex_declaration);
670 IDirect3DVertexShader9_Release(mova_shader);
671 IDirect3DVertexShader9_Release(mov_shader);
672 }
673
674 struct sVertex {
675 float x, y, z;
676 DWORD diffuse;
677 DWORD specular;
678 };
679
680 struct sVertexT {
681 float x, y, z, rhw;
682 DWORD diffuse;
683 DWORD specular;
684 };
685
686 static void fog_test(IDirect3DDevice9 *device)
687 {
688 HRESULT hr;
689 DWORD color;
690 BYTE r, g, b;
691 float start = 0.0f, end = 1.0f;
692 D3DCAPS9 caps;
693 int i;
694
695 /* Gets full z based fog with linear fog, no fog with specular color */
696 struct sVertex unstransformed_1[] = {
697 {-1, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
698 {-1, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
699 { 0, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
700 { 0, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
701 };
702 /* Ok, I am too lazy to deal with transform matrices */
703 struct sVertex unstransformed_2[] = {
704 {-1, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
705 {-1, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
706 { 0, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
707 { 0, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
708 };
709 /* Untransformed ones. Give them a different diffuse color to make the test look
710 * nicer. It also makes making sure that they are drawn correctly easier.
711 */
712 struct sVertexT transformed_1[] = {
713 {320, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
714 {640, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
715 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
716 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
717 };
718 struct sVertexT transformed_2[] = {
719 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
720 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
721 {640, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
722 {320, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
723 };
724 struct vertex rev_fog_quads[] = {
725 {-1.0, -1.0, 0.1, 0x000000ff},
726 {-1.0, 0.0, 0.1, 0x000000ff},
727 { 0.0, 0.0, 0.1, 0x000000ff},
728 { 0.0, -1.0, 0.1, 0x000000ff},
729
730 { 0.0, -1.0, 0.9, 0x000000ff},
731 { 0.0, 0.0, 0.9, 0x000000ff},
732 { 1.0, 0.0, 0.9, 0x000000ff},
733 { 1.0, -1.0, 0.9, 0x000000ff},
734
735 { 0.0, 0.0, 0.4, 0x000000ff},
736 { 0.0, 1.0, 0.4, 0x000000ff},
737 { 1.0, 1.0, 0.4, 0x000000ff},
738 { 1.0, 0.0, 0.4, 0x000000ff},
739
740 {-1.0, 0.0, 0.7, 0x000000ff},
741 {-1.0, 1.0, 0.7, 0x000000ff},
742 { 0.0, 1.0, 0.7, 0x000000ff},
743 { 0.0, 0.0, 0.7, 0x000000ff},
744 };
745 WORD Indices[] = {0, 1, 2, 2, 3, 0};
746
747 memset(&caps, 0, sizeof(caps));
748 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
749 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %s\n", DXGetErrorString9(hr));
750 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
751 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
752
753 /* Setup initial states: No lighting, fog on, fog color */
754 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
755 ok(hr == D3D_OK, "Turning off lighting returned %s\n", DXGetErrorString9(hr));
756 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
757 ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
758 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
759 ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
760
761 /* First test: Both table fog and vertex fog off */
762 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
763 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
764 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
765 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
766
767 /* Start = 0, end = 1. Should be default, but set them */
768 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
769 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
770 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
771 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
772
773 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
774 {
775 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
776 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
777 /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
778 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
779 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
780 sizeof(unstransformed_1[0]));
781 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
782
783 /* That makes it use the Z value */
784 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
785 ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
786 /* Untransformed, vertex fog != none (or table fog != none):
787 * Use the Z value as input into the equation
788 */
789 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
790 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
791 sizeof(unstransformed_1[0]));
792 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
793
794 /* transformed verts */
795 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
796 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
797 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
798 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
799 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
800 sizeof(transformed_1[0]));
801 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
802
803 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
804 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
805 /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
806 * equation
807 */
808 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
809 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_2,
810 sizeof(transformed_2[0]));
811
812 hr = IDirect3DDevice9_EndScene(device);
813 ok(hr == D3D_OK, "EndScene returned %s\n", DXGetErrorString9(hr));
814 }
815 else
816 {
817 ok(FALSE, "BeginScene failed\n");
818 }
819
820 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
821 color = getPixelColor(device, 160, 360);
822 ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
823 color = getPixelColor(device, 160, 120);
824 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
825 color = getPixelColor(device, 480, 120);
826 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
827 if(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
828 {
829 color = getPixelColor(device, 480, 360);
830 ok(color == 0x0000FF00 || color == 0x0000FE00, "Transformed vertex with linear table fog has color %08x\n", color);
831 }
832 else
833 {
834 /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
835 * The settings above result in no fogging with vertex fog
836 */
837 color = getPixelColor(device, 480, 120);
838 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
839 trace("Info: Table fog not supported by this device\n");
840 }
841
842 /* Now test the special case fogstart == fogend */
843 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
844 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
845
846 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
847 {
848 start = 512;
849 end = 512;
850 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
851 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
852 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
853 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
854
855 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
856 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
857 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
858 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %s\n", DXGetErrorString9(hr));
859 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
860 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
861
862 /* Untransformed vertex, z coord = 0.1, fogstart = 512, fogend = 512. Would result in
863 * a completely fog-free primitive because start > zcoord, but because start == end, the primitive
864 * is fully covered by fog. The same happens to the 2nd untransformed quad with z = 1.0.
865 * The third transformed quad remains unfogged because the fogcoords are read from the specular
866 * color and has fixed fogstart and fogend.
867 */
868 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
869 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
870 sizeof(unstransformed_1[0]));
871 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
872 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
873 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
874 sizeof(unstransformed_1[0]));
875 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
876
877 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
878 ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
879 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
880 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
881 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
882 sizeof(transformed_1[0]));
883 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
884
885 hr = IDirect3DDevice9_EndScene(device);
886 ok(hr == D3D_OK, "EndScene returned %s\n", DXGetErrorString9(hr));
887 }
888 else
889 {
890 ok(FALSE, "BeginScene failed\n");
891 }
892 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
893 color = getPixelColor(device, 160, 360);
894 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 0.1 has color %08x\n", color);
895 color = getPixelColor(device, 160, 120);
896 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 1.0 has color %08x\n", color);
897 color = getPixelColor(device, 480, 120);
898 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
899
900 /* Test "reversed" fog without shaders. With shaders this fails on a few Windows D3D implementations,
901 * but without shaders it seems to work everywhere
902 */
903 end = 0.2;
904 start = 0.8;
905 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
906 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
907 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
908 ok(hr == D3D_OK, "Setting fog end returned %s\n", DXGetErrorString9(hr));
909 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
910 ok( hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
911
912 /* Test reversed fog without shaders. ATI cards have problems with reversed fog and shaders, so
913 * it doesn't seem very important for games. ATI cards also have problems with reversed table fog,
914 * so skip this for now
915 */
916 for(i = 0; i < 1 /*2 - Table fog test disabled, fails on ATI */; i++) {
917 const char *mode = (i ? "table" : "vertex");
918 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
919 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
920 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, i == 0 ? D3DFOG_LINEAR : D3DFOG_NONE);
921 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
922 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, i == 0 ? D3DFOG_NONE : D3DFOG_LINEAR);
923 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
924 hr = IDirect3DDevice9_BeginScene(device);
925 ok( hr == D3D_OK, "IDirect3DDDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
926 if(SUCCEEDED(hr)) {
927 WORD Indices2[] = { 0, 1, 2, 2, 3, 0,
928 4, 5, 6, 6, 7, 4,
929 8, 9, 10, 10, 11, 8,
930 12, 13, 14, 14, 15, 12};
931
932 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */,
933 16 /* NumVerts */, 8 /*PrimCount */, Indices2, D3DFMT_INDEX16, rev_fog_quads,
934 sizeof(rev_fog_quads[0]));
935
936 hr = IDirect3DDevice9_EndScene(device);
937 ok( hr == D3D_OK, "IDirect3DDDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
938 }
939 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
940 color = getPixelColor(device, 160, 360);
941 ok(color == 0x0000FF00 || color == 0x0000FE00, "Reversed %s fog: z=0.1 has color 0x%08x, expected 0x0000ff00\n", mode, color);
942
943 color = getPixelColor(device, 160, 120);
944 r = (color & 0x00ff0000) >> 16;
945 g = (color & 0x0000ff00) >> 8;
946 b = (color & 0x000000ff);
947 ok(r == 0x00 && g >= 0x29 && g <= 0x2d && b >= 0xd2 && b <= 0xd6,
948 "Reversed %s fog: z=0.7 has color 0x%08x, expected\n", mode, color);
949
950 color = getPixelColor(device, 480, 120);
951 r = (color & 0x00ff0000) >> 16;
952 g = (color & 0x0000ff00) >> 8;
953 b = (color & 0x000000ff);
954 ok(r == 0x00 && g >= 0xa8 && g <= 0xac && b >= 0x53 && b <= 0x57,
955 "Reversed %s fog: z=0.4 has color 0x%08x, expected\n", mode, color);
956
957 color = getPixelColor(device, 480, 360);
958 ok(color == 0x000000ff, "Reversed %s fog: z=0.9 has color 0x%08x, expected 0x000000ff\n", mode, color);
959
960 if(!(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)) {
961 skip("D3DPRASTERCAPS_FOGTABLE not supported, skipping reversed table fog test\n");
962 break;
963 }
964 }
965 /* Turn off the fog master switch to avoid confusing other tests */
966 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
967 ok(hr == D3D_OK, "Turning off fog calculations returned %s\n", DXGetErrorString9(hr));
968 start = 0.0;
969 end = 1.0;
970 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
971 ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
972 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
973 ok(hr == D3D_OK, "Setting fog end returned %s\n", DXGetErrorString9(hr));
974 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
975 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %s\n", DXGetErrorString9(hr));
976 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
977 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
978 }
979
980 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
981 * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
982 * regardless of the actual addressing mode set. */
983 static void test_cube_wrap(IDirect3DDevice9 *device)
984 {
985 static const float quad[][6] = {
986 {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
987 {-1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
988 { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
989 { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
990 };
991
992 static const D3DVERTEXELEMENT9 decl_elements[] = {
993 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
994 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
995 D3DDECL_END()
996 };
997
998 static const struct {
999 D3DTEXTUREADDRESS mode;
1000 const char *name;
1001 } address_modes[] = {
1002 {D3DTADDRESS_WRAP, "D3DTADDRESS_WRAP"},
1003 {D3DTADDRESS_MIRROR, "D3DTADDRESS_MIRROR"},
1004 {D3DTADDRESS_CLAMP, "D3DTADDRESS_CLAMP"},
1005 {D3DTADDRESS_BORDER, "D3DTADDRESS_BORDER"},
1006 {D3DTADDRESS_MIRRORONCE, "D3DTADDRESS_MIRRORONCE"},
1007 };
1008
1009 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1010 IDirect3DCubeTexture9 *texture = NULL;
1011 IDirect3DSurface9 *surface = NULL;
1012 D3DLOCKED_RECT locked_rect;
1013 HRESULT hr;
1014 UINT x;
1015 INT y, face;
1016
1017 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1018 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1019 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1020 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1021
1022 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 128, 128,
1023 D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
1024 ok(SUCCEEDED(hr), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr);
1025
1026 hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, 0);
1027 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1028
1029 for (y = 0; y < 128; ++y)
1030 {
1031 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1032 for (x = 0; x < 64; ++x)
1033 {
1034 *ptr++ = 0xffff0000;
1035 }
1036 for (x = 64; x < 128; ++x)
1037 {
1038 *ptr++ = 0xff0000ff;
1039 }
1040 }
1041
1042 hr = IDirect3DSurface9_UnlockRect(surface);
1043 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1044
1045 hr = IDirect3DDevice9_CreateCubeTexture(device, 128, 1, 0, D3DFMT_A8R8G8B8,
1046 D3DPOOL_DEFAULT, &texture, NULL);
1047 ok(SUCCEEDED(hr), "CreateCubeTexture failed (0x%08x)\n", hr);
1048
1049 /* Create cube faces */
1050 for (face = 0; face < 6; ++face)
1051 {
1052 IDirect3DSurface9 *face_surface = NULL;
1053
1054 hr= IDirect3DCubeTexture9_GetCubeMapSurface(texture, face, 0, &face_surface);
1055 ok(SUCCEEDED(hr), "GetCubeMapSurface failed (0x%08x)\n", hr);
1056
1057 hr = IDirect3DDevice9_UpdateSurface(device, surface, NULL, face_surface, NULL);
1058 ok(SUCCEEDED(hr), "UpdateSurface failed (0x%08x)\n", hr);
1059
1060 IDirect3DSurface9_Release(face_surface);
1061 }
1062
1063 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
1064 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1065
1066 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1067 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1068 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1069 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1070 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_BORDERCOLOR, 0xff00ff00);
1071 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr);
1072
1073 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1074 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1075
1076 for (x = 0; x < (sizeof(address_modes) / sizeof(*address_modes)); ++x)
1077 {
1078 DWORD color;
1079
1080 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, address_modes[x].mode);
1081 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1082 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, address_modes[x].mode);
1083 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1084
1085 hr = IDirect3DDevice9_BeginScene(device);
1086 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1087
1088 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1089 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1090
1091 hr = IDirect3DDevice9_EndScene(device);
1092 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1093
1094 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1095 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1096
1097 /* Due to the nature of this test, we sample essentially at the edge
1098 * between two faces. Because of this it's undefined from which face
1099 * the driver will sample. Fortunately that's not important for this
1100 * test, since all we care about is that it doesn't sample from the
1101 * other side of the surface or from the border. */
1102 color = getPixelColor(device, 320, 240);
1103 ok(color == 0x00ff0000 || color == 0x000000ff,
1104 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
1105 color, address_modes[x].name);
1106
1107 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1108 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1109 }
1110
1111 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1112 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1113
1114 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1115 IDirect3DCubeTexture9_Release(texture);
1116 IDirect3DSurface9_Release(surface);
1117 }
1118
1119 static void offscreen_test(IDirect3DDevice9 *device)
1120 {
1121 HRESULT hr;
1122 IDirect3DTexture9 *offscreenTexture = NULL;
1123 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
1124 DWORD color;
1125
1126 static const float quad[][5] = {
1127 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
1128 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
1129 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
1130 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
1131 };
1132
1133 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1134 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
1135
1136 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1137 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
1138 if(!offscreenTexture) {
1139 trace("Failed to create an X8R8G8B8 offscreen texture, trying R5G6B5\n");
1140 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1141 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
1142 if(!offscreenTexture) {
1143 skip("Cannot create an offscreen render target\n");
1144 goto out;
1145 }
1146 }
1147
1148 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
1149 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
1150 if(!backbuffer) {
1151 goto out;
1152 }
1153
1154 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
1155 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
1156 if(!offscreen) {
1157 goto out;
1158 }
1159
1160 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
1161 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
1162
1163 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1164 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
1165 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
1166 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
1167 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1168 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1169 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1170 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1171 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1172 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1173
1174 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
1175 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
1176 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
1177 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1178 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
1179
1180 /* Draw without textures - Should result in a white quad */
1181 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1182 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
1183
1184 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1185 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
1186 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
1187 ok(hr == D3D_OK, "SetTexture failed, %s\n", DXGetErrorString9(hr));
1188
1189 /* This time with the texture */
1190 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1191 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
1192
1193 IDirect3DDevice9_EndScene(device);
1194 }
1195
1196 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1197
1198 /* Center quad - should be white */
1199 color = getPixelColor(device, 320, 240);
1200 ok(color == 0x00ffffff, "Offscreen failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1201 /* Some quad in the cleared part of the texture */
1202 color = getPixelColor(device, 170, 240);
1203 ok(color == 0x00ff00ff, "Offscreen failed: Got color 0x%08x, expected 0x00ff00ff.\n", color);
1204 /* Part of the originally cleared back buffer */
1205 color = getPixelColor(device, 10, 10);
1206 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1207 if(0) {
1208 /* Lower left corner of the screen, where back buffer offscreen rendering draws the offscreen texture.
1209 * It should be red, but the offscreen texture may leave some junk there. Not tested yet. Depending on
1210 * the offscreen rendering mode this test would succeed or fail
1211 */
1212 color = getPixelColor(device, 10, 470);
1213 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1214 }
1215
1216 out:
1217 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1218
1219 /* restore things */
1220 if(backbuffer) {
1221 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1222 IDirect3DSurface9_Release(backbuffer);
1223 }
1224 if(offscreenTexture) {
1225 IDirect3DTexture9_Release(offscreenTexture);
1226 }
1227 if(offscreen) {
1228 IDirect3DSurface9_Release(offscreen);
1229 }
1230 }
1231
1232 /* This test tests fog in combination with shaders.
1233 * What's tested: linear fog (vertex and table) with pixel shader
1234 * linear table fog with non foggy vertex shader
1235 * vertex fog with foggy vertex shader
1236 * What's not tested: non linear fog with shader
1237 * table fog with foggy vertex shader
1238 */
1239 static void fog_with_shader_test(IDirect3DDevice9 *device)
1240 {
1241 HRESULT hr;
1242 DWORD color;
1243 union {
1244 float f;
1245 DWORD i;
1246 } start, end;
1247 unsigned int i, j;
1248
1249 /* basic vertex shader without fog computation ("non foggy") */
1250 static const DWORD vertex_shader_code1[] = {
1251 0xfffe0101, /* vs_1_1 */
1252 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1253 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1254 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1255 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1256 0x0000ffff
1257 };
1258 /* basic vertex shader with reversed fog computation ("foggy") */
1259 static const DWORD vertex_shader_code2[] = {
1260 0xfffe0101, /* vs_1_1 */
1261 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1262 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1263 0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
1264 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1265 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1266 0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000, /* add r0, v0.z, c0.z */
1267 0x00000005, 0xc00f0001, 0x80000000, 0xa0000000, /* mul oFog, r0.x, c0.x */
1268 0x0000ffff
1269 };
1270 /* basic pixel shader */
1271 static const DWORD pixel_shader_code[] = {
1272 0xffff0101, /* ps_1_1 */
1273 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, vo */
1274 0x0000ffff
1275 };
1276
1277 static struct vertex quad[] = {
1278 {-1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1279 {-1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1280 { 1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1281 { 1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1282 };
1283
1284 static const D3DVERTEXELEMENT9 decl_elements[] = {
1285 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1286 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
1287 D3DDECL_END()
1288 };
1289
1290 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1291 IDirect3DVertexShader9 *vertex_shader[3] = {NULL, NULL, NULL};
1292 IDirect3DPixelShader9 *pixel_shader[2] = {NULL, NULL};
1293
1294 /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
1295 static const struct test_data_t {
1296 int vshader;
1297 int pshader;
1298 D3DFOGMODE vfog;
1299 D3DFOGMODE tfog;
1300 unsigned int color[11];
1301 } test_data[] = {
1302 /* only pixel shader: */
1303 {0, 1, 0, 3,
1304 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1305 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1306 {0, 1, 1, 3,
1307 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1308 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1309 {0, 1, 2, 3,
1310 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1311 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1312 {0, 1, 3, 0,
1313 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1314 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1315 {0, 1, 3, 3,
1316 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1317 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1318
1319 /* vertex shader */
1320 {1, 0, 0, 0,
1321 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
1322 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
1323 {1, 0, 0, 3,
1324 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1325 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1326 {1, 0, 1, 3,
1327 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1328 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1329
1330 {1, 0, 2, 3,
1331 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1332 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1333 {1, 0, 3, 3,
1334 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1335 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1336
1337 /* vertex shader and pixel shader */
1338 {1, 1, 0, 3,
1339 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1340 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1341 {1, 1, 1, 3,
1342 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1343 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1344 {1, 1, 2, 3,
1345 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1346 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1347
1348 {1, 1, 3, 3,
1349 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1350 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1351
1352
1353 #if 0 /* FIXME: these fail on GeForce 8500 */
1354 /* foggy vertex shader */
1355 {2, 0, 0, 0,
1356 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1357 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1358 {2, 0, 1, 0,
1359 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1360 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1361 {2, 0, 2, 0,
1362 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1363 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1364 {2, 0, 3, 0,
1365 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1366 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1367 #endif
1368
1369 /* foggy vertex shader and pixel shader */
1370 {2, 1, 0, 0,
1371 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1372 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1373 {2, 1, 1, 0,
1374 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1375 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1376 {2, 1, 2, 0,
1377 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1378 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1379 {2, 1, 3, 0,
1380 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1381 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1382
1383 };
1384
1385 /* NOTE: changing these values will not affect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
1386 start.f=0.1f;
1387 end.f=0.9f;
1388
1389 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]);
1390 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1391 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]);
1392 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1393 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]);
1394 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1395 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1396 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
1397
1398 /* Setup initial states: No lighting, fog on, fog color */
1399 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1400 ok(hr == D3D_OK, "Turning off lighting failed (%08x)\n", hr);
1401 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
1402 ok(hr == D3D_OK, "Turning on fog calculations failed (%08x)\n", hr);
1403 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
1404 ok(hr == D3D_OK, "Setting fog color failed (%08x)\n", hr);
1405 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1406 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1407
1408 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
1409 ok(hr == D3D_OK, "Turning off table fog failed (%08x)\n", hr);
1410 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
1411 ok(hr == D3D_OK, "Turning off vertex fog failed (%08x)\n", hr);
1412
1413 /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
1414 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i);
1415 ok(hr == D3D_OK, "Setting fog start failed (%08x)\n", hr);
1416 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i);
1417 ok(hr == D3D_OK, "Setting fog end failed (%08x)\n", hr);
1418
1419 for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++)
1420 {
1421 hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]);
1422 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1423 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[test_data[i].pshader]);
1424 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1425 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog);
1426 ok( hr == D3D_OK, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1427 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog);
1428 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1429
1430 for(j=0; j < 11; j++)
1431 {
1432 /* Don't use the whole zrange to prevent rounding errors */
1433 quad[0].z = 0.001f + (float)j / 10.02f;
1434 quad[1].z = 0.001f + (float)j / 10.02f;
1435 quad[2].z = 0.001f + (float)j / 10.02f;
1436 quad[3].z = 0.001f + (float)j / 10.02f;
1437
1438 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1439 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1440
1441 hr = IDirect3DDevice9_BeginScene(device);
1442 ok( hr == D3D_OK, "BeginScene returned failed (%08x)\n", hr);
1443
1444 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1445 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
1446
1447 hr = IDirect3DDevice9_EndScene(device);
1448 ok(hr == D3D_OK, "EndScene failed (%08x)\n", hr);
1449
1450 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1451
1452 /* As the red and green component are the result of blending use 5% tolerance on the expected value */
1453 color = getPixelColor(device, 128, 240);
1454 ok((unsigned char)(color) == ((unsigned char)test_data[i].color[j])
1455 && abs( ((unsigned char)(color>>8)) - (unsigned char)(test_data[i].color[j]>>8) ) < 13
1456 && abs( ((unsigned char)(color>>16)) - (unsigned char)(test_data[i].color[j]>>16) ) < 13,
1457 "fog vs%i ps%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%\n",
1458 test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, j, color, test_data[i].color[j]);
1459 }
1460 }
1461
1462 /* reset states */
1463 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1464 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1465 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1466 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1467 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1468 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1469 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1470 ok(hr == D3D_OK, "Turning off fog calculations failed (%08x)\n", hr);
1471
1472 IDirect3DVertexShader9_Release(vertex_shader[1]);
1473 IDirect3DVertexShader9_Release(vertex_shader[2]);
1474 IDirect3DPixelShader9_Release(pixel_shader[1]);
1475 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1476 }
1477
1478 static void generate_bumpmap_textures(IDirect3DDevice9 *device) {
1479 unsigned int i, x, y;
1480 HRESULT hr;
1481 IDirect3DTexture9 *texture[2] = {NULL, NULL};
1482 D3DLOCKED_RECT locked_rect;
1483
1484 /* Generate the textures */
1485 for(i=0; i<2; i++)
1486 {
1487 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, 0, i?D3DFMT_A8R8G8B8:D3DFMT_V8U8,
1488 D3DPOOL_MANAGED, &texture[i], NULL);
1489 ok(SUCCEEDED(hr), "CreateTexture failed (0x%08x)\n", hr);
1490
1491 hr = IDirect3DTexture9_LockRect(texture[i], 0, &locked_rect, NULL, 0);
1492 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1493 for (y = 0; y < 128; ++y)
1494 {
1495 if(i)
1496 { /* Set up black texture with 2x2 texel white spot in the middle */
1497 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1498 for (x = 0; x < 128; ++x)
1499 {
1500 if(y>62 && y<66 && x>62 && x<66)
1501 *ptr++ = 0xffffffff;
1502 else
1503 *ptr++ = 0xff000000;
1504 }
1505 }
1506 else
1507 { /* Set up a displacement map which points away from the center parallel to the closest axis.
1508 * (if multiplied with bumpenvmat)
1509 */
1510 WORD *ptr = (WORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1511 for (x = 0; x < 128; ++x)
1512 {
1513 if(abs(x-64)>abs(y-64))
1514 {
1515 if(x < 64)
1516 *ptr++ = 0xc000;
1517 else
1518 *ptr++ = 0x4000;
1519 }
1520 else
1521 {
1522 if(y < 64)
1523 *ptr++ = 0x0040;
1524 else
1525 *ptr++ = 0x00c0;
1526 }
1527 }
1528 }
1529 }
1530 hr = IDirect3DTexture9_UnlockRect(texture[i], 0);
1531 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1532
1533 hr = IDirect3DDevice9_SetTexture(device, i, (IDirect3DBaseTexture9 *)texture[i]);
1534 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1535
1536 /* Disable texture filtering */
1537 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1538 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1539 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1540 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1541
1542 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1543 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr);
1544 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1545 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr);
1546 }
1547 }
1548
1549 /* test the behavior of the texbem instruction
1550 * with normal 2D and projective 2D textures
1551 */
1552 static void texbem_test(IDirect3DDevice9 *device)
1553 {
1554 HRESULT hr;
1555 DWORD color;
1556 int i;
1557
1558 static const DWORD pixel_shader_code[] = {
1559 0xffff0101, /* ps_1_1*/
1560 0x00000042, 0xb00f0000, /* tex t0*/
1561 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
1562 0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
1563 0x0000ffff
1564 };
1565 static const DWORD double_texbem_code[] = {
1566 0xffff0103, /* ps_1_3 */
1567 0x00000042, 0xb00f0000, /* tex t0 */
1568 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0 */
1569 0x00000042, 0xb00f0002, /* tex t2 */
1570 0x00000043, 0xb00f0003, 0xb0e40002, /* texbem t3, t2 */
1571 0x00000002, 0x800f0000, 0xb0e40001, 0xb0e40003, /* add r0, t1, t3 */
1572 0x0000ffff /* end */
1573 };
1574
1575
1576 static const float quad[][7] = {
1577 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
1578 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
1579 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
1580 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
1581 };
1582 static const float quad_proj[][9] = {
1583 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 128.0f},
1584 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 128.0f, 0.0f, 128.0f},
1585 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 128.0f, 0.0f, 0.0f, 128.0f},
1586 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 128.0f, 128.0f, 0.0f, 128.0f},
1587 };
1588
1589 static const D3DVERTEXELEMENT9 decl_elements[][4] = { {
1590 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1591 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1592 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1593 D3DDECL_END()
1594 },{
1595 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1596 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1597 {0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1598 D3DDECL_END()
1599 } };
1600
1601 /* use asymmetric matrix to test loading */
1602 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
1603
1604 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1605 IDirect3DPixelShader9 *pixel_shader = NULL;
1606 IDirect3DTexture9 *texture = NULL, *texture1, *texture2;
1607 D3DLOCKED_RECT locked_rect;
1608
1609 generate_bumpmap_textures(device);
1610
1611 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1612 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1613 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1614 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1615 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
1616
1617 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1618 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1619
1620 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1621 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1622
1623 for(i=0; i<2; i++)
1624 {
1625 if(i)
1626 {
1627 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
1628 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1629 }
1630
1631 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements[i], &vertex_declaration);
1632 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1633 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1634 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1635
1636 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader);
1637 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1638 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1639 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1640
1641 hr = IDirect3DDevice9_BeginScene(device);
1642 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1643
1644 if(!i)
1645 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1646 else
1647 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad_proj[0], sizeof(quad_proj[0]));
1648 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1649
1650 hr = IDirect3DDevice9_EndScene(device);
1651 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1652
1653 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1654 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1655
1656 color = getPixelColor(device, 320-32, 240);
1657 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1658 color = getPixelColor(device, 320+32, 240);
1659 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1660 color = getPixelColor(device, 320, 240-32);
1661 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1662 color = getPixelColor(device, 320, 240+32);
1663 ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1664
1665 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1666 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1667 IDirect3DPixelShader9_Release(pixel_shader);
1668
1669 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1670 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1671 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1672 }
1673
1674 /* clean up */
1675 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1676 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1677
1678 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
1679 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1680
1681 for(i=0; i<2; i++)
1682 {
1683 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
1684 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
1685 IDirect3DTexture9_Release(texture); /* For the GetTexture */
1686 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
1687 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1688 IDirect3DTexture9_Release(texture);
1689 }
1690
1691 /* Test double texbem */
1692 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture, NULL);
1693 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1694 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture1, NULL);
1695 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1696 hr = IDirect3DDevice9_CreateTexture(device, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture2, NULL);
1697 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1698 hr = IDirect3DDevice9_CreatePixelShader(device, double_texbem_code, &pixel_shader);
1699 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1700
1701 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
1702 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1703 ((signed char *) locked_rect.pBits)[0] = (-1.0 / 8.0) * 127;
1704 ((signed char *) locked_rect.pBits)[1] = ( 1.0 / 8.0) * 127;
1705
1706 hr = IDirect3DTexture9_UnlockRect(texture, 0);
1707 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1708
1709 hr = IDirect3DTexture9_LockRect(texture1, 0, &locked_rect, NULL, 0);
1710 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1711 ((signed char *) locked_rect.pBits)[0] = (-2.0 / 8.0) * 127;
1712 ((signed char *) locked_rect.pBits)[1] = (-4.0 / 8.0) * 127;
1713 hr = IDirect3DTexture9_UnlockRect(texture1, 0);
1714 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1715
1716 {
1717 /* Some data without any meaning, just to have an 8x8 array to see which element is picked */
1718 #define tex 0x00ff0000
1719 #define tex1 0x0000ff00
1720 #define origin 0x000000ff
1721 static const DWORD pixel_data[] = {
1722 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1723 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1724 0x000000ff, tex1 , 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1725 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1726 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, origin, 0x000000ff, tex , 0x000000ff,
1727 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1728 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1729 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1730 };
1731 #undef tex1
1732 #undef tex2
1733 #undef origin
1734
1735 hr = IDirect3DTexture9_LockRect(texture2, 0, &locked_rect, NULL, 0);
1736 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1737 for(i = 0; i < 8; i++) {
1738 memcpy(((char *) locked_rect.pBits) + i * locked_rect.Pitch, pixel_data + 8 * i, 8 * sizeof(DWORD));
1739 }
1740 hr = IDirect3DTexture9_UnlockRect(texture2, 0);
1741 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1742 }
1743
1744 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
1745 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1746 hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) texture2);
1747 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1748 hr = IDirect3DDevice9_SetTexture(device, 2, (IDirect3DBaseTexture9 *) texture1);
1749 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1750 hr = IDirect3DDevice9_SetTexture(device, 3, (IDirect3DBaseTexture9 *) texture2);
1751 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1752 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1753 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1754 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX4);
1755 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1756
1757 bumpenvmat[0] =-1.0; bumpenvmat[2] = 2.0;
1758 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.0;
1759 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1760 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1761 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1762 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1763
1764 bumpenvmat[0] = 1.5; bumpenvmat[2] = 0.0;
1765 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.5;
1766 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1767 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1768 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1769 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1770
1771 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1772 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1773 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1774 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1775 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1776 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1777 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1778 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1779
1780 hr = IDirect3DDevice9_BeginScene(device);
1781 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1782 if(SUCCEEDED(hr)) {
1783 static const float double_quad[] = {
1784 -1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1785 1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1786 -1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1787 1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1788 };
1789
1790 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, double_quad, sizeof(float) * 11);
1791 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1792 hr = IDirect3DDevice9_EndScene(device);
1793 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1794 }
1795 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1796 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1797 color = getPixelColor(device, 320, 240);
1798 ok(color == 0x00ffff00, "double texbem failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1799
1800 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1801 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1802 hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
1803 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1804 hr = IDirect3DDevice9_SetTexture(device, 2, NULL);
1805 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1806 hr = IDirect3DDevice9_SetTexture(device, 3, NULL);
1807 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1808 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1809 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1810
1811 IDirect3DPixelShader9_Release(pixel_shader);
1812 IDirect3DTexture9_Release(texture);
1813 IDirect3DTexture9_Release(texture1);
1814 IDirect3DTexture9_Release(texture2);
1815 }
1816
1817 static void z_range_test(IDirect3DDevice9 *device)
1818 {
1819 const struct vertex quad[] =
1820 {
1821 {-1.0f, 0.0f, 1.1f, 0xffff0000},
1822 {-1.0f, 1.0f, 1.1f, 0xffff0000},
1823 { 1.0f, 0.0f, -1.1f, 0xffff0000},
1824 { 1.0f, 1.0f, -1.1f, 0xffff0000},
1825 };
1826 const struct vertex quad2[] =
1827 {
1828 {-1.0f, 0.0f, 1.1f, 0xff0000ff},
1829 {-1.0f, 1.0f, 1.1f, 0xff0000ff},
1830 { 1.0f, 0.0f, -1.1f, 0xff0000ff},
1831 { 1.0f, 1.0f, -1.1f, 0xff0000ff},
1832 };
1833
1834 const struct tvertex quad3[] =
1835 {
1836 { 0, 240, 1.1f, 1.0, 0xffffff00},
1837 { 0, 480, 1.1f, 1.0, 0xffffff00},
1838 { 640, 240, -1.1f, 1.0, 0xffffff00},
1839 { 640, 480, -1.1f, 1.0, 0xffffff00},
1840 };
1841 const struct tvertex quad4[] =
1842 {
1843 { 0, 240, 1.1f, 1.0, 0xff00ff00},
1844 { 0, 480, 1.1f, 1.0, 0xff00ff00},
1845 { 640, 240, -1.1f, 1.0, 0xff00ff00},
1846 { 640, 480, -1.1f, 1.0, 0xff00ff00},
1847 };
1848 HRESULT hr;
1849 DWORD color;
1850 IDirect3DVertexShader9 *shader;
1851 IDirect3DVertexDeclaration9 *decl;
1852 D3DCAPS9 caps;
1853 const DWORD shader_code[] = {
1854 0xfffe0101, /* vs_1_1 */
1855 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1856 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1857 0x00000001, 0xd00f0000, 0xa0e40000, /* mov oD0, c0 */
1858 0x0000ffff /* end */
1859 };
1860 static const D3DVERTEXELEMENT9 decl_elements[] = {
1861 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1862 D3DDECL_END()
1863 };
1864 /* Does the Present clear the depth stencil? Clear the depth buffer with some value != 0,
1865 * then call Present. Then clear the color buffer to make sure it has some defined content
1866 * after the Present with D3DSWAPEFFECT_DISCARD. After that draw a plane that is somewhere cut
1867 * by the depth value.
1868 */
1869 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.75, 0);
1870 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
1871 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1872 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1873
1874 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, TRUE);
1875 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1876 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
1877 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1878 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
1879 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1880 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1881 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1882 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
1883 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
1884
1885 hr = IDirect3DDevice9_BeginScene(device);
1886 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
1887 if(hr == D3D_OK)
1888 {
1889 /* Test the untransformed vertex path */
1890 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1891 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1892 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1893 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1894 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1895 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1896
1897 /* Test the transformed vertex path */
1898 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
1899 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
1900
1901 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad4, sizeof(quad4[0]));
1902 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1903 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1904 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1905 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad3, sizeof(quad3[0]));
1906 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1907
1908 hr = IDirect3DDevice9_EndScene(device);
1909 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
1910 }
1911
1912 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1913 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1914
1915 /* Do not test the exact corner pixels, but go pretty close to them */
1916
1917 /* Clipped because z > 1.0 */
1918 color = getPixelColor(device, 28, 238);
1919 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1920 color = getPixelColor(device, 28, 241);
1921 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1922
1923 /* Not clipped, > z buffer clear value(0.75) */
1924 color = getPixelColor(device, 31, 238);
1925 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1926 color = getPixelColor(device, 31, 241);
1927 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1928 color = getPixelColor(device, 100, 238);
1929 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1930 color = getPixelColor(device, 100, 241);
1931 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1932
1933 /* Not clipped, < z buffer clear value */
1934 color = getPixelColor(device, 104, 238);
1935 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
1936 color = getPixelColor(device, 104, 241);
1937 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
1938 color = getPixelColor(device, 318, 238);
1939 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
1940 color = getPixelColor(device, 318, 241);
1941 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
1942
1943 /* Clipped because z < 0.0 */
1944 color = getPixelColor(device, 321, 238);
1945 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1946 color = getPixelColor(device, 321, 241);
1947 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1948
1949 /* Test the shader path */
1950 IDirect3DDevice9_GetDeviceCaps(device, &caps);
1951 if (caps.VertexShaderVersion < D3DVS_VERSION(1, 1)) {
1952 skip("Vertex shaders not supported\n");
1953 goto out;
1954 }
1955 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
1956 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
1957 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
1958 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
1959
1960 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1961
1962 IDirect3DDevice9_SetVertexDeclaration(device, decl);
1963 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
1964 IDirect3DDevice9_SetVertexShader(device, shader);
1965 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
1966
1967 hr = IDirect3DDevice9_BeginScene(device);
1968 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
1969 if(hr == D3D_OK)
1970 {
1971 float colorf[] = {1.0, 0.0, 0.0, 1.0};
1972 float colorf2[] = {0.0, 0.0, 1.0, 1.0};
1973 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf, 1);
1974 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1975 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1976 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1977 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
1978 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf2, 1);
1979 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1980 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
1981
1982 hr = IDirect3DDevice9_EndScene(device);
1983 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
1984 }
1985
1986 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1987 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
1988 IDirect3DDevice9_SetVertexShader(device, NULL);
1989 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
1990
1991 IDirect3DVertexDeclaration9_Release(decl);
1992 IDirect3DVertexShader9_Release(shader);
1993
1994 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1995 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1996 /* Z < 1.0 */
1997 color = getPixelColor(device, 28, 238);
1998 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1999
2000 /* 1.0 < z < 0.75 */
2001 color = getPixelColor(device, 31, 238);
2002 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2003 color = getPixelColor(device, 100, 238);
2004 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2005
2006 /* 0.75 < z < 0.0 */
2007 color = getPixelColor(device, 104, 238);
2008 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2009 color = getPixelColor(device, 318, 238);
2010 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2011
2012 /* 0.0 < z */
2013 color = getPixelColor(device, 321, 238);
2014 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2015
2016 out:
2017 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
2018 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2019 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
2020 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2021 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
2022 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
2023 }
2024
2025 static void fill_surface(IDirect3DSurface9 *surface, DWORD color)
2026 {
2027 D3DSURFACE_DESC desc;
2028 D3DLOCKED_RECT l;
2029 HRESULT hr;
2030 unsigned int x, y;
2031 DWORD *mem;
2032
2033 memset(&desc, 0, sizeof(desc));
2034 memset(&l, 0, sizeof(l));
2035 hr = IDirect3DSurface9_GetDesc(surface, &desc);
2036 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %s\n", DXGetErrorString9(hr));
2037 hr = IDirect3DSurface9_LockRect(surface, &l, NULL, 0);
2038 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed with %s\n", DXGetErrorString9(hr));
2039 if(FAILED(hr)) return;
2040
2041 for(y = 0; y < desc.Height; y++)
2042 {
2043 mem = (DWORD *) ((BYTE *) l.pBits + y * l.Pitch);
2044 for(x = 0; x < l.Pitch / sizeof(DWORD); x++)
2045 {
2046 mem[x] = color;
2047 }
2048 }
2049 hr = IDirect3DSurface9_UnlockRect(surface);
2050 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2051 }
2052
2053 /* This tests a variety of possible StretchRect() situations */
2054 static void stretchrect_test(IDirect3DDevice9 *device)
2055 {
2056 HRESULT hr;
2057 IDirect3DTexture9 *tex_rt32 = NULL, *tex_rt64 = NULL, *tex_rt_dest64 = NULL;
2058 IDirect3DSurface9 *surf_tex_rt32 = NULL, *surf_tex_rt64 = NULL, *surf_tex_rt_dest64 = NULL;
2059 IDirect3DTexture9 *tex32 = NULL, *tex64 = NULL, *tex_dest64 = NULL;
2060 IDirect3DSurface9 *surf_tex32 = NULL, *surf_tex64 = NULL, *surf_tex_dest64 = NULL;
2061 IDirect3DSurface9 *surf_rt32 = NULL, *surf_rt64 = NULL, *surf_rt_dest64 = NULL;
2062 IDirect3DSurface9 *surf_offscreen32 = NULL, *surf_offscreen64 = NULL, *surf_offscreen_dest64 = NULL;
2063 IDirect3DSurface9 *surf_temp32 = NULL, *surf_temp64 = NULL;
2064 IDirect3DSurface9 *orig_rt = NULL;
2065 DWORD color;
2066
2067 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &orig_rt);
2068 ok(hr == D3D_OK, "Can't get render target, hr = %s\n", DXGetErrorString9(hr));
2069 if(!orig_rt) {
2070 goto out;
2071 }
2072
2073 /* Create our temporary surfaces in system memory */
2074 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp32, NULL);
2075 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2076 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp64, NULL);
2077 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2078
2079 /* Create offscreen plain surfaces in D3DPOOL_DEFAULT */
2080 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen32, NULL);
2081 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2082 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen64, NULL);
2083 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2084 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen_dest64, NULL);
2085 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %s\n", DXGetErrorString9(hr));
2086
2087 /* Create render target surfaces */
2088 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt32, NULL );
2089 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2090 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt64, NULL );
2091 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2092 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt_dest64, NULL );
2093 ok(hr == D3D_OK, "Creating the render target surface failed with %s\n", DXGetErrorString9(hr));
2094
2095 /* Create render target textures */
2096 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt32, NULL);
2097 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2098 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt64, NULL);
2099 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2100 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt_dest64, NULL);
2101 ok(hr == D3D_OK, "Creating the render target texture failed with %s\n", DXGetErrorString9(hr));
2102 if (tex_rt32) {
2103 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt32, 0, &surf_tex_rt32);
2104 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2105 }
2106 if (tex_rt64) {
2107 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt64, 0, &surf_tex_rt64);
2108 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2109 }
2110 if (tex_rt_dest64) {
2111 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt_dest64, 0, &surf_tex_rt_dest64);
2112 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2113 }
2114
2115 /* Create regular textures in D3DPOOL_DEFAULT */
2116 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex32, NULL);
2117 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2118 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex64, NULL);
2119 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2120 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_dest64, NULL);
2121 ok(hr == D3D_OK, "Creating the regular texture failed with %s\n", DXGetErrorString9(hr));
2122 if (tex32) {
2123 hr = IDirect3DTexture9_GetSurfaceLevel(tex32, 0, &surf_tex32);
2124 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2125 }
2126 if (tex64) {
2127 hr = IDirect3DTexture9_GetSurfaceLevel(tex64, 0, &surf_tex64);
2128 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2129 }
2130 if (tex_dest64) {
2131 hr = IDirect3DTexture9_GetSurfaceLevel(tex_dest64, 0, &surf_tex_dest64);
2132 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
2133 }
2134
2135 /*********************************************************************
2136 * Tests for when the source parameter is an offscreen plain surface *
2137 *********************************************************************/
2138
2139 /* Fill the offscreen 64x64 surface with green */
2140 if (surf_offscreen64)
2141 fill_surface(surf_offscreen64, 0xff00ff00);
2142
2143 /* offscreenplain ==> offscreenplain, same size */
2144 if(surf_offscreen64 && surf_offscreen_dest64) {
2145 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_offscreen_dest64, NULL, 0);
2146 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2147
2148 if (hr == D3D_OK) {
2149 color = getPixelColorFromSurface(surf_offscreen_dest64, 32, 32);
2150 ok(color == 0xff00ff00, "StretchRect offscreen ==> offscreen same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2151 }
2152 }
2153
2154 /* offscreenplain ==> rendertarget texture, same size */
2155 if(surf_offscreen64 && surf_tex_rt_dest64 && surf_temp64) {
2156 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_rt_dest64, NULL, 0);
2157 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2158
2159 /* We can't lock rendertarget textures, so copy to our temp surface first */
2160 if (hr == D3D_OK) {
2161 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2162 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2163 }
2164
2165 if (hr == D3D_OK) {
2166 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2167 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2168 }
2169 }
2170
2171 /* offscreenplain ==> rendertarget surface, same size */
2172 if(surf_offscreen64 && surf_rt_dest64) {
2173 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_rt_dest64, NULL, 0);
2174 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2175
2176 if (hr == D3D_OK) {
2177 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2178 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2179 }
2180 }
2181
2182 /* offscreenplain ==> texture, same size (should fail) */
2183 if(surf_offscreen64 && surf_tex_dest64) {
2184 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_dest64, NULL, 0);
2185 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2186 }
2187
2188 /* Fill the smaller offscreen surface with red */
2189 fill_surface(surf_offscreen32, 0xffff0000);
2190
2191 /* offscreenplain ==> offscreenplain, scaling (should fail) */
2192 if(surf_offscreen32 && surf_offscreen64) {
2193 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_offscreen64, NULL, 0);
2194 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2195 }
2196
2197 /* offscreenplain ==> rendertarget texture, scaling */
2198 if(surf_offscreen32 && surf_tex_rt_dest64 && surf_temp64) {
2199 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_rt_dest64, NULL, 0);
2200 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2201
2202 /* We can't lock rendertarget textures, so copy to our temp surface first */
2203 if (hr == D3D_OK) {
2204 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2205 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2206 }
2207
2208 if (hr == D3D_OK) {
2209 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2210 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2211 }
2212 }
2213
2214 /* offscreenplain ==> rendertarget surface, scaling */
2215 if(surf_offscreen32 && surf_rt_dest64) {
2216 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_rt_dest64, NULL, 0);
2217 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2218
2219 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2220 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2221 }
2222
2223 /* offscreenplain ==> texture, scaling (should fail) */
2224 if(surf_offscreen32 && surf_tex_dest64) {
2225 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_dest64, NULL, 0);
2226 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2227 }
2228
2229 /************************************************************
2230 * Tests for when the source parameter is a regular texture *
2231 ************************************************************/
2232
2233 /* Fill the surface of the regular texture with blue */
2234 if (surf_tex64 && surf_temp64) {
2235 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2236 fill_surface(surf_temp64, 0xff0000ff);
2237 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex64, NULL);
2238 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2239 }
2240
2241 /* texture ==> offscreenplain, same size */
2242 if(surf_tex64 && surf_offscreen64) {
2243 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_offscreen64, NULL, 0);
2244 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2245 }
2246
2247 /* texture ==> rendertarget texture, same size */
2248 if(surf_tex64 && surf_tex_rt_dest64 && surf_temp64) {
2249 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_rt_dest64, NULL, 0);
2250 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2251
2252 /* We can't lock rendertarget textures, so copy to our temp surface first */
2253 if (hr == D3D_OK) {
2254 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2255 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2256 }
2257
2258 if (hr == D3D_OK) {
2259 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2260 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2261 }
2262 }
2263
2264 /* texture ==> rendertarget surface, same size */
2265 if(surf_tex64 && surf_rt_dest64) {
2266 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_rt_dest64, NULL, 0);
2267 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2268
2269 if (hr == D3D_OK) {
2270 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2271 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2272 }
2273 }
2274
2275 /* texture ==> texture, same size (should fail) */
2276 if(surf_tex64 && surf_tex_dest64) {
2277 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_dest64, NULL, 0);
2278 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2279 }
2280
2281 /* Fill the surface of the smaller regular texture with red */
2282 if (surf_tex32 && surf_temp32) {
2283 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2284 fill_surface(surf_temp32, 0xffff0000);
2285 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex32, NULL);
2286 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2287 }
2288
2289 /* texture ==> offscreenplain, scaling (should fail) */
2290 if(surf_tex32 && surf_offscreen64) {
2291 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_offscreen64, NULL, 0);
2292 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2293 }
2294
2295 /* texture ==> rendertarget texture, scaling */
2296 if(surf_tex32 && surf_tex_rt_dest64 && surf_temp64) {
2297 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_rt_dest64, NULL, 0);
2298 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2299
2300 /* We can't lock rendertarget textures, so copy to our temp surface first */
2301 if (hr == D3D_OK) {
2302 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2303 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2304 }
2305
2306 if (hr == D3D_OK) {
2307 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2308 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2309 }
2310 }
2311
2312 /* texture ==> rendertarget surface, scaling */
2313 if(surf_tex32 && surf_rt_dest64) {
2314 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_rt_dest64, NULL, 0);
2315 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2316
2317 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2318 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2319 }
2320
2321 /* texture ==> texture, scaling (should fail) */
2322 if(surf_tex32 && surf_tex_dest64) {
2323 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_dest64, NULL, 0);
2324 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2325 }
2326
2327 /*****************************************************************
2328 * Tests for when the source parameter is a rendertarget texture *
2329 *****************************************************************/
2330
2331 /* Fill the surface of the rendertarget texture with white */
2332 if (surf_tex_rt64 && surf_temp64) {
2333 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2334 fill_surface(surf_temp64, 0xffffffff);
2335 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex_rt64, NULL);
2336 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2337 }
2338
2339 /* rendertarget texture ==> offscreenplain, same size */
2340 if(surf_tex_rt64 && surf_offscreen64) {
2341 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_offscreen64, NULL, 0);
2342 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2343 }
2344
2345 /* rendertarget texture ==> rendertarget texture, same size */
2346 if(surf_tex_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2347 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2348 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2349
2350 /* We can't lock rendertarget textures, so copy to our temp surface first */
2351 if (hr == D3D_OK) {
2352 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2353 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2354 }
2355
2356 if (hr == D3D_OK) {
2357 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2358 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2359 }
2360 }
2361
2362 /* rendertarget texture ==> rendertarget surface, same size */
2363 if(surf_tex_rt64 && surf_rt_dest64) {
2364 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_rt_dest64, NULL, 0);
2365 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2366
2367 if (hr == D3D_OK) {
2368 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2369 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2370 }
2371 }
2372
2373 /* rendertarget texture ==> texture, same size (should fail) */
2374 if(surf_tex_rt64 && surf_tex_dest64) {
2375 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_dest64, NULL, 0);
2376 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2377 }
2378
2379 /* Fill the surface of the smaller rendertarget texture with red */
2380 if (surf_tex_rt32 && surf_temp32) {
2381 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2382 fill_surface(surf_temp32, 0xffff0000);
2383 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex_rt32, NULL);
2384 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %s\n", DXGetErrorString9(hr));
2385 }
2386
2387 /* rendertarget texture ==> offscreenplain, scaling (should fail) */
2388 if(surf_tex_rt32 && surf_offscreen64) {
2389 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_offscreen64, NULL, 0);
2390 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2391 }
2392
2393 /* rendertarget texture ==> rendertarget texture, scaling */
2394 if(surf_tex_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2395 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2396 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2397
2398 /* We can't lock rendertarget textures, so copy to our temp surface first */
2399 if (hr == D3D_OK) {
2400 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2401 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2402 }
2403
2404 if (hr == D3D_OK) {
2405 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2406 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2407 }
2408 }
2409
2410 /* rendertarget texture ==> rendertarget surface, scaling */
2411 if(surf_tex_rt32 && surf_rt_dest64) {
2412 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_rt_dest64, NULL, 0);
2413 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2414
2415 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2416 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2417 }
2418
2419 /* rendertarget texture ==> texture, scaling (should fail) */
2420 if(surf_tex_rt32 && surf_tex_dest64) {
2421 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_dest64, NULL, 0);
2422 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2423 }
2424
2425 /*****************************************************************
2426 * Tests for when the source parameter is a rendertarget surface *
2427 *****************************************************************/
2428
2429 /* Fill the surface of the rendertarget surface with black */
2430 if (surf_rt64)
2431 fill_surface(surf_rt64, 0xff000000);
2432
2433 /* rendertarget texture ==> offscreenplain, same size */
2434 if(surf_rt64 && surf_offscreen64) {
2435 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_offscreen64, NULL, 0);
2436 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2437 }
2438
2439 /* rendertarget surface ==> rendertarget texture, same size */
2440 if(surf_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2441 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2442 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2443
2444 /* We can't lock rendertarget textures, so copy to our temp surface first */
2445 if (hr == D3D_OK) {
2446 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2447 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2448 }
2449
2450 if (hr == D3D_OK) {
2451 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2452 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2453 }
2454 }
2455
2456 /* rendertarget surface ==> rendertarget surface, same size */
2457 if(surf_rt64 && surf_rt_dest64) {
2458 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_rt_dest64, NULL, 0);
2459 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2460
2461 if (hr == D3D_OK) {
2462 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2463 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2464 }
2465 }
2466
2467 /* rendertarget surface ==> texture, same size (should fail) */
2468 if(surf_rt64 && surf_tex_dest64) {
2469 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_dest64, NULL, 0);
2470 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2471 }
2472
2473 /* Fill the surface of the smaller rendertarget texture with red */
2474 if (surf_rt32)
2475 fill_surface(surf_rt32, 0xffff0000);
2476
2477 /* rendertarget surface ==> offscreenplain, scaling (should fail) */
2478 if(surf_rt32 && surf_offscreen64) {
2479 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_offscreen64, NULL, 0);
2480 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2481 }
2482
2483 /* rendertarget surface ==> rendertarget texture, scaling */
2484 if(surf_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2485 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2486 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2487
2488 /* We can't lock rendertarget textures, so copy to our temp surface first */
2489 if (hr == D3D_OK) {
2490 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2491 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %s\n", DXGetErrorString9(hr));
2492 }
2493
2494 if (hr == D3D_OK) {
2495 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2496 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2497 }
2498 }
2499
2500 /* rendertarget surface ==> rendertarget surface, scaling */
2501 if(surf_rt32 && surf_rt_dest64) {
2502 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_rt_dest64, NULL, 0);
2503 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
2504
2505 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2506 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2507 }
2508
2509 /* rendertarget surface ==> texture, scaling (should fail) */
2510 if(surf_rt32 && surf_tex_dest64) {
2511 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_dest64, NULL, 0);
2512 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2513 }
2514
2515 /* TODO: Test when source and destination RECT parameters are given... */
2516 /* TODO: Test format conversions */
2517
2518
2519 out:
2520 /* Clean up */
2521 if (surf_rt32)
2522 IDirect3DSurface9_Release(surf_rt32);
2523 if (surf_rt64)
2524 IDirect3DSurface9_Release(surf_rt64);
2525 if (surf_rt_dest64)
2526 IDirect3DSurface9_Release(surf_rt_dest64);
2527 if (surf_temp32)
2528 IDirect3DSurface9_Release(surf_temp32);
2529 if (surf_temp64)
2530 IDirect3DSurface9_Release(surf_temp64);
2531 if (surf_offscreen32)
2532 IDirect3DSurface9_Release(surf_offscreen32);
2533 if (surf_offscreen64)
2534 IDirect3DSurface9_Release(surf_offscreen64);
2535 if (surf_offscreen_dest64)
2536 IDirect3DSurface9_Release(surf_offscreen_dest64);
2537
2538 if (tex_rt32) {
2539 if (surf_tex_rt32)
2540 IDirect3DSurface9_Release(surf_tex_rt32);
2541 IDirect3DTexture9_Release(tex_rt32);
2542 }
2543 if (tex_rt64) {
2544 if (surf_tex_rt64)
2545 IDirect3DSurface9_Release(surf_tex_rt64);
2546 IDirect3DTexture9_Release(tex_rt64);
2547 }
2548 if (tex_rt_dest64) {
2549 if (surf_tex_rt_dest64)
2550 IDirect3DSurface9_Release(surf_tex_rt_dest64);
2551 IDirect3DTexture9_Release(tex_rt_dest64);
2552 }
2553 if (tex32) {
2554 if (surf_tex32)
2555 IDirect3DSurface9_Release(surf_tex32);
2556 IDirect3DTexture9_Release(tex32);
2557 }
2558 if (tex64) {
2559 if (surf_tex64)
2560 IDirect3DSurface9_Release(surf_tex64);
2561 IDirect3DTexture9_Release(tex64);
2562 }
2563 if (tex_dest64) {
2564 if (surf_tex_dest64)
2565 IDirect3DSurface9_Release(surf_tex_dest64);
2566 IDirect3DTexture9_Release(tex_dest64);
2567 }
2568
2569 if (orig_rt) {
2570 hr = IDirect3DDevice9_SetRenderTarget(device, 0, orig_rt);
2571 ok(hr == D3D_OK, "IDirect3DSetRenderTarget failed with %s\n", DXGetErrorString9(hr));
2572 IDirect3DSurface9_Release(orig_rt);
2573 }
2574 }
2575
2576 static void maxmip_test(IDirect3DDevice9 *device)
2577 {
2578 IDirect3DTexture9 *texture = NULL;
2579 IDirect3DSurface9 *surface = NULL;
2580 HRESULT hr;
2581 DWORD color;
2582 const float quads[] = {
2583 -1.0, -1.0, 0.0, 0.0, 0.0,
2584 -1.0, 0.0, 0.0, 0.0, 1.0,
2585 0.0, -1.0, 0.0, 1.0, 0.0,
2586 0.0, 0.0, 0.0, 1.0, 1.0,
2587
2588 0.0, -1.0, 0.0, 0.0, 0.0,
2589 0.0, 0.0, 0.0, 0.0, 1.0,
2590 1.0, -1.0, 0.0, 1.0, 0.0,
2591 1.0, 0.0, 0.0, 1.0, 1.0,
2592
2593 0.0, 0.0, 0.0, 0.0, 0.0,
2594 0.0, 1.0, 0.0, 0.0, 1.0,
2595 1.0, 0.0, 0.0, 1.0, 0.0,
2596 1.0, 1.0, 0.0, 1.0, 1.0,
2597
2598 -1.0, 0.0, 0.0, 0.0, 0.0,
2599 -1.0, 1.0, 0.0, 0.0, 1.0,
2600 0.0, 0.0, 0.0, 1.0, 0.0,
2601 0.0, 1.0, 0.0, 1.0, 1.0,
2602 };
2603
2604 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2605 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
2606
2607 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
2608 &texture, NULL);
2609 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2610 if(!texture)
2611 {
2612 skip("Failed to create test texture\n");
2613 return;
2614 }
2615
2616 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
2617 fill_surface(surface, 0xffff0000);
2618 IDirect3DSurface9_Release(surface);
2619 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 1, &surface);
2620 fill_surface(surface, 0xff00ff00);
2621 IDirect3DSurface9_Release(surface);
2622 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 2, &surface);
2623 fill_surface(surface, 0xff0000ff);
2624 IDirect3DSurface9_Release(surface);
2625
2626 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2627 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2628 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2629 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2630
2631 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2632 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2633
2634 hr = IDirect3DDevice9_BeginScene(device);
2635 if(SUCCEEDED(hr))
2636 {
2637 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2638 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2639 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2640 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2641
2642 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2643 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2644 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2645 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2646
2647 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2648 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2649 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2650 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2651
2652 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2653 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2654 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2655 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2656 hr = IDirect3DDevice9_EndScene(device);
2657 }
2658
2659 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2660 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2661 /* With mipmapping disabled, the max mip level is ignored, only level 0 is used */
2662 color = getPixelColor(device, 160, 360);
2663 ok(color == 0x00FF0000, "MapMip 0, no mipfilter has color %08x\n", color);
2664 color = getPixelColor(device, 160, 120);
2665 ok(color == 0x00FF0000, "MapMip 3, no mipfilter has color %08x\n", color);
2666 color = getPixelColor(device, 480, 120);
2667 ok(color == 0x00FF0000, "MapMip 2, no mipfilter has color %08x\n", color);
2668 color = getPixelColor(device, 480, 360);
2669 ok(color == 0x00FF0000, "MapMip 1, no mipfilter has color %08x\n", color);
2670
2671 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2672 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
2673
2674 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
2675 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2676
2677 hr = IDirect3DDevice9_BeginScene(device);
2678 if(SUCCEEDED(hr))
2679 {
2680 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2681 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2682 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2683 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2684
2685 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2686 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2687 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2688 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2689
2690 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2691 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2692 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2693 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2694
2695 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2696 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2697 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2698 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2699 hr = IDirect3DDevice9_EndScene(device);
2700 }
2701
2702 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2703 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2704 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2705 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2706
2707 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2708 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2709 /* Max Mip level 0-2 sample from the specified texture level, Max Mip level 3(> levels in texture)
2710 * samples from the highest level in the texture(level 2)
2711 */
2712 color = getPixelColor(device, 160, 360);
2713 ok(color == 0x00FF0000, "MapMip 0, point mipfilter has color %08x\n", color);
2714 color = getPixelColor(device, 160, 120);
2715 ok(color == 0x000000FF, "MapMip 3, point mipfilter has color %08x\n", color);
2716 color = getPixelColor(device, 480, 120);
2717 ok(color == 0x000000FF, "MapMip 2, point mipfilter has color %08x\n", color);
2718 color = getPixelColor(device, 480, 360);
2719 ok(color == 0x0000FF00, "MapMip 1, point mipfilter has color %08x\n", color);
2720
2721 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2722 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2723 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2724 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
2725 IDirect3DTexture9_Release(texture);
2726 }
2727
2728 static void release_buffer_test(IDirect3DDevice9 *device)
2729 {
2730 IDirect3DVertexBuffer9 *vb = NULL;
2731 IDirect3DIndexBuffer9 *ib = NULL;
2732 HRESULT hr;
2733 BYTE *data;
2734 long ref;
2735
2736 static const struct vertex quad[] = {
2737 {-1.0, -1.0, 0.1, 0xffff0000},
2738 {-1.0, 1.0, 0.1, 0xffff0000},
2739 { 1.0, 1.0, 0.1, 0xffff0000},
2740
2741 {-1.0, -1.0, 0.1, 0xff00ff00},
2742 {-1.0, 1.0, 0.1, 0xff00ff00},
2743 { 1.0, 1.0, 0.1, 0xff00ff00}
2744 };
2745 short indices[] = {3, 4, 5};
2746
2747 /* Index and vertex buffers should always be creatable */
2748 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE,
2749 D3DPOOL_MANAGED, &vb, NULL);
2750 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
2751 if(!vb) {
2752 skip("Failed to create a vertex buffer\n");
2753 return;
2754 }
2755 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
2756 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %s\n", DXGetErrorString9(hr));
2757 if(!ib) {
2758 skip("Failed to create an index buffer\n");
2759 return;
2760 }
2761
2762 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
2763 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
2764 memcpy(data, quad, sizeof(quad));
2765 hr = IDirect3DVertexBuffer9_Unlock(vb);
2766 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
2767
2768 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
2769 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
2770 memcpy(data, indices, sizeof(indices));
2771 hr = IDirect3DIndexBuffer9_Unlock(ib);
2772 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
2773
2774 hr = IDirect3DDevice9_SetIndices(device, ib);
2775 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %s\n", DXGetErrorString9(hr));
2776 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad[0]));
2777 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
2778 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
2779 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2780
2781 /* Now destroy the bound index buffer and draw again */
2782 ref = IDirect3DIndexBuffer9_Release(ib);
2783 ok(ref == 0, "Index Buffer reference count is %08ld\n", ref);
2784
2785 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
2786 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
2787
2788 hr = IDirect3DDevice9_BeginScene(device);
2789 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2790 if(SUCCEEDED(hr))
2791 {
2792 /* Deliberately using minvertexindex = 0 and numVertices = 6 to prevent d3d from
2793 * making assumptions about the indices or vertices
2794 */
2795 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 3, 3, 0, 1);
2796 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x\n", hr);
2797 hr = IDirect3DDevice9_EndScene(device);
2798 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2799 }
2800
2801 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2802 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2803
2804 hr = IDirect3DDevice9_SetIndices(device, NULL);
2805 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2806 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2807 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2808
2809 /* Index buffer was already destroyed as part of the test */
2810 IDirect3DVertexBuffer9_Release(vb);
2811 }
2812
2813 static void float_texture_test(IDirect3DDevice9 *device)
2814 {
2815 IDirect3D9 *d3d = NULL;
2816 HRESULT hr;
2817 IDirect3DTexture9 *texture = NULL;
2818 D3DLOCKED_RECT lr;
2819 float *data;
2820 DWORD color;
2821 float quad[] = {
2822 -1.0, -1.0, 0.1, 0.0, 0.0,
2823 -1.0, 1.0, 0.1, 0.0, 1.0,
2824 1.0, -1.0, 0.1, 1.0, 0.0,
2825 1.0, 1.0, 0.1, 1.0, 1.0,
2826 };
2827
2828 memset(&lr, 0, sizeof(lr));
2829 IDirect3DDevice9_GetDirect3D(device, &d3d);
2830 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2831 D3DRTYPE_TEXTURE, D3DFMT_R32F) != D3D_OK) {
2832 skip("D3DFMT_R32F textures not supported\n");
2833 goto out;
2834 }
2835
2836 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_R32F,
2837 D3DPOOL_MANAGED, &texture, NULL);
2838 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2839 if(!texture) {
2840 skip("Failed to create R32F texture\n");
2841 goto out;
2842 }
2843
2844 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2845 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
2846 data = lr.pBits;
2847 *data = 0.0;
2848 hr = IDirect3DTexture9_UnlockRect(texture, 0);
2849 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2850
2851 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2852 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2853
2854 hr = IDirect3DDevice9_BeginScene(device);
2855 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
2856 if(SUCCEEDED(hr))
2857 {
2858 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2859 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2860
2861 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2862 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2863
2864 hr = IDirect3DDevice9_EndScene(device);
2865 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
2866 }
2867 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2868 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2869
2870 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2871 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
2872
2873 color = getPixelColor(device, 240, 320);
2874 ok(color == 0x0000FFFF, "R32F with value 0.0 has color %08x, expected 0x0000FFFF\n", color);
2875
2876 out:
2877 if(texture) IDirect3DTexture9_Release(texture);
2878 IDirect3D9_Release(d3d);
2879 }
2880
2881 static void g16r16_texture_test(IDirect3DDevice9 *device)
2882 {
2883 IDirect3D9 *d3d = NULL;
2884 HRESULT hr;
2885 IDirect3DTexture9 *texture = NULL;
2886 D3DLOCKED_RECT lr;
2887 DWORD *data;
2888 DWORD color, red, green, blue;
2889 float quad[] = {
2890 -1.0, -1.0, 0.1, 0.0, 0.0,
2891 -1.0, 1.0, 0.1, 0.0, 1.0,
2892 1.0, -1.0, 0.1, 1.0, 0.0,
2893 1.0, 1.0, 0.1, 1.0, 1.0,
2894 };
2895
2896 memset(&lr, 0, sizeof(lr));
2897 IDirect3DDevice9_GetDirect3D(device, &d3d);
2898 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2899 D3DRTYPE_TEXTURE, D3DFMT_G16R16) != D3D_OK) {
2900 skip("D3DFMT_G16R16 textures not supported\n");
2901 goto out;
2902 }
2903
2904 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_G16R16,
2905 D3DPOOL_MANAGED, &texture, NULL);
2906 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
2907 if(!texture) {
2908 skip("Failed to create D3DFMT_G16R16 texture\n");
2909 goto out;
2910 }
2911
2912 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2913 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
2914 data = lr.pBits;
2915 *data = 0x0f00f000;
2916 hr = IDirect3DTexture9_UnlockRect(texture, 0);
2917 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
2918
2919 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2920 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2921
2922 hr = IDirect3DDevice9_BeginScene(device);
2923 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
2924 if(SUCCEEDED(hr))
2925 {
2926 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2927 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
2928
2929 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2930 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2931
2932 hr = IDirect3DDevice9_EndScene(device);
2933 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
2934 }
2935 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2936 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
2937
2938 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2939 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
2940
2941 color = getPixelColor(device, 240, 320);
2942 red = (color & 0x00ff0000) >> 16;
2943 green = (color & 0x0000ff00) >> 8;
2944 blue = (color & 0x000000ff) >> 0;
2945 ok(blue == 0xff && red >= 0xef && red <= 0xf1 && green >= 0x0e && green <= 0x10,
2946 "D3DFMT_G16R16 with value 0x00ffff00 has color %08x, expected 0x00F00FFF\n", color);
2947
2948 out:
2949 if(texture) IDirect3DTexture9_Release(texture);
2950 IDirect3D9_Release(d3d);
2951 }
2952
2953 static void texture_transform_flags_test(IDirect3DDevice9 *device)
2954 {
2955 HRESULT hr;
2956 IDirect3D9 *d3d;
2957 D3DFORMAT fmt = D3DFMT_X8R8G8B8;
2958 D3DCAPS9 caps;
2959 IDirect3DTexture9 *texture = NULL;
2960 IDirect3DVolumeTexture9 *volume = NULL;
2961 unsigned int x, y, z;
2962 D3DLOCKED_RECT lr;
2963 D3DLOCKED_BOX lb;
2964 DWORD color;
2965 IDirect3DVertexDeclaration9 *decl, *decl2, *decl3;
2966 float identity[16] = {1.0, 0.0, 0.0, 0.0,
2967 0.0, 1.0, 0.0, 0.0,
2968 0.0, 0.0, 1.0, 0.0,
2969 0.0, 0.0, 0.0, 1.0};
2970 static const D3DVERTEXELEMENT9 decl_elements[] = {
2971 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2972 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2973 D3DDECL_END()
2974 };
2975 static const D3DVERTEXELEMENT9 decl_elements2[] = {
2976 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2977 {0, 12, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2978 D3DDECL_END()
2979 };
2980 static const D3DVERTEXELEMENT9 decl_elements3[] = {
2981 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
2982 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
2983 D3DDECL_END()
2984 };
2985 static const unsigned char proj_texdata[] = {0x00, 0x00, 0x00, 0x00,
2986 0x00, 0xff, 0x00, 0x00,
2987 0x00, 0x00, 0x00, 0x00,
2988 0x00, 0x00, 0x00, 0x00};
2989
2990 memset(&lr, 0, sizeof(lr));
2991 memset(&lb, 0, sizeof(lb));
2992 IDirect3DDevice9_GetDirect3D(device, &d3d);
2993 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2994 D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16) == D3D_OK) {
2995 fmt = D3DFMT_A16B16G16R16;
2996 }
2997 IDirect3D9_Release(d3d);
2998
2999 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
3000 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3001 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
3002 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3003 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements3, &decl3);
3004 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
3005 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
3006 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_SRGBTEXTURE) returned %s\n", DXGetErrorString9(hr));
3007 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
3008 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MAGFILTER) returned %s\n", DXGetErrorString9(hr));
3009 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
3010 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MINFILTER) returned %s\n", DXGetErrorString9(hr));
3011 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
3012 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MIPFILTER) returned %s\n", DXGetErrorString9(hr));
3013 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
3014 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSU) returned %s\n", DXGetErrorString9(hr));
3015 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
3016 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSV) returned %s\n", DXGetErrorString9(hr));
3017 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
3018 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSW) returned %s\n", DXGetErrorString9(hr));
3019 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
3020 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState(D3DRS_LIGHTING) returned %s\n", DXGetErrorString9(hr));
3021 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3022 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3023
3024 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
3025 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %s\n", DXGetErrorString9(hr));
3026 hr = IDirect3DDevice9_CreateTexture(device, caps.MaxTextureWidth, caps.MaxTextureHeight, 1,
3027 0, fmt, D3DPOOL_MANAGED, &texture, NULL);
3028 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
3029 if(!texture) {
3030 skip("Failed to create the test texture\n");
3031 return;
3032 }
3033
3034 /* Unfortunately there is no easy way to set up a texture coordinate passthrough
3035 * in d3d fixed function pipeline, so create a texture that has a gradient from 0.0 to
3036 * 1.0 in red and green for the x and y coords
3037 */
3038 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3039 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %s\n", DXGetErrorString9(hr));
3040 for(y = 0; y < caps.MaxTextureHeight; y++) {
3041 for(x = 0; x < caps.MaxTextureWidth; x++) {
3042 double r_f = (double) y / (double) caps.MaxTextureHeight;
3043 double g_f = (double) x / (double) caps.MaxTextureWidth;
3044 if(fmt == D3DFMT_A16B16G16R16) {
3045 unsigned short r, g;
3046 unsigned short *dst = (unsigned short *) (((char *) lr.pBits) + y * lr.Pitch + x * 8);
3047 r = (unsigned short) (r_f * 65536.0);
3048 g = (unsigned short) (g_f * 65536.0);
3049 dst[0] = r;
3050 dst[1] = g;
3051 dst[2] = 0;
3052 dst[3] = 65535;
3053 } else {
3054 unsigned char *dst = ((unsigned char *) lr.pBits) + y * lr.Pitch + x * 4;
3055 unsigned char r = (unsigned char) (r_f * 255.0);
3056 unsigned char g = (unsigned char) (g_f * 255.0);
3057 dst[0] = 0;
3058 dst[1] = g;
3059 dst[2] = r;
3060 dst[3] = 255;
3061 }
3062 }
3063 }
3064 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3065 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %s\n", DXGetErrorString9(hr));
3066 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3067 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
3068
3069 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3070 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3071 hr = IDirect3DDevice9_BeginScene(device);
3072 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3073 if(SUCCEEDED(hr))
3074 {
3075 float quad1[] = {
3076 -1.0, -1.0, 0.1, 1.0, 1.0,
3077 -1.0, 0.0, 0.1, 1.0, 1.0,
3078 0.0, -1.0, 0.1, 1.0, 1.0,
3079 0.0, 0.0, 0.1, 1.0, 1.0,
3080 };
3081 float quad2[] = {
3082 -1.0, 0.0, 0.1, 1.0, 1.0,
3083 -1.0, 1.0, 0.1, 1.0, 1.0,
3084 0.0, 0.0, 0.1, 1.0, 1.0,
3085 0.0, 1.0, 0.1, 1.0, 1.0,
3086 };
3087 float quad3[] = {
3088 0.0, 0.0, 0.1, 0.5, 0.5,
3089 0.0, 1.0, 0.1, 0.5, 0.5,
3090 1.0, 0.0, 0.1, 0.5, 0.5,
3091 1.0, 1.0, 0.1, 0.5, 0.5,
3092 };
3093 float quad4[] = {
3094 320, 480, 0.1, 1.0, 0.0, 1.0,
3095 320, 240, 0.1, 1.0, 0.0, 1.0,
3096 640, 480, 0.1, 1.0, 0.0, 1.0,
3097 640, 240, 0.1, 1.0, 0.0, 1.0,
3098 };
3099 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3100 0.0, 0.0, 0.0, 0.0,
3101 0.0, 0.0, 0.0, 0.0,
3102 0.0, 0.0, 0.0, 0.0};
3103
3104 /* What happens with the texture matrix if D3DTSS_TEXTURETRANSFORMFLAGS is disabled? */
3105 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3106 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3107 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3108 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3109
3110 /* What happens with transforms enabled? */
3111 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3112 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3113 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3114 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3115
3116 /* What happens if 4 coords are used, but only 2 given ?*/
3117 mat[8] = 1.0;
3118 mat[13] = 1.0;
3119 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3120 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3121 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3122 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3123 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3124 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3125
3126 /* What happens with transformed geometry? This setup lead to 0/0 coords with untransformed
3127 * geometry. If the same applies to transformed vertices, the quad will be black, otherwise red,
3128 * due to the coords in the vertices. (turns out red, indeed)
3129 */
3130 memset(mat, 0, sizeof(mat));
3131 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3132 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3133 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_TEX1);
3134 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3135 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3136 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3137 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3138 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3139
3140 hr = IDirect3DDevice9_EndScene(device);
3141 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3142 }
3143 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3144 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3145 color = getPixelColor(device, 160, 360);
3146 ok(color == 0x00FFFF00 || color == 0x00FEFE00, "quad 1 has color %08x, expected 0x00FFFF00\n", color);
3147 color = getPixelColor(device, 160, 120);
3148 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3149 color = getPixelColor(device, 480, 120);
3150 ok(color == 0x0000FF00 || color == 0x0000FE00, "quad 3 has color %08x, expected 0x0000FF00\n", color);
3151 color = getPixelColor(device, 480, 360);
3152 ok(color == 0x00FF0000 || 0x00FE0000, "quad 4 has color %08x, expected 0x00FF0000\n", color);
3153
3154 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3155 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3156
3157 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3158 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3159 hr = IDirect3DDevice9_BeginScene(device);
3160 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3161 if(SUCCEEDED(hr))
3162 {
3163 float quad1[] = {
3164 -1.0, -1.0, 0.1, 0.8, 0.2,
3165 -1.0, 0.0, 0.1, 0.8, 0.2,
3166 0.0, -1.0, 0.1, 0.8, 0.2,
3167 0.0, 0.0, 0.1, 0.8, 0.2,
3168 };
3169 float quad2[] = {
3170 -1.0, 0.0, 0.1, 0.5, 1.0,
3171 -1.0, 1.0, 0.1, 0.5, 1.0,
3172 0.0, 0.0, 0.1, 0.5, 1.0,
3173 0.0, 1.0, 0.1, 0.5, 1.0,
3174 };
3175 float quad3[] = {
3176 0.0, 0.0, 0.1, 0.5, 1.0,
3177 0.0, 1.0, 0.1, 0.5, 1.0,
3178 1.0, 0.0, 0.1, 0.5, 1.0,
3179 1.0, 1.0, 0.1, 0.5, 1.0,
3180 };
3181 float quad4[] = {
3182 0.0, -1.0, 0.1, 0.8, 0.2,
3183 0.0, 0.0, 0.1, 0.8, 0.2,
3184 1.0, -1.0, 0.1, 0.8, 0.2,
3185 1.0, 0.0, 0.1, 0.8, 0.2,
3186 };
3187 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3188 0.0, 0.0, 0.0, 0.0,
3189 0.0, 1.0, 0.0, 0.0,
3190 0.0, 0.0, 0.0, 0.0};
3191
3192 /* What happens to the default 1 in the 3rd coordinate if it is disabled?
3193 */
3194 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3195 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3196 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3197 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3198
3199 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3200 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3201
3202 /* D3DTFF_COUNT1 does not work on Nvidia drivers. It behaves like D3DTTFF_DISABLE. On ATI drivers
3203 * it behaves like COUNT2 because normal textures require 2 coords
3204 */
3205 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3206 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3207 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 5 * sizeof(float));
3208 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3209
3210 /* Just to be sure, the same as quad2 above */
3211 memset(mat, 0, sizeof(mat));
3212 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3213 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3214 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3215 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3216 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3217 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3218
3219 /* Now, what happens to the 2nd coordinate(that is disabled in the matrix) if it is not
3220 * used? And what happens to the first?
3221 */
3222 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3223 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3224 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3225 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3226
3227 hr = IDirect3DDevice9_EndScene(device);
3228 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3229 }
3230 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3231 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3232 color = getPixelColor(device, 160, 360);
3233 ok(color == 0x00FF0000 || color == 0x00FE0000, "quad 1 has color %08x, expected 0x00FF0000\n", color);
3234 color = getPixelColor(device, 160, 120);
3235 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3236 color = getPixelColor(device, 480, 120);
3237 ok(color == 0x00ff8000 || color == 0x00fe7f00 || color == 0x00000000,
3238 "quad 3 has color %08x, expected 0x00ff8000\n", color);
3239 color = getPixelColor(device, 480, 360);
3240 ok(color == 0x0033cc00 || color == 0x0032cb00 || color == 0x00FF0000 || color == 0x00FE0000,
3241 "quad 4 has color %08x, expected 0x0033cc00\n", color);
3242
3243 IDirect3DTexture9_Release(texture);
3244
3245 /* Test projected textures, without any fancy matrices */
3246 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3247 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3248 hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 1, 0, D3DFMT_L8, D3DPOOL_MANAGED, &texture, NULL);
3249 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
3250 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3251 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3252 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl3);
3253 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3254
3255 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3256 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %s\n", DXGetErrorString9(hr));
3257 for(x = 0; x < 4; x++) {
3258 memcpy(((BYTE *) lr.pBits) + lr.Pitch * x, proj_texdata + 4 * x, 4 * sizeof(proj_texdata[0]));
3259 }
3260 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3261 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %s\n", DXGetErrorString9(hr));
3262 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3263 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
3264
3265 hr = IDirect3DDevice9_BeginScene(device);
3266 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3267 if(SUCCEEDED(hr))
3268 {
3269 const float proj_quads[] = {
3270 -1.0, -1.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3271 1.0, -1.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3272 -1.0, 0.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3273 1.0, 0.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3274 -1.0, 0.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3275 1.0, 0.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3276 -1.0, 1.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3277 1.0, 1.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3278 };
3279
3280 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);
3281 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3282 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[0*7], 7 * sizeof(float));
3283 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3284
3285 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED);
3286 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3287 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[4*7], 7 * sizeof(float));
3288 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3289
3290 hr = IDirect3DDevice9_EndScene(device);
3291 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3292 }
3293
3294 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3295 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
3296 IDirect3DTexture9_Release(texture);
3297
3298 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3299 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3300 color = getPixelColor(device, 158, 118);
3301 ok(color == 0x00000000, "proj: Pixel 158/118 has color 0x%08x, expected 0x00000000\n", color);
3302 color = getPixelColor(device, 162, 118);
3303 ok(color == 0x00000000, "proj: Pixel 162/118 has color 0x%08x, expected 0x00000000\n", color);
3304 color = getPixelColor(device, 158, 122);
3305 ok(color == 0x00000000, "proj: Pixel 158/122 has color 0x%08x, expected 0x00000000\n", color);
3306 color = getPixelColor(device, 162, 122);
3307 ok(color == 0x00FFFFFF, "proj: Pixel 162/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3308
3309 color = getPixelColor(device, 158, 178);
3310 ok(color == 0x00000000, "proj: Pixel 158/178 has color 0x%08x, expected 0x00000000\n", color);
3311 color = getPixelColor(device, 162, 178);
3312 ok(color == 0x00FFFFFF, "proj: Pixel 158/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3313 color = getPixelColor(device, 158, 182);
3314 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3315 color = getPixelColor(device, 162, 182);
3316 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3317
3318 color = getPixelColor(device, 318, 118);
3319 ok(color == 0x00000000, "proj: Pixel 318/118 has color 0x%08x, expected 0x00000000\n", color);
3320 color = getPixelColor(device, 322, 118);
3321 ok(color == 0x00000000, "proj: Pixel 322/118 has color 0x%08x, expected 0x00000000\n", color);
3322 color = getPixelColor(device, 318, 122);
3323 ok(color == 0x00FFFFFF, "proj: Pixel 318/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3324 color = getPixelColor(device, 322, 122);
3325 ok(color == 0x00000000, "proj: Pixel 322/122 has color 0x%08x, expected 0x00000000\n", color);
3326
3327 color = getPixelColor(device, 318, 178);
3328 ok(color == 0x00FFFFFF, "proj: Pixel 318/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3329 color = getPixelColor(device, 322, 178);
3330 ok(color == 0x00000000, "proj: Pixel 322/178 has color 0x%08x, expected 0x00000000\n", color);
3331 color = getPixelColor(device, 318, 182);
3332 ok(color == 0x00000000, "proj: Pixel 318/182 has color 0x%08x, expected 0x00000000\n", color);
3333 color = getPixelColor(device, 322, 182);
3334 ok(color == 0x00000000, "proj: Pixel 322/182 has color 0x%08x, expected 0x00000000\n", color);
3335
3336 color = getPixelColor(device, 238, 298);
3337 ok(color == 0x00000000, "proj: Pixel 238/298 has color 0x%08x, expected 0x00000000\n", color);
3338 color = getPixelColor(device, 242, 298);
3339 ok(color == 0x00000000, "proj: Pixel 242/298 has color 0x%08x, expected 0x00000000\n", color);
3340 color = getPixelColor(device, 238, 302);
3341 ok(color == 0x00000000, "proj: Pixel 238/302 has color 0x%08x, expected 0x00000000\n", color);
3342 color = getPixelColor(device, 242, 302);
3343 ok(color == 0x00FFFFFF, "proj: Pixel 242/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3344
3345 color = getPixelColor(device, 238, 388);
3346 ok(color == 0x00000000, "proj: Pixel 238/388 has color 0x%08x, expected 0x00000000\n", color);
3347 color = getPixelColor(device, 242, 388);
3348 ok(color == 0x00FFFFFF, "proj: Pixel 242/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3349 color = getPixelColor(device, 238, 392);
3350 ok(color == 0x00000000, "proj: Pixel 238/392 has color 0x%08x, expected 0x00000000\n", color);
3351 color = getPixelColor(device, 242, 392);
3352 ok(color == 0x00000000, "proj: Pixel 242/392 has color 0x%08x, expected 0x00000000\n", color);
3353
3354 color = getPixelColor(device, 478, 298);
3355 ok(color == 0x00000000, "proj: Pixel 478/298 has color 0x%08x, expected 0x00000000\n", color);
3356 color = getPixelColor(device, 482, 298);
3357 ok(color == 0x00000000, "proj: Pixel 482/298 has color 0x%08x, expected 0x00000000\n", color);
3358 color = getPixelColor(device, 478, 302);
3359 ok(color == 0x00FFFFFF, "proj: Pixel 478/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3360 color = getPixelColor(device, 482, 302);
3361 ok(color == 0x00000000, "proj: Pixel 482/302 has color 0x%08x, expected 0x00000000\n", color);
3362
3363 color = getPixelColor(device, 478, 388);
3364 ok(color == 0x00FFFFFF, "proj: Pixel 478/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3365 color = getPixelColor(device, 482, 388);
3366 ok(color == 0x00000000, "proj: Pixel 482/388 has color 0x%08x, expected 0x00000000\n", color);
3367 color = getPixelColor(device, 478, 392);
3368 ok(color == 0x00000000, "proj: Pixel 478/392 has color 0x%08x, expected 0x00000000\n", color);
3369 color = getPixelColor(device, 482, 392);
3370 ok(color == 0x00000000, "proj: Pixel 482/392 has color 0x%08x, expected 0x00000000\n", color);
3371
3372 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3373 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3374 /* Use a smaller volume texture than the biggest possible size for memory and performance reasons
3375 * Thus watch out if sampling from texels between 0 and 1.
3376 */
3377 hr = IDirect3DDevice9_CreateVolumeTexture(device, 32, 32, 32, 1, 0, fmt, D3DPOOL_MANAGED, &volume, 0);
3378 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
3379 "IDirect3DDevice9_CreateVolumeTexture failed with %s\n", DXGetErrorString9(hr));
3380 if(!volume) {
3381 skip("Failed to create a volume texture\n");
3382 goto out;
3383 }
3384
3385 hr = IDirect3DVolumeTexture9_LockBox(volume, 0, &lb, NULL, 0);
3386 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_LockBox failed with %s\n", DXGetErrorString9(hr));
3387 for(z = 0; z < 32; z++) {
3388 for(y = 0; y < 32; y++) {
3389 for(x = 0; x < 32; x++) {
3390 char size = (fmt == D3DFMT_A16B16G16R16 ? 8 : 4);
3391 void *mem = ((char *) lb.pBits) + y * lb.RowPitch + z * lb.SlicePitch + x * size;
3392 float r_f = (float) x / 31.0;
3393 float g_f = (float) y / 31.0;
3394 float b_f = (float) z / 31.0;
3395
3396 if(fmt == D3DFMT_A16B16G16R16) {
3397 unsigned short *mem_s = mem;
3398 mem_s[0] = r_f * 65535.0;
3399 mem_s[1] = g_f * 65535.0;
3400 mem_s[2] = b_f * 65535.0;
3401 mem_s[3] = 65535;
3402 } else {
3403 unsigned char *mem_c = mem;
3404 mem_c[0] = b_f * 255.0;
3405 mem_c[1] = g_f * 255.0;
3406 mem_c[2] = r_f * 255.0;
3407 mem_c[3] = 255;
3408 }
3409 }
3410 }
3411 }
3412 hr = IDirect3DVolumeTexture9_UnlockBox(volume, 0);
3413 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %s\n", DXGetErrorString9(hr));
3414
3415 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) volume);
3416 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %s\n", DXGetErrorString9(hr));
3417
3418 hr = IDirect3DDevice9_BeginScene(device);
3419 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3420 if(SUCCEEDED(hr))
3421 {
3422 float quad1[] = {
3423 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3424 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3425 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3426 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3427 };
3428 float quad2[] = {
3429 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3430 -1.0, 1.0, 0.1, 1.0, 1.0, 1.0,
3431 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3432 0.0, 1.0, 0.1, 1.0, 1.0, 1.0
3433 };
3434 float quad3[] = {
3435 0.0, 0.0, 0.1, 0.0, 0.0,
3436 0.0, 1.0, 0.1, 0.0, 0.0,
3437 1.0, 0.0, 0.1, 0.0, 0.0,
3438 1.0, 1.0, 0.1, 0.0, 0.0
3439 };
3440 float quad4[] = {
3441 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3442 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3443 1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3444 1.0, 0.0, 0.1, 1.0, 1.0, 1.0
3445 };
3446 float mat[16] = {1.0, 0.0, 0.0, 0.0,
3447 0.0, 0.0, 1.0, 0.0,
3448 0.0, 1.0, 0.0, 0.0,
3449 0.0, 0.0, 0.0, 1.0};
3450 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3451 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3452
3453 /* Draw a quad with all 3 coords enabled. Nothing fancy. v and w are swapped, but have the same
3454 * values
3455 */
3456 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3457 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3458 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3);
3459 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3460 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3461 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3462
3463 /* Now disable the w coordinate. Does that change the input, or the output. The coordinates
3464 * are swapped by the matrix. If it changes the input, the v coord will be missing(green),
3465 * otherwise the w will be missing(blue).
3466 * turns out that on nvidia cards the blue color is missing, so it is an output modification.
3467 * On ATI cards the COUNT2 is ignored, and it behaves in the same way as COUNT3.
3468 */
3469 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3470 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3471 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
3472 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3473
3474 /* default values? Set up the identity matrix, pass in 2 vertex coords, and enable 4 */
3475 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3476 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3477 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3478 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3479 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3480 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3481 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3482 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3483
3484 /* D3DTTFF_COUNT1. Set a NULL matrix, and count1, pass in all values as 1.0. Nvidia has count1 ==
3485 * disable. ATI extends it up to the amount of values needed for the volume texture
3486 */
3487 memset(mat, 0, sizeof(mat));
3488 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3489 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3490 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3491 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3492 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3493 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3494 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3495 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3496
3497 hr = IDirect3DDevice9_EndScene(device);
3498 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3499 }
3500 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3501 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3502
3503 color = getPixelColor(device, 160, 360);
3504 ok(color == 0x00ffffff, "quad 1 has color %08x, expected 0x00ffffff\n", color);
3505 color = getPixelColor(device, 160, 120);
3506 ok(color == 0x00ffff00 /* NV*/ || color == 0x00ffffff /* ATI */,
3507 "quad 2 has color %08x, expected 0x00ffff00\n", color);
3508 color = getPixelColor(device, 480, 120);
3509 ok(color == 0x000000ff, "quad 3 has color %08x, expected 0x000000ff\n", color);
3510 color = getPixelColor(device, 480, 360);
3511 ok(color == 0x00ffffff || color == 0x0000ff00, "quad 4 has color %08x, expected 0x00ffffff\n", color);
3512
3513 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff303030, 0.0, 0);
3514 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3515 hr = IDirect3DDevice9_BeginScene(device);
3516 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
3517 if(SUCCEEDED(hr))
3518 {
3519 float quad1[] = {
3520 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3521 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3522 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3523 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3524 };
3525 float quad2[] = {
3526 -1.0, 0.0, 0.1,
3527 -1.0, 1.0, 0.1,
3528 0.0, 0.0, 0.1,
3529 0.0, 1.0, 0.1,
3530 };
3531 float quad3[] = {
3532 0.0, 0.0, 0.1, 1.0,
3533 0.0, 1.0, 0.1, 1.0,
3534 1.0, 0.0, 0.1, 1.0,
3535 1.0, 1.0, 0.1, 1.0
3536 };
3537 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3538 0.0, 0.0, 0.0, 0.0,
3539 0.0, 0.0, 0.0, 0.0,
3540 0.0, 1.0, 0.0, 0.0};
3541 float mat2[16] = {0.0, 0.0, 0.0, 1.0,
3542 1.0, 0.0, 0.0, 0.0,
3543 0.0, 1.0, 0.0, 0.0,
3544 0.0, 0.0, 1.0, 0.0};
3545 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3546 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3547
3548 /* Default values? 4 coords used, 3 passed. What happens to the 4th?
3549 */
3550 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3551 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3552 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3553 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3554 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3555 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3556
3557 /* None passed */
3558 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3559 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3560 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3561 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
3562 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
3563 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3564
3565 /* 4 used, 1 passed */
3566 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
3567 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3568 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat2);
3569 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3570 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 4 * sizeof(float));
3571 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3572
3573 hr = IDirect3DDevice9_EndScene(device);
3574 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
3575 }
3576 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3577 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3578 color = getPixelColor(device, 160, 360);
3579 ok(color == 0x0000ff00, "quad 1 has color %08x, expected 0x0000ff00\n", color);
3580 color = getPixelColor(device, 160, 120);
3581 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x00000000\n", color);
3582 color = getPixelColor(device, 480, 120);
3583 ok(color == 0x00ff0000, "quad 3 has color %08x, expected 0x00ff0000\n", color);
3584 /* Quad4: unused */
3585
3586 IDirect3DVolumeTexture9_Release(volume);
3587
3588 out:
3589 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
3590 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
3591 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
3592 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3593 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3594 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %s\n", DXGetErrorString9(hr));
3595 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3596 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
3597 IDirect3DVertexDeclaration9_Release(decl);
3598 IDirect3DVertexDeclaration9_Release(decl2);
3599 IDirect3DVertexDeclaration9_Release(decl3);
3600 }
3601
3602 static void texdepth_test(IDirect3DDevice9 *device)
3603 {
3604 IDirect3DPixelShader9 *shader;
3605 HRESULT hr;
3606 const float texdepth_test_data1[] = { 0.25, 2.0, 0.0, 0.0};
3607 const float texdepth_test_data2[] = { 0.25, 0.5, 0.0, 0.0};
3608 const float texdepth_test_data3[] = {-1.00, 0.1, 0.0, 0.0};
3609 const float texdepth_test_data4[] = {-0.25, -0.5, 0.0, 0.0};
3610 const float texdepth_test_data5[] = { 1.00, -0.1, 0.0, 0.0};
3611 const float texdepth_test_data6[] = { 1.00, 0.5, 0.0, 0.0};
3612 const float texdepth_test_data7[] = { 0.50, 0.0, 0.0, 0.0};
3613 DWORD shader_code[] = {
3614 0xffff0104, /* ps_1_4 */
3615 0x00000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c1, 0, 0, 1, 1 */
3616 0x00000001, 0x800f0005, 0xa0e40000, /* mov r5, c0 */
3617 0x0000fffd, /* phase */
3618 0x00000057, 0x800f0005, /* texdepth r5 */
3619 0x00000001, 0x800f0000, 0xa0e40001, /* mov r0, c1 */
3620 0x0000ffff /* end */
3621 };
3622 DWORD color;
3623 float vertex[] = {
3624 -1.0, -1.0, 0.0,
3625 1.0, -1.0, 1.0,
3626 -1.0, 1.0, 0.0,
3627 1.0, 1.0, 1.0
3628 };
3629
3630 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
3631 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3632
3633 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffff00, 0.0, 0);
3634 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
3635 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
3636 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3637 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3638 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3639 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_ALWAYS);
3640 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3641 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3642
3643 /* Fill the depth buffer with a gradient */
3644 hr = IDirect3DDevice9_BeginScene(device);
3645 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3646 if(SUCCEEDED(hr))
3647 {
3648 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3649 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3650 hr = IDirect3DDevice9_EndScene(device);
3651 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3652 }
3653
3654 /* Now perform the actual tests. Same geometry, but with the shader */
3655 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
3656 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3657 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
3658 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3659 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3660 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3661
3662 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data1, 1);
3663 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3664 hr = IDirect3DDevice9_BeginScene(device);
3665 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3666 if(SUCCEEDED(hr))
3667 {
3668 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3669 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3670
3671 hr = IDirect3DDevice9_EndScene(device);
3672 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3673 }
3674
3675 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3676 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3677 color = getPixelColor(device, 158, 240);
3678 ok(color == 0x000000ff, "Pixel 158(25%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3679 color = getPixelColor(device, 162, 240);
3680 ok(color == 0x00ffffff, "Pixel 158(25%% + 2 pixel) has color %08x, expected 0x00ffffff\n", color);
3681
3682 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3683
3684 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data2, 1);
3685 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3686 hr = IDirect3DDevice9_BeginScene(device);
3687 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3688 if(SUCCEEDED(hr))
3689 {
3690 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3691 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3692
3693 hr = IDirect3DDevice9_EndScene(device);
3694 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3695 }
3696
3697 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3698 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3699 color = getPixelColor(device, 318, 240);
3700 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3701 color = getPixelColor(device, 322, 240);
3702 ok(color == 0x00ffff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3703
3704 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3705
3706 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data3, 1);
3707 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3708 hr = IDirect3DDevice9_BeginScene(device);
3709 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3710 if(SUCCEEDED(hr))
3711 {
3712 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3713 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3714
3715 hr = IDirect3DDevice9_EndScene(device);
3716 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3717 }
3718 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3719 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3720
3721 color = getPixelColor(device, 1, 240);
3722 ok(color == 0x00ff0000, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ff0000\n", color);
3723
3724 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3725
3726 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data4, 1);
3727 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3728 hr = IDirect3DDevice9_BeginScene(device);
3729 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3730 if(SUCCEEDED(hr))
3731 {
3732 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3733 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3734
3735 hr = IDirect3DDevice9_EndScene(device);
3736 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3737 }
3738 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3739 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3740 color = getPixelColor(device, 318, 240);
3741 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3742 color = getPixelColor(device, 322, 240);
3743 ok(color == 0x0000ff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x0000ff00\n", color);
3744
3745 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3746
3747 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data5, 1);
3748 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3749 hr = IDirect3DDevice9_BeginScene(device);
3750 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3751 if(SUCCEEDED(hr))
3752 {
3753 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3754 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3755
3756 hr = IDirect3DDevice9_EndScene(device);
3757 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3758 }
3759 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3760 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3761
3762 color = getPixelColor(device, 1, 240);
3763 ok(color == 0x00ffff00, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3764
3765 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3766
3767 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data6, 1);
3768 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3769 hr = IDirect3DDevice9_BeginScene(device);
3770 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3771 if(SUCCEEDED(hr))
3772 {
3773 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3774 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3775
3776 hr = IDirect3DDevice9_EndScene(device);
3777 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3778 }
3779 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3780 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3781
3782 color = getPixelColor(device, 638, 240);
3783 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3784
3785 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3786
3787 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data7, 1);
3788 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
3789 hr = IDirect3DDevice9_BeginScene(device);
3790 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3791 if(SUCCEEDED(hr))
3792 {
3793 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3794 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3795
3796 hr = IDirect3DDevice9_EndScene(device);
3797 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3798 }
3799 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3800 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3801
3802 color = getPixelColor(device, 638, 240);
3803 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3804
3805 /* Cleanup */
3806 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3807 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3808 IDirect3DPixelShader9_Release(shader);
3809
3810 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
3811 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3812 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3813 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
3814 }
3815
3816 static void texkill_test(IDirect3DDevice9 *device)
3817 {
3818 IDirect3DPixelShader9 *shader;
3819 HRESULT hr;
3820 DWORD color;
3821
3822 const float vertex[] = {
3823 /* bottom top right left */
3824 -1.0, -1.0, 1.0, -0.1, 0.9, 0.9, -0.1,
3825 1.0, -1.0, 0.0, 0.9, -0.1, 0.9, -0.1,
3826 -1.0, 1.0, 1.0, -0.1, 0.9, -0.1, 0.9,
3827 1.0, 1.0, 0.0, 0.9, -0.1, -0.1, 0.9,
3828 };
3829
3830 DWORD shader_code_11[] = {
3831 0xffff0101, /* ps_1_1 */
3832 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
3833 0x00000041, 0xb00f0000, /* texkill t0 */
3834 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
3835 0x0000ffff /* end */
3836 };
3837 DWORD shader_code_20[] = {
3838 0xffff0200, /* ps_2_0 */
3839 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
3840 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c0, 0.0, 0.0, 1.0, 1.0 */
3841 0x01000041, 0xb00f0000, /* texkill t0 */
3842 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
3843 0x0000ffff /* end */
3844 };
3845
3846 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3847 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3848 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader);
3849 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3850
3851 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3852 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3853 hr = IDirect3DDevice9_BeginScene(device);
3854 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3855 if(SUCCEEDED(hr))
3856 {
3857 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE4(0) | D3DFVF_TEX1);
3858 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
3859 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3860 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3861 hr = IDirect3DDevice9_EndScene(device);
3862 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3863 }
3864 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3865 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3866 color = getPixelColor(device, 63, 46);
3867 ok(color == 0x0000ff00, "Pixel 63/46 has color %08x, expected 0x0000ff00\n", color);
3868 color = getPixelColor(device, 66, 46);
3869 ok(color == 0x0000ff00, "Pixel 66/64 has color %08x, expected 0x0000ff00\n", color);
3870 color = getPixelColor(device, 63, 49);
3871 ok(color == 0x0000ff00, "Pixel 63/49 has color %08x, expected 0x0000ff00\n", color);
3872 color = getPixelColor(device, 66, 49);
3873 ok(color == 0x00ff0000, "Pixel 66/49 has color %08x, expected 0x00ff0000\n", color);
3874
3875 color = getPixelColor(device, 578, 46);
3876 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3877 color = getPixelColor(device, 575, 46);
3878 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3879 color = getPixelColor(device, 578, 49);
3880 ok(color == 0x0000ff00, "Pixel 578/49 has color %08x, expected 0x0000ff00\n", color);
3881 color = getPixelColor(device, 575, 49);
3882 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3883
3884 color = getPixelColor(device, 63, 430);
3885 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3886 color = getPixelColor(device, 63, 433);
3887 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3888 color = getPixelColor(device, 66, 433);
3889 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3890 color = getPixelColor(device, 66, 430);
3891 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3892
3893 color = getPixelColor(device, 578, 430);
3894 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3895 color = getPixelColor(device, 578, 433);
3896 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3897 color = getPixelColor(device, 575, 433);
3898 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3899 color = getPixelColor(device, 575, 430);
3900 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3901
3902 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3903 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3904 IDirect3DPixelShader9_Release(shader);
3905
3906 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3907 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
3908 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader);
3909 if(FAILED(hr)) {
3910 skip("Failed to create 2.0 test shader, most likely not supported\n");
3911 return;
3912 }
3913
3914 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3915 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
3916 hr = IDirect3DDevice9_BeginScene(device);
3917 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
3918 if(SUCCEEDED(hr))
3919 {
3920 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3921 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3922 hr = IDirect3DDevice9_EndScene(device);
3923 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
3924 }
3925 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3926
3927 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
3928 color = getPixelColor(device, 63, 46);
3929 ok(color == 0x00ffff00, "Pixel 63/46 has color %08x, expected 0x00ffff00\n", color);
3930 color = getPixelColor(device, 66, 46);
3931 ok(color == 0x00ffff00, "Pixel 66/64 has color %08x, expected 0x00ffff00\n", color);
3932 color = getPixelColor(device, 63, 49);
3933 ok(color == 0x00ffff00, "Pixel 63/49 has color %08x, expected 0x00ffff00\n", color);
3934 color = getPixelColor(device, 66, 49);
3935 ok(color == 0x000000ff, "Pixel 66/49 has color %08x, expected 0x000000ff\n", color);
3936
3937 color = getPixelColor(device, 578, 46);
3938 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3939 color = getPixelColor(device, 575, 46);
3940 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3941 color = getPixelColor(device, 578, 49);
3942 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3943 color = getPixelColor(device, 575, 49);
3944 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3945
3946 color = getPixelColor(device, 63, 430);
3947 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3948 color = getPixelColor(device, 63, 433);
3949 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3950 color = getPixelColor(device, 66, 433);
3951 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3952 color = getPixelColor(device, 66, 430);
3953 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3954
3955 color = getPixelColor(device, 578, 430);
3956 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
3957 color = getPixelColor(device, 578, 433);
3958 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
3959 color = getPixelColor(device, 575, 433);
3960 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
3961 color = getPixelColor(device, 575, 430);
3962 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
3963
3964 /* Cleanup */
3965 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3966 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
3967 IDirect3DPixelShader9_Release(shader);
3968 }
3969
3970 static void x8l8v8u8_test(IDirect3DDevice9 *device)
3971 {
3972 IDirect3D9 *d3d9;
3973 HRESULT hr;
3974 IDirect3DTexture9 *texture;
3975 IDirect3DPixelShader9 *shader;
3976 IDirect3DPixelShader9 *shader2;
3977 D3DLOCKED_RECT lr;
3978 DWORD color;
3979 DWORD shader_code[] = {
3980 0xffff0101, /* ps_1_1 */
3981 0x00000042, 0xb00f0000, /* tex t0 */
3982 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
3983 0x0000ffff /* end */
3984 };
3985 DWORD shader_code2[] = {
3986 0xffff0101, /* ps_1_1 */
3987 0x00000042, 0xb00f0000, /* tex t0 */
3988 0x00000001, 0x800f0000, 0xb0ff0000, /* mov r0, t0.w */
3989 0x0000ffff /* end */
3990 };
3991
3992 float quad[] = {
3993 -1.0, -1.0, 0.1, 0.5, 0.5,
3994 1.0, -1.0, 0.1, 0.5, 0.5,
3995 -1.0, 1.0, 0.1, 0.5, 0.5,
3996 1.0, 1.0, 0.1, 0.5, 0.5,
3997 };
3998
3999 memset(&lr, 0, sizeof(lr));
4000 IDirect3DDevice9_GetDirect3D(device, &d3d9);
4001 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4002 0, D3DRTYPE_TEXTURE, D3DFMT_X8L8V8U8);
4003 IDirect3D9_Release(d3d9);
4004 if(FAILED(hr)) {
4005 skip("No D3DFMT_X8L8V8U8 support\n");
4006 };
4007
4008 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
4009 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4010
4011 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8L8V8U8, D3DPOOL_MANAGED, &texture, NULL);
4012 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed (%08x)\n", hr);
4013 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
4014 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed (%08x)\n", hr);
4015 *((DWORD *) lr.pBits) = 0x11ca3141;
4016 hr = IDirect3DTexture9_UnlockRect(texture, 0);
4017 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed (%08x)\n", hr);
4018
4019 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4020 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4021 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code2, &shader2);
4022 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4023
4024 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4025 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
4026 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4027 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4028 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4029 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4030
4031 hr = IDirect3DDevice9_BeginScene(device);
4032 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4033 if(SUCCEEDED(hr))
4034 {
4035 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4036 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4037
4038 hr = IDirect3DDevice9_EndScene(device);
4039 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4040 }
4041 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4042 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4043 color = getPixelColor(device, 578, 430);
4044 ok(color == 0x008262ca || color == 0x008363ca || color == 0x008362ca,
4045 "D3DFMT_X8L8V8U8 = 0x112131ca returns color %08x, expected 0x008262ca\n", color);
4046
4047 hr = IDirect3DDevice9_SetPixelShader(device, shader2);
4048 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4049 hr = IDirect3DDevice9_BeginScene(device);
4050 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4051 if(SUCCEEDED(hr))
4052 {
4053 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4054 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4055
4056 hr = IDirect3DDevice9_EndScene(device);
4057 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4058 }
4059 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4060 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4061 color = getPixelColor(device, 578, 430);
4062 ok(color == 0x00ffffff, "w component of D3DFMT_X8L8V8U8 = 0x11ca3141 returns color %08x\n", color);
4063
4064 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4065 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4066 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4067 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4068 IDirect3DPixelShader9_Release(shader);
4069 IDirect3DPixelShader9_Release(shader2);
4070 IDirect3DTexture9_Release(texture);
4071 }
4072
4073 static void autogen_mipmap_test(IDirect3DDevice9 *device)
4074 {
4075 HRESULT hr;
4076 IDirect3D9 *d3d;
4077 IDirect3DTexture9 *texture = NULL;
4078 IDirect3DSurface9 *surface;
4079 DWORD color;
4080 const RECT r1 = {256, 256, 512, 512};
4081 const RECT r2 = {512, 256, 768, 512};
4082 const RECT r3 = {256, 512, 512, 768};
4083 const RECT r4 = {512, 512, 768, 768};
4084 unsigned int x, y;
4085 D3DLOCKED_RECT lr;
4086 memset(&lr, 0, sizeof(lr));
4087
4088 IDirect3DDevice9_GetDirect3D(device, &d3d);
4089 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4090 D3DUSAGE_AUTOGENMIPMAP, D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8) != D3D_OK) {
4091 skip("No autogenmipmap support\n");
4092 IDirect3D9_Release(d3d);
4093 return;
4094 }
4095 IDirect3D9_Release(d3d);
4096
4097 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
4098 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4099
4100 /* Make the mipmap big, so that a smaller mipmap is used
4101 */
4102 hr = IDirect3DDevice9_CreateTexture(device, 1024, 1024, 0, D3DUSAGE_AUTOGENMIPMAP,
4103 D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0);
4104 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
4105
4106 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
4107 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel returned %s\n", DXGetErrorString9(hr));
4108 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
4109 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %s\n", DXGetErrorString9(hr));
4110 for(y = 0; y < 1024; y++) {
4111 for(x = 0; x < 1024; x++) {
4112 DWORD *dst = (DWORD *) (((BYTE *) lr.pBits) + y * lr.Pitch + x * 4);
4113 POINT pt;
4114
4115 pt.x = x;
4116 pt.y = y;
4117 if(PtInRect(&r1, pt)) {
4118 *dst = 0xffff0000;
4119 } else if(PtInRect(&r2, pt)) {
4120 *dst = 0xff00ff00;
4121 } else if(PtInRect(&r3, pt)) {
4122 *dst = 0xff0000ff;
4123 } else if(PtInRect(&r4, pt)) {
4124 *dst = 0xff000000;
4125 } else {
4126 *dst = 0xffffffff;
4127 }
4128 }
4129 }
4130 hr = IDirect3DSurface9_UnlockRect(surface);
4131 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned %s\n", DXGetErrorString9(hr));
4132 IDirect3DSurface9_Release(surface);
4133
4134 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4135 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
4136 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
4137 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
4138
4139 hr = IDirect3DDevice9_BeginScene(device);
4140 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4141 if(SUCCEEDED(hr)) {
4142 const float quad[] = {
4143 -0.5, -0.5, 0.1, 0.0, 0.0,
4144 -0.5, 0.5, 0.1, 0.0, 1.0,
4145 0.5, -0.5, 0.1, 1.0, 0.0,
4146 0.5, 0.5, 0.1, 1.0, 1.0
4147 };
4148
4149 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4150 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4151 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4152 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4153 hr = IDirect3DDevice9_EndScene(device);
4154 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4155 }
4156 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4157 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
4158 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
4159 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
4160 IDirect3DTexture9_Release(texture);
4161
4162 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4163 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4164 color = getPixelColor(device, 200, 200);
4165 ok(color == 0x00ffffff, "pixel 200/200 has color %08x, expected 0x00ffffff\n", color);
4166 color = getPixelColor(device, 280, 200);
4167 ok(color == 0x000000ff, "pixel 280/200 has color %08x, expected 0x000000ff\n", color);
4168 color = getPixelColor(device, 360, 200);
4169 ok(color == 0x00000000, "pixel 360/200 has color %08x, expected 0x00000000\n", color);
4170 color = getPixelColor(device, 440, 200);
4171 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4172 color = getPixelColor(device, 200, 270);
4173 ok(color == 0x00ffffff, "pixel 200/270 has color %08x, expected 0x00ffffff\n", color);
4174 color = getPixelColor(device, 280, 270);
4175 ok(color == 0x00ff0000, "pixel 280/270 has color %08x, expected 0x00ff0000\n", color);
4176 color = getPixelColor(device, 360, 270);
4177 ok(color == 0x0000ff00, "pixel 360/270 has color %08x, expected 0x0000ff00\n", color);
4178 color = getPixelColor(device, 440, 270);
4179 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4180 }
4181
4182 static void test_constant_clamp_vs(IDirect3DDevice9 *device)
4183 {
4184 IDirect3DVertexShader9 *shader_11, *shader_11_2, *shader_20, *shader_20_2;
4185 IDirect3DVertexDeclaration9 *decl;
4186 HRESULT hr;
4187 DWORD color;
4188 DWORD shader_code_11[] = {
4189 0xfffe0101, /* vs_1_1 */
4190 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4191 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4192 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4193 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4194 0x0000ffff /* end */
4195 };
4196 DWORD shader_code_11_2[] = {
4197 0xfffe0101, /* vs_1_1 */
4198 0x00000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000, /* dcl ... */
4199 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* dcl ... */
4200 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4201 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4202 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4203 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4204 0x0000ffff /* end */
4205 };
4206 DWORD shader_code_20[] = {
4207 0xfffe0200, /* vs_2_0 */
4208 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4209 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4210 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4211 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4212 0x0000ffff /* end */
4213 };
4214 DWORD shader_code_20_2[] = {
4215 0xfffe0200, /* vs_2_0 */
4216 0x05000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000,
4217 0x05000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000,
4218 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4219 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4220 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4221 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4222 0x0000ffff /* end */
4223 };
4224 static const D3DVERTEXELEMENT9 decl_elements[] = {
4225 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4226 D3DDECL_END()
4227 };
4228 float quad1[] = {
4229 -1.0, -1.0, 0.1,
4230 0.0, -1.0, 0.1,
4231 -1.0, 0.0, 0.1,
4232 0.0, 0.0, 0.1
4233 };
4234 float quad2[] = {
4235 0.0, -1.0, 0.1,
4236 1.0, -1.0, 0.1,
4237 0.0, 0.0, 0.1,
4238 1.0, 0.0, 0.1
4239 };
4240 float quad3[] = {
4241 0.0, 0.0, 0.1,
4242 1.0, 0.0, 0.1,
4243 0.0, 1.0, 0.1,
4244 1.0, 1.0, 0.1
4245 };
4246 float quad4[] = {
4247 -1.0, 0.0, 0.1,
4248 0.0, 0.0, 0.1,
4249 -1.0, 1.0, 0.1,
4250 0.0, 1.0, 0.1
4251 };
4252 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4253 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4254
4255 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4256 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4257
4258 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11, &shader_11);
4259 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
4260 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11_2, &shader_11_2);
4261 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
4262 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20, &shader_20);
4263 if(FAILED(hr)) shader_20 = NULL;
4264 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20_2, &shader_20_2);
4265 if(FAILED(hr)) shader_20_2 = NULL;
4266 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
4267 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4268
4269 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, test_data_c1, 1);
4270 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %s\n", DXGetErrorString9(hr));
4271 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 2, test_data_c2, 1);
4272 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %s\n", DXGetErrorString9(hr));
4273 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
4274 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4275
4276 hr = IDirect3DDevice9_BeginScene(device);
4277 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4278 if(SUCCEEDED(hr))
4279 {
4280 hr = IDirect3DDevice9_SetVertexShader(device, shader_11);
4281 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4282 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4283 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4284
4285 hr = IDirect3DDevice9_SetVertexShader(device, shader_11_2);
4286 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4287 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4288 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4289
4290 if(shader_20) {
4291 hr = IDirect3DDevice9_SetVertexShader(device, shader_20);
4292 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4293 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4294 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4295 }
4296
4297 if(shader_20_2) {
4298 hr = IDirect3DDevice9_SetVertexShader(device, shader_20_2);
4299 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4300 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4301 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4302 }
4303
4304 hr = IDirect3DDevice9_EndScene(device);
4305 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4306 }
4307 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4308 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4309
4310 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
4311 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4312 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
4313 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
4314
4315 color = getPixelColor(device, 160, 360);
4316 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4317 "quad 1 has color %08x, expected 0x00bfbf80\n", color);
4318 color = getPixelColor(device, 480, 360);
4319 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4320 "quad 2 has color %08x, expected 0x00bfbf80\n", color);
4321 if(shader_20) {
4322 color = getPixelColor(device, 160, 120);
4323 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4324 "quad 3 has color %08x, expected 0x00bfbf80\n", color);
4325 }
4326 if(shader_20_2) {
4327 color = getPixelColor(device, 480, 120);
4328 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4329 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4330 }
4331
4332 IDirect3DVertexDeclaration9_Release(decl);
4333 if(shader_20_2) IDirect3DVertexShader9_Release(shader_20_2);
4334 if(shader_20) IDirect3DVertexShader9_Release(shader_20);
4335 IDirect3DVertexShader9_Release(shader_11_2);
4336 IDirect3DVertexShader9_Release(shader_11);
4337 }
4338
4339 static void constant_clamp_ps_test(IDirect3DDevice9 *device)
4340 {
4341 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_14, *shader_20;
4342 HRESULT hr;
4343 DWORD color;
4344 DWORD shader_code_11[] = {
4345 0xffff0101, /* ps_1_1 */
4346 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4347 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4348 0x0000ffff /* end */
4349 };
4350 DWORD shader_code_12[] = {
4351 0xffff0102, /* ps_1_2 */
4352 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4353 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4354 0x0000ffff /* end */
4355 };
4356 /* Skip 1.3 shaders because we have only 4 quads(ok, could make them smaller if needed).
4357 * 1.2 and 1.4 shaders behave the same, so it's unlikely that 1.3 shaders are different.
4358 * During development of this test, 1.3 shaders were verified too
4359 */
4360 DWORD shader_code_14[] = {
4361 0xffff0104, /* ps_1_4 */
4362 /* Try to make one constant local. It gets clamped too, although the binary contains
4363 * the bigger numbers
4364 */
4365 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* def c2, -0.5, 1.25, 2, 1 */
4366 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4367 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4368 0x0000ffff /* end */
4369 };
4370 DWORD shader_code_20[] = {
4371 0xffff0200, /* ps_2_0 */
4372 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4373 0x03000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4374 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4375 0x0000ffff /* end */
4376 };
4377 float quad1[] = {
4378 -1.0, -1.0, 0.1,
4379 0.0, -1.0, 0.1,
4380 -1.0, 0.0, 0.1,
4381 0.0, 0.0, 0.1
4382 };
4383 float quad2[] = {
4384 0.0, -1.0, 0.1,
4385 1.0, -1.0, 0.1,
4386 0.0, 0.0, 0.1,
4387 1.0, 0.0, 0.1
4388 };
4389 float quad3[] = {
4390 0.0, 0.0, 0.1,
4391 1.0, 0.0, 0.1,
4392 0.0, 1.0, 0.1,
4393 1.0, 1.0, 0.1
4394 };
4395 float quad4[] = {
4396 -1.0, 0.0, 0.1,
4397 0.0, 0.0, 0.1,
4398 -1.0, 1.0, 0.1,
4399 0.0, 1.0, 0.1
4400 };
4401 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4402 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4403
4404 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4405 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4406
4407 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4408 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4409 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4410 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4411 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4412 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4413 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader_20);
4414 if(FAILED(hr)) shader_20 = NULL;
4415
4416 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4417 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4418 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4419 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4420 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4421 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4422
4423 hr = IDirect3DDevice9_BeginScene(device);
4424 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4425 if(SUCCEEDED(hr))
4426 {
4427 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4428 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4429 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4430 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4431
4432 hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4433 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4434 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4435 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4436
4437 hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4438 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4439 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4440 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4441
4442 if(shader_20) {
4443 hr = IDirect3DDevice9_SetPixelShader(device, shader_20);
4444 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4445 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4446 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4447 }
4448
4449 hr = IDirect3DDevice9_EndScene(device);
4450 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4451 }
4452 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4453 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4454
4455 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4456 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4457
4458 color = getPixelColor(device, 160, 360);
4459 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4460 "quad 1 has color %08x, expected 0x00808000\n", color);
4461 color = getPixelColor(device, 480, 360);
4462 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4463 "quad 2 has color %08x, expected 0x00808000\n", color);
4464 color = getPixelColor(device, 480, 120);
4465 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4466 "quad 3 has color %08x, expected 0x00808000\n", color);
4467 if(shader_20) {
4468 color = getPixelColor(device, 160, 120);
4469 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4470 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4471 }
4472
4473 if(shader_20) IDirect3DPixelShader9_Release(shader_20);
4474 IDirect3DPixelShader9_Release(shader_14);
4475 IDirect3DPixelShader9_Release(shader_12);
4476 IDirect3DPixelShader9_Release(shader_11);
4477 }
4478
4479 static void dp2add_ps_test(IDirect3DDevice9 *device)
4480 {
4481 IDirect3DPixelShader9 *shader_dp2add = NULL;
4482 IDirect3DPixelShader9 *shader_dp2add_sat = NULL;
4483 HRESULT hr;
4484 DWORD color;
4485
4486 /* DP2ADD is defined as: (src0.r * src1.r) + (src0.g * src1.g) + src2.
4487 * One D3D restriction of all shader instructions except SINCOS is that no more than 2
4488 * source tokens can be constants. So, for this exercise, we move contents of c0 to
4489 * r0 first.
4490 * The result here for the r,g,b components should be roughly 0.5:
4491 * (0.5 * 0.5) + (0.5 * 0.5) + 0.0 = 0.5 */
4492 static const DWORD shader_code_dp2add[] = {
4493 0xffff0200, /* ps_2_0 */
4494 0x05000051, 0xa00f0000, 0x3f000000, 0x3f000000, 0x3f800000, 0x00000000, /* def c0, 0.5, 0.5, 1.0, 0 */
4495
4496 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4497 0x0400005a, 0x80070000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add r0.rgb, r0, r0, r0.a */
4498
4499 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4500 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4501 0x0000ffff /* end */
4502 };
4503
4504 /* Test the _sat modifier, too. Result here should be:
4505 * DP2: (-0.5 * -0.5) + (-0.5 * -0.5) + 2.0 = 2.5
4506 * _SAT: ==> 1.0
4507 * ADD: (1.0 + -0.5) = 0.5
4508 */
4509 static const DWORD shader_code_dp2add_sat[] = {
4510 0xffff0200, /* ps_2_0 */
4511 0x05000051, 0xa00f0000, 0xbf000000, 0xbf000000, 0x3f800000, 0x40000000, /* def c0, -0.5, -0.5, 1.0, 2.0 */
4512
4513 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4514 0x0400005a, 0x80170000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add_sat r0.rgb, r0, r0, r0.a */
4515 0x03000002, 0x80070000, 0x80e40000, 0xa0000000, /* add r0.rgb, r0, c0.r */
4516
4517 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4518 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4519 0x0000ffff /* end */
4520 };
4521
4522 const float quad[] = {
4523 -1.0, -1.0, 0.1,
4524 1.0, -1.0, 0.1,
4525 -1.0, 1.0, 0.1,
4526 1.0, 1.0, 0.1
4527 };
4528
4529
4530 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
4531 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4532
4533 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add, &shader_dp2add);
4534 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4535
4536 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add_sat, &shader_dp2add_sat);
4537 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4538
4539 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4540 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4541
4542 if (shader_dp2add) {
4543
4544 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add);
4545 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4546
4547 hr = IDirect3DDevice9_BeginScene(device);
4548 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4549 if(SUCCEEDED(hr))
4550 {
4551 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4552 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4553
4554 hr = IDirect3DDevice9_EndScene(device);
4555 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4556 }
4557 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4558 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4559
4560 color = getPixelColor(device, 360, 240);
4561 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4562
4563 IDirect3DPixelShader9_Release(shader_dp2add);
4564 } else {
4565 skip("dp2add shader creation failed\n");
4566 }
4567
4568 if (shader_dp2add_sat) {
4569
4570 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add_sat);
4571 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4572
4573 hr = IDirect3DDevice9_BeginScene(device);
4574 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4575 if(SUCCEEDED(hr))
4576 {
4577 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4578 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4579
4580 hr = IDirect3DDevice9_EndScene(device);
4581 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4582 }
4583 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4584 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4585
4586 color = getPixelColor(device, 360, 240);
4587 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4588
4589 IDirect3DPixelShader9_Release(shader_dp2add_sat);
4590 } else {
4591 skip("dp2add shader creation failed\n");
4592 }
4593
4594 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4595 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4596 }
4597
4598 static void cnd_test(IDirect3DDevice9 *device)
4599 {
4600 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_13, *shader_14;
4601 IDirect3DPixelShader9 *shader_11_coissue, *shader_12_coissue, *shader_13_coissue, *shader_14_coissue;
4602 HRESULT hr;
4603 DWORD color;
4604 /* ps 1.x shaders are rather picky with writemasks and source swizzles. The dp3 is
4605 * used to copy r0.r to all components of r1, then copy r1.a to c0.a. Essentially it
4606 * does a mov r0.a, r0.r, which isn't allowed as-is in 1.x pixel shaders.
4607 */
4608 DWORD shader_code_11[] = {
4609 0xffff0101, /* ps_1_1 */
4610 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4611 0x00000040, 0xb00f0000, /* texcoord t0 */
4612 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, ???(t0) */
4613 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4614 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4615 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4616 0x0000ffff /* end */
4617 };
4618 DWORD shader_code_12[] = {
4619 0xffff0102, /* ps_1_2 */
4620 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4621 0x00000040, 0xb00f0000, /* texcoord t0 */
4622 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4623 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4624 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4625 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4626 0x0000ffff /* end */
4627 };
4628 DWORD shader_code_13[] = {
4629 0xffff0103, /* ps_1_3 */
4630 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4631 0x00000040, 0xb00f0000, /* texcoord t0 */
4632 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4633 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3, r1, r0, c0 */
4634 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4635 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4636 0x0000ffff /* end */
4637 };
4638 DWORD shader_code_14[] = {
4639 0xffff0104, /* ps_1_3 */
4640 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4641 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4642 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4643 0x00000050, 0x800f0000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0, c1, c2 */
4644 0x0000ffff /* end */
4645 };
4646
4647 /* Special fun: The coissue flag on cnd: Apparently cnd always selects the 2nd source,
4648 * as if the src0 comparison against 0.5 always evaluates to true. The coissue flag isn't
4649 * set by the compiler, it was added manually after compilation. It isn't always allowed,
4650 * only if there's a mov r0.a, XXXX, and the cnd instruction writes to r0.xyz, otherwise
4651 * native CreatePixelShader returns an error.
4652 *
4653 * The shader attempts to test the range [-1;1] against coissued cnd, which is a bit tricky.
4654 * The input from t0 is [0;1]. 0.5 is substracted, then we have to multiply with 2. Since
4655 * constants are clamped to [-1;1], a 2.0 is constructed by adding c0.r(=1.0) to c0.r into r1.r,
4656 * then r1(2.0, 0.0, 0.0, 0.0) is passed to dp3(explained above).
4657 */
4658 DWORD shader_code_11_coissue[] = {
4659 0xffff0101, /* ps_1_1 */
4660 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4661 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4662 0x00000040, 0xb00f0000, /* texcoord t0 */
4663 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4664 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4665 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4666 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4667 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4668 /* 0x40000000 = D3DSI_COISSUE */
4669 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4670 0x0000ffff /* end */
4671 };
4672 DWORD shader_code_12_coissue[] = {
4673 0xffff0102, /* ps_1_2 */
4674 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4675 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4676 0x00000040, 0xb00f0000, /* texcoord t0 */
4677 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4678 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4679 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4680 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4681 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4682 /* 0x40000000 = D3DSI_COISSUE */
4683 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4684 0x0000ffff /* end */
4685 };
4686 DWORD shader_code_13_coissue[] = {
4687 0xffff0103, /* ps_1_3 */
4688 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4689 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4690 0x00000040, 0xb00f0000, /* texcoord t0 */
4691 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4692 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4693 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4694 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4695 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4696 /* 0x40000000 = D3DSI_COISSUE */
4697 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4698 0x0000ffff /* end */
4699 };
4700 /* ps_1_4 does not have a different cnd behavior, just pass the [0;1] texcrd result to cnd, it will
4701 * compare against 0.5
4702 */
4703 DWORD shader_code_14_coissue[] = {
4704 0xffff0104, /* ps_1_4 */
4705 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4706 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4707 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4708 /* 0x40000000 = D3DSI_COISSUE */
4709 0x40000050, 0x80070000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0, c1, c2 */
4710 0x0000ffff /* end */
4711 };
4712 float quad1[] = {
4713 -1.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4714 0.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4715 -1.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4716 0.0, 0.0, 0.1, 1.0, 1.0, 0.0
4717 };
4718 float quad2[] = {
4719 0.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4720 1.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4721 0.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4722 1.0, 0.0, 0.1, 1.0, 1.0, 0.0
4723 };
4724 float quad3[] = {
4725 0.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4726 1.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4727 0.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4728 1.0, 1.0, 0.1, 1.0, 1.0, 0.0
4729 };
4730 float quad4[] = {
4731 -1.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4732 0.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4733 -1.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4734 0.0, 1.0, 0.1, 1.0, 1.0, 0.0
4735 };
4736 float test_data_c1[4] = { 0.0, 0.0, 0.0, 0.0};
4737 float test_data_c2[4] = { 1.0, 1.0, 1.0, 1.0};
4738 float test_data_c1_coi[4] = { 0.0, 1.0, 0.0, 0.0};
4739 float test_data_c2_coi[4] = { 1.0, 0.0, 1.0, 1.0};
4740
4741 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4742 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4743
4744 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4745 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4746 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4747 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4748 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13, &shader_13);
4749 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4750 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4751 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4752 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11_coissue, &shader_11_coissue);
4753 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4754 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12_coissue, &shader_12_coissue);
4755 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4756 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13_coissue, &shader_13_coissue);
4757 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4758 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14_coissue, &shader_14_coissue);
4759 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
4760
4761 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4762 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4763 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4764 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4765 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4766 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
4767
4768 hr = IDirect3DDevice9_BeginScene(device);
4769 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4770 if(SUCCEEDED(hr))
4771 {
4772 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4773 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4774 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4775 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4776
4777 hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4778 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4779 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4780 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4781
4782 hr = IDirect3DDevice9_SetPixelShader(device, shader_13);
4783 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4784 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4785 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4786
4787 hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4788 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4789 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4790 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4791
4792 hr = IDirect3DDevice9_EndScene(device);
4793 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4794 }
4795 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4796 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4797
4798 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4799 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
4800
4801 /* This is the 1.4 test. Each component(r, g, b) is tested separately against 0.5 */
4802 color = getPixelColor(device, 158, 118);
4803 ok(color == 0x00ff00ff, "pixel 158, 118 has color %08x, expected 0x00ff00ff\n", color);
4804 color = getPixelColor(device, 162, 118);
4805 ok(color == 0x000000ff, "pixel 162, 118 has color %08x, expected 0x000000ff\n", color);
4806 color = getPixelColor(device, 158, 122);
4807 ok(color == 0x00ffffff, "pixel 162, 122 has color %08x, expected 0x00ffffff\n", color);
4808 color = getPixelColor(device, 162, 122);
4809 ok(color == 0x0000ffff, "pixel 162, 122 has color %08x, expected 0x0000ffff\n", color);
4810
4811 /* 1.1 shader. All 3 components get set, based on the .w comparison */
4812 color = getPixelColor(device, 158, 358);
4813 ok(color == 0x00ffffff, "pixel 158, 358 has color %08x, expected 0x00ffffff\n", color);
4814 color = getPixelColor(device, 162, 358);
4815 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4816 "pixel 162, 358 has color %08x, expected 0x00000000\n", color);
4817 color = getPixelColor(device, 158, 362);
4818 ok(color == 0x00ffffff, "pixel 158, 362 has color %08x, expected 0x00ffffff\n", color);
4819 color = getPixelColor(device, 162, 362);
4820 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4821 "pixel 162, 362 has color %08x, expected 0x00000000\n", color);
4822
4823 /* 1.2 shader */
4824 color = getPixelColor(device, 478, 358);
4825 ok(color == 0x00ffffff, "pixel 478, 358 has color %08x, expected 0x00ffffff\n", color);
4826 color = getPixelColor(device, 482, 358);
4827 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4828 "pixel 482, 358 has color %08x, expected 0x00000000\n", color);
4829 color = getPixelColor(device, 478, 362);
4830 ok(color == 0x00ffffff, "pixel 478, 362 has color %08x, expected 0x00ffffff\n", color);
4831 color = getPixelColor(device, 482, 362);
4832 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4833 "pixel 482, 362 has color %08x, expected 0x00000000\n", color);
4834
4835 /* 1.3 shader */
4836 color = getPixelColor(device, 478, 118);
4837 ok(color == 0x00ffffff, "pixel 478, 118 has color %08x, expected 0x00ffffff\n", color);
4838 color = getPixelColor(device, 482, 118);
4839 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4840 "pixel 482, 118 has color %08x, expected 0x00000000\n", color);
4841 color = getPixelColor(device, 478, 122);
4842 ok(color == 0x00ffffff, "pixel 478, 122 has color %08x, expected 0x00ffffff\n", color);
4843 color = getPixelColor(device, 482, 122);
4844 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4845 "pixel 482, 122 has color %08x, expected 0x00000000\n", color);
4846
4847 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4848 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4849 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1_coi, 1);
4850 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4851 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2_coi, 1);
4852 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %s\n", DXGetErrorString9(hr));
4853
4854 hr = IDirect3DDevice9_BeginScene(device);
4855 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4856 if(SUCCEEDED(hr))
4857 {
4858 hr = IDirect3DDevice9_SetPixelShader(device, shader_11_coissue);
4859 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4860 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4861 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4862
4863 hr = IDirect3DDevice9_SetPixelShader(device, shader_12_coissue);
4864 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4865 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4866 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4867
4868 hr = IDirect3DDevice9_SetPixelShader(device, shader_13_coissue);
4869 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4870 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4871 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4872
4873 hr = IDirect3DDevice9_SetPixelShader(device, shader_14_coissue);
4874 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
4875 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4876 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4877
4878 hr = IDirect3DDevice9_EndScene(device);
4879 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4880 }
4881 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4882 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4883
4884 /* This is the 1.4 test. The coissue doesn't change the behavior here, but keep in mind
4885 * that we swapped the values in c1 and c2 to make the other tests return some color
4886 */
4887 color = getPixelColor(device, 158, 118);
4888 ok(color == 0x00ffffff, "pixel 158, 118 has color %08x, expected 0x00ffffff\n", color);
4889 color = getPixelColor(device, 162, 118);
4890 ok(color == 0x0000ffff, "pixel 162, 118 has color %08x, expected 0x0000ffff\n", color);
4891 color = getPixelColor(device, 158, 122);
4892 ok(color == 0x00ff00ff, "pixel 162, 122 has color %08x, expected 0x00ff00ff\n", color);
4893 color = getPixelColor(device, 162, 122);
4894 ok(color == 0x000000ff, "pixel 162, 122 has color %08x, expected 0x000000ff\n", color);
4895
4896 /* 1.1 shader. coissue flag changed the semantic of cnd, c1 is always selected */
4897 color = getPixelColor(device, 158, 358);
4898 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4899 "pixel 158, 358 has color %08x, expected 0x0000ff00\n", color);
4900 color = getPixelColor(device, 162, 358);
4901 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4902 "pixel 162, 358 has color %08x, expected 0x0000ff00\n", color);
4903 color = getPixelColor(device, 158, 362);
4904 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4905 "pixel 158, 362 has color %08x, expected 0x0000ff00\n", color);
4906 color = getPixelColor(device, 162, 362);
4907 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4908 "pixel 162, 362 has color %08x, expected 0x0000ff00\n", color);
4909
4910 /* 1.2 shader */
4911 color = getPixelColor(device, 478, 358);
4912 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4913 "pixel 478, 358 has color %08x, expected 0x0000ff00\n", color);
4914 color = getPixelColor(device, 482, 358);
4915 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4916 "pixel 482, 358 has color %08x, expected 0x0000ff00\n", color);
4917 color = getPixelColor(device, 478, 362);
4918 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4919 "pixel 478, 362 has color %08x, expected 0x0000ff00\n", color);
4920 color = getPixelColor(device, 482, 362);
4921 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4922 "pixel 482, 362 has color %08x, expected 0x0000ff00\n", color);
4923
4924 /* 1.3 shader */
4925 color = getPixelColor(device, 478, 118);
4926 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4927 "pixel 478, 118 has color %08x, expected 0x0000ff00\n", color);
4928 color = getPixelColor(device, 482, 118);
4929 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4930 "pixel 482, 118 has color %08x, expected 0x0000ff00\n", color);
4931 color = getPixelColor(device, 478, 122);
4932 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4933 "pixel 478, 122 has color %08x, expected 0x0000ff00\n", color);
4934 color = getPixelColor(device, 482, 122);
4935 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4936 "pixel 482, 122 has color %08x, expected 0x0000ff00\n", color);
4937
4938 IDirect3DPixelShader9_Release(shader_14_coissue);
4939 IDirect3DPixelShader9_Release(shader_13_coissue);
4940 IDirect3DPixelShader9_Release(shader_12_coissue);
4941 IDirect3DPixelShader9_Release(shader_11_coissue);
4942 IDirect3DPixelShader9_Release(shader_14);
4943 IDirect3DPixelShader9_Release(shader_13);
4944 IDirect3DPixelShader9_Release(shader_12);
4945 IDirect3DPixelShader9_Release(shader_11);
4946 }
4947
4948 static void nested_loop_test(IDirect3DDevice9 *device) {
4949 const DWORD shader_code[] = {
4950 0xffff0300, /* ps_3_0 */
4951 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4952 0x05000051, 0xa00f0001, 0x3d000000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1/32, 0, 0, 0*/
4953 0x05000030, 0xf00f0000, 0x00000004, 0x00000000, 0x00000002, 0x00000000, /* defi i0, 4, 0, 2, 0 */
4954 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4955 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
4956 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
4957 0x03000002, 0x800f0000, 0x80e40000, 0xa0e40001, /* add r0, r0, c1 */
4958 0x0000001d, /* endloop */
4959 0x0000001d, /* endloop */
4960 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4961 0x0000ffff /* end */
4962 };
4963 IDirect3DPixelShader9 *shader;
4964 HRESULT hr;
4965 DWORD color;
4966 const float quad[] = {
4967 -1.0, -1.0, 0.1,
4968 1.0, -1.0, 0.1,
4969 -1.0, 1.0, 0.1,
4970 1.0, 1.0, 0.1
4971 };
4972
4973 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4974 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed with %s\n", DXGetErrorString9(hr));
4975 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4976 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %s\n", DXGetErrorString9(hr));
4977 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4978 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
4979 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x0000ff00, 0.0, 0);
4980 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
4981
4982 hr = IDirect3DDevice9_BeginScene(device);
4983 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
4984 if(SUCCEEDED(hr))
4985 {
4986 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4987 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4988 hr = IDirect3DDevice9_EndScene(device);
4989 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
4990 }
4991 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4992 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
4993
4994 color = getPixelColor(device, 360, 240);
4995 ok(color == 0x007f0000 || color == 0x00800000 || color == 0x00810000,
4996 "Nested loop test returned color 0x%08x, expected 0x00800000\n", color);
4997
4998 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4999 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %s\n", DXGetErrorString9(hr));
5000 IDirect3DPixelShader9_Release(shader);
5001 }
5002
5003 struct varying_test_struct
5004 {
5005 const DWORD *shader_code;
5006 IDirect3DPixelShader9 *shader;
5007 DWORD color, color_rhw;
5008 const char *name;
5009 BOOL todo, todo_rhw;
5010 };
5011
5012 struct hugeVertex
5013 {
5014 float pos_x, pos_y, pos_z, rhw;
5015 float weight_1, weight_2, weight_3, weight_4;
5016 float index_1, index_2, index_3, index_4;
5017 float normal_1, normal_2, normal_3, normal_4;
5018 float fog_1, fog_2, fog_3, fog_4;
5019 float texcoord_1, texcoord_2, texcoord_3, texcoord_4;
5020 float tangent_1, tangent_2, tangent_3, tangent_4;
5021 float binormal_1, binormal_2, binormal_3, binormal_4;
5022 float depth_1, depth_2, depth_3, depth_4;
5023 DWORD diffuse, specular;
5024 };
5025
5026 static void fixed_function_varying_test(IDirect3DDevice9 *device) {
5027 /* dcl_position: fails to compile */
5028 const DWORD blendweight_code[] = {
5029 0xffff0300, /* ps_3_0 */
5030 0x0200001f, 0x80000001, 0x900f0000, /* dcl_blendweight, v0 */
5031 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5032 0x0000ffff /* end */
5033 };
5034 const DWORD blendindices_code[] = {
5035 0xffff0300, /* ps_3_0 */
5036 0x0200001f, 0x80000002, 0x900f0000, /* dcl_blendindices, v0 */
5037 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5038 0x0000ffff /* end */
5039 };
5040 const DWORD normal_code[] = {
5041 0xffff0300, /* ps_3_0 */
5042 0x0200001f, 0x80000003, 0x900f0000, /* dcl_normal, v0 */
5043 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5044 0x0000ffff /* end */
5045 };
5046 /* psize: fails? */
5047 const DWORD texcoord0_code[] = {
5048 0xffff0300, /* ps_3_0 */
5049 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0, v0 */
5050 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5051 0x0000ffff /* end */
5052 };
5053 const DWORD tangent_code[] = {
5054 0xffff0300, /* ps_3_0 */
5055 0x0200001f, 0x80000006, 0x900f0000, /* dcl_tangent, v0 */
5056 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5057 0x0000ffff /* end */
5058 };
5059 const DWORD binormal_code[] = {
5060 0xffff0300, /* ps_3_0 */
5061 0x0200001f, 0x80000007, 0x900f0000, /* dcl_binormal, v0 */
5062 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5063 0x0000ffff /* end */
5064 };
5065 /* tessfactor: fails */
5066 /* positiont: fails */
5067 const DWORD color_code[] = {
5068 0xffff0300, /* ps_3_0 */
5069 0x0200001f, 0x8000000a, 0x900f0000, /* dcl_color0, v0 */
5070 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5071 0x0000ffff /* end */
5072 };
5073 const DWORD fog_code[] = {
5074 0xffff0300, /* ps_3_0 */
5075 0x0200001f, 0x8000000b, 0x900f0000, /* dcl_fog, v0 */
5076 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5077 0x0000ffff /* end */
5078 };
5079 const DWORD depth_code[] = {
5080 0xffff0300, /* ps_3_0 */
5081 0x0200001f, 0x8000000c, 0x900f0000, /* dcl_depth, v0 */
5082 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5083 0x0000ffff /* end */
5084 };
5085 const DWORD specular_code[] = {
5086 0xffff0300, /* ps_3_0 */
5087 0x0200001f, 0x8001000a, 0x900f0000, /* dcl_color1, v0 */
5088 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5089 0x0000ffff /* end */
5090 };
5091 /* sample: fails */
5092
5093 struct varying_test_struct tests[] = {
5094 {blendweight_code, NULL, 0x00000000, 0x00191919, "blendweight" , FALSE, TRUE },
5095 {blendindices_code, NULL, 0x00000000, 0x00000000, "blendindices" , FALSE, FALSE },
5096 {normal_code, NULL, 0x00000000, 0x004c4c4c, "normal" , FALSE, TRUE },
5097 /* Why does dx not forward the texcoord? */
5098 {texcoord0_code, NULL, 0x00000000, 0x00808c8c, "texcoord0" , FALSE, FALSE },
5099 {tangent_code, NULL, 0x00000000, 0x00999999, "tangent" , FALSE, TRUE },
5100 {binormal_code, NULL, 0x00000000, 0x00b2b2b2, "binormal" , FALSE, TRUE },
5101 {color_code, NULL, 0x00e6e6e6, 0x00e6e6e6, "color" , FALSE, FALSE },
5102 {fog_code, NULL, 0x00000000, 0x00666666, "fog" , FALSE, TRUE },
5103 {depth_code, NULL, 0x00000000, 0x00cccccc, "depth" , FALSE, TRUE },
5104 {specular_code, NULL, 0x004488ff, 0x004488ff, "specular" , FALSE, FALSE }
5105 };
5106 /* Declare a monster vertex type :-) */
5107 static const D3DVERTEXELEMENT9 decl_elements[] = {
5108 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5109 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5110 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5111 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5112 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5113 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5114 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5115 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5116 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5117 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5118 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5119 D3DDECL_END()
5120 };
5121 static const D3DVERTEXELEMENT9 decl_elements2[] = {
5122 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
5123 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5124 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5125 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5126 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5127 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5128 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5129 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5130 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5131 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5132 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5133 D3DDECL_END()
5134 };
5135 struct hugeVertex data[4] = {
5136 {
5137 -1.0, -1.0, 0.1, 1.0,
5138 0.1, 0.1, 0.1, 0.1,
5139 0.2, 0.2, 0.2, 0.2,
5140 0.3, 0.3, 0.3, 0.3,
5141 0.4, 0.4, 0.4, 0.4,
5142 0.50, 0.55, 0.55, 0.55,
5143 0.6, 0.6, 0.6, 0.7,
5144 0.7, 0.7, 0.7, 0.6,
5145 0.8, 0.8, 0.8, 0.8,
5146 0xe6e6e6e6, /* 0.9 * 256 */
5147 0x224488ff /* Nothing special */
5148 },
5149 {
5150 1.0, -1.0, 0.1, 1.0,
5151 0.1, 0.1, 0.1, 0.1,
5152 0.2, 0.2, 0.2, 0.2,
5153 0.3, 0.3, 0.3, 0.3,
5154 0.4, 0.4, 0.4, 0.4,
5155 0.50, 0.55, 0.55, 0.55,
5156 0.6, 0.6, 0.6, 0.7,
5157 0.7, 0.7, 0.7, 0.6,
5158 0.8, 0.8, 0.8, 0.8,
5159 0xe6e6e6e6, /* 0.9 * 256 */
5160 0x224488ff /* Nothing special */
5161 },
5162 {
5163 -1.0, 1.0, 0.1, 1.0,
5164 0.1, 0.1, 0.1, 0.1,
5165 0.2, 0.2, 0.2, 0.2,
5166 0.3, 0.3, 0.3, 0.3,
5167 0.4, 0.4, 0.4, 0.4,
5168 0.50, 0.55, 0.55, 0.55,
5169 0.6, 0.6, 0.6, 0.7,
5170 0.7, 0.7, 0.7, 0.6,
5171 0.8, 0.8, 0.8, 0.8,
5172 0xe6e6e6e6, /* 0.9 * 256 */
5173 0x224488ff /* Nothing special */
5174 },
5175 {
5176 1.0, 1.0, 0.1, 1.0,
5177 0.1, 0.1, 0.1, 0.1,
5178 0.2, 0.2, 0.2, 0.2,
5179 0.3, 0.3, 0.3, 0.3,
5180 0.4, 0.4, 0.4, 0.4,
5181 0.50, 0.55, 0.55, 0.55,
5182 0.6, 0.6, 0.6, 0.7,
5183 0.7, 0.7, 0.7, 0.6,
5184 0.8, 0.8, 0.8, 0.8,
5185 0xe6e6e6e6, /* 0.9 * 256 */
5186 0x224488ff /* Nothing special */
5187 },
5188 };
5189 struct hugeVertex data2[4];
5190 IDirect3DVertexDeclaration9 *decl;
5191 IDirect3DVertexDeclaration9 *decl2;
5192 HRESULT hr;
5193 unsigned int i;
5194 DWORD color, r, g, b, r_e, g_e, b_e;
5195 BOOL drawok;
5196
5197 memcpy(data2, data, sizeof(data2));
5198 data2[0].pos_x = 0; data2[0].pos_y = 0;
5199 data2[1].pos_x = 640; data2[1].pos_y = 0;
5200 data2[2].pos_x = 0; data2[2].pos_y = 480;
5201 data2[3].pos_x = 640; data2[3].pos_y = 480;
5202
5203 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
5204 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5205 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
5206 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5207 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
5208 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5209
5210 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5211 {
5212 hr = IDirect3DDevice9_CreatePixelShader(device, tests[i].shader_code, &tests[i].shader);
5213 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed for shader %s, hr = %s\n",
5214 tests[i].name, DXGetErrorString9(hr));
5215 }
5216
5217 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5218 {
5219 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5220 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
5221
5222 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5223 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5224
5225 hr = IDirect3DDevice9_BeginScene(device);
5226 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5227 drawok = FALSE;
5228 if(SUCCEEDED(hr))
5229 {
5230 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data, sizeof(data[0]));
5231 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed (%08x)\n", hr);
5232 drawok = SUCCEEDED(hr);
5233 hr = IDirect3DDevice9_EndScene(device);
5234 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5235 }
5236 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5237 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5238
5239 /* Some drivers reject the combination of ps_3_0 and fixed function vertex processing. Accept
5240 * the failure and do not check the color if it failed
5241 */
5242 if(!drawok) {
5243 continue;
5244 }
5245
5246 color = getPixelColor(device, 360, 240);
5247 r = color & 0x00ff0000 >> 16;
5248 g = color & 0x0000ff00 >> 8;
5249 b = color & 0x000000ff;
5250 r_e = tests[i].color & 0x00ff0000 >> 16;
5251 g_e = tests[i].color & 0x0000ff00 >> 8;
5252 b_e = tests[i].color & 0x000000ff;
5253
5254 if(tests[i].todo) {
5255 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5256 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5257 tests[i].name, color, tests[i].color);
5258 } else {
5259 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5260 "Test %s returned color 0x%08x, expected 0x%08x\n",
5261 tests[i].name, color, tests[i].color);
5262 }
5263 }
5264
5265 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
5266 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
5267 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5268 {
5269 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5270 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
5271
5272 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5273 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5274
5275 hr = IDirect3DDevice9_BeginScene(device);
5276 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5277 if(SUCCEEDED(hr))
5278 {
5279 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data2, sizeof(data2[0]));
5280 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5281 hr = IDirect3DDevice9_EndScene(device);
5282 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5283 }
5284 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5285 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5286
5287 color = getPixelColor(device, 360, 240);
5288 r = color & 0x00ff0000 >> 16;
5289 g = color & 0x0000ff00 >> 8;
5290 b = color & 0x000000ff;
5291 r_e = tests[i].color_rhw & 0x00ff0000 >> 16;
5292 g_e = tests[i].color_rhw & 0x0000ff00 >> 8;
5293 b_e = tests[i].color_rhw & 0x000000ff;
5294
5295 if(tests[i].todo_rhw) {
5296 /* This isn't a weekend's job to fix, ignore the problem for now. Needs a replacement
5297 * pipeline
5298 */
5299 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5300 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5301 tests[i].name, color, tests[i].color_rhw);
5302 } else {
5303 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5304 "Test %s returned color 0x%08x, expected 0x%08x\n",
5305 tests[i].name, color, tests[i].color_rhw);
5306 }
5307 }
5308
5309 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5310 {
5311 IDirect3DPixelShader9_Release(tests[i].shader);
5312 }
5313
5314 IDirect3DVertexDeclaration9_Release(decl2);
5315 IDirect3DVertexDeclaration9_Release(decl);
5316 }
5317
5318 static void vshader_version_varying_test(IDirect3DDevice9 *device) {
5319 static const DWORD ps_code[] = {
5320 0xffff0300, /* ps_3_0 */
5321 0x05000030, 0xf00f0000, 0x00000003, 0x00000003, 0x00000001, 0x00000000, /* defi i0, 3, 3, 1, 0 */
5322 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5323 0x0200001f, 0x8001000a, 0x900f0003, /* dcl_color1 v3 */
5324 0x0200001f, 0x8000000b, 0x900f0004, /* dcl_fog v4 */
5325 0x0200001f, 0x80030005, 0x900f0005, /* dcl_texcoord3 v5 */
5326 0x0200001f, 0x80000003, 0x900f0006,
5327 0x0200001f, 0x80000006, 0x900f0007,
5328 0x0200001f, 0x80000001, 0x900f0008,
5329 0x0200001f, 0x8000000c, 0x900f0009,
5330
5331 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5332 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
5333 0x04000002, 0x800f0000, 0x80e40000, 0x90e42000, 0xf0e40800, /* add r0, r0, v0[aL] */
5334 0x0000001d, /* endloop */
5335 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5336 0x0000ffff /* end */
5337 };
5338 static const DWORD vs_1_code[] = {
5339 0xfffe0101, /* vs_1_1 */
5340 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5341 0x00000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5342 0x00000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5343 0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5344 0x00000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5345 0x00000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5346 0x00000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5347 0x00000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5348 0x00000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5349 0x00000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5350 0x00000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5351 0x00000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5352 0x00000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5353 0x00000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5354 0x00000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5355 0x00000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5356 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5357 0x0000ffff
5358 };
5359 DWORD vs_2_code[] = {
5360 0xfffe0200, /* vs_2_0 */
5361 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5362 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0 */
5363 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.5, 0.0, 0.0 */
5364 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.5, 0.0 */
5365 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5366 0x02000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5367 0x02000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5368 0x02000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5369 0x02000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5370 0x02000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5371 0x02000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5372 0x02000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5373 0x02000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5374 0x02000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5375 0x02000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5376 0x02000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5377 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5378 0x0000ffff /* end */
5379 };
5380 /* TODO: Define normal, tangent, blendweight and depth here */
5381 static const DWORD vs_3_code[] = {
5382 0xfffe0300, /* vs_3_0 */
5383 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5384 0x0200001f, 0x8001000a, 0xe00f0009, /* dcl_color1 o9 */
5385 0x0200001f, 0x8000000b, 0xe00f0002, /* dcl_fog o2 */
5386 0x0200001f, 0x80030005, 0xe00f0005, /* dcl_texcoord3 o5 */
5387 0x0200001f, 0x80000000, 0xe00f000b, /* dcl_position o11 */
5388 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5389 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5390 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5391 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5392 0x02000001, 0xe00f0009, 0xa0e40000, /* mov o9, c0 */
5393 0x02000001, 0xe00f0002, 0xa0e40001, /* mov o2, c1 */
5394 0x02000001, 0xe00f0005, 0xa0e40002, /* mov o5, c2 */
5395 0x02000001, 0xe00f000b, 0x90e40000, /* mov o11, v0 */
5396 0x0000ffff /* end */
5397 };
5398 float quad1[] = {
5399 -1.0, -1.0, 0.1,
5400 0.0, -1.0, 0.1,
5401 -1.0, 0.0, 0.1,
5402 0.0, 0.0, 0.1
5403 };
5404 float quad2[] = {
5405 0.0, -1.0, 0.1,
5406 1.0, -1.0, 0.1,
5407 0.0, 0.0, 0.1,
5408 1.0, 0.0, 0.1
5409 };
5410 float quad3[] = {
5411 -1.0, 0.0, 0.1,
5412 0.0, 0.0, 0.1,
5413 -1.0, 1.0, 0.1,
5414 0.0, 1.0, 0.1
5415 };
5416
5417 HRESULT hr;
5418 DWORD color;
5419 IDirect3DPixelShader9 *pixelshader = NULL;
5420 IDirect3DVertexShader9 *vs_1_shader = NULL;
5421 IDirect3DVertexShader9 *vs_2_shader = NULL;
5422 IDirect3DVertexShader9 *vs_3_shader = NULL;
5423
5424 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff110000, 0.0, 0);
5425
5426 hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &pixelshader);
5427 ok(hr == D3D_OK, "IDirect3DDevice_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5428 hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_code, &vs_1_shader);
5429 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5430 hr = IDirect3DDevice9_CreateVertexShader(device, vs_2_code, &vs_2_shader);
5431 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5432 hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_code, &vs_3_shader);
5433 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5434 hr = IDirect3DDevice9_SetPixelShader(device, pixelshader);
5435 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5436 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5437
5438 hr = IDirect3DDevice9_BeginScene(device);
5439 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5440 if(SUCCEEDED(hr))
5441 {
5442 hr = IDirect3DDevice9_SetVertexShader(device, vs_1_shader);
5443 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5444 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5445 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5446
5447 hr = IDirect3DDevice9_SetVertexShader(device, vs_2_shader);
5448 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5449 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5450 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5451
5452 hr = IDirect3DDevice9_SetVertexShader(device, vs_3_shader);
5453 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5454 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5455 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5456
5457 hr = IDirect3DDevice9_EndScene(device);
5458 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5459 }
5460 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5461 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5462
5463 color = getPixelColor(device, 160, 120);
5464 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5465 (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003500 &&
5466 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5467 "vs_3_0 returned color 0x%08x, expected 0x00203366\n", color);
5468 color = getPixelColor(device, 160, 360);
5469 ok((color & 0x00ff0000) >= 0x003c0000 && (color & 0x00ff0000) <= 0x004e0000 &&
5470 (color & 0x0000ff00) >= 0x00000000 && (color & 0x0000ff00) <= 0x00000000 &&
5471 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5472 "vs_1_1 returned color 0x%08x, expected 0x004c0066\n", color);
5473 color = getPixelColor(device, 480, 360);
5474 ok((color & 0x00ff0000) >= 0x003c0000 && (color & 0x00ff0000) <= 0x004e0000 &&
5475 (color & 0x0000ff00) >= 0x00000000 && (color & 0x0000ff00) <= 0x00000000 &&
5476 (color & 0x000000ff) >= 0x00000066 && (color & 0x000000ff) <= 0x00000068,
5477 "vs_2_0 returned color 0x%08x, expected 0x004c0066\n", color);
5478
5479 /* cleanup */
5480 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5481 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5482 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5483 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5484 if(pixelshader) IDirect3DPixelShader9_Release(pixelshader);
5485 if(vs_1_shader) IDirect3DVertexShader9_Release(vs_1_shader);
5486 if(vs_2_shader) IDirect3DVertexShader9_Release(vs_2_shader);
5487 if(vs_3_shader) IDirect3DVertexShader9_Release(vs_3_shader);
5488 }
5489
5490 static void pshader_version_varying_test(IDirect3DDevice9 *device) {
5491 static const DWORD vs_code[] = {
5492 0xfffe0300, /* vs_3_0 */
5493 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5494 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5495 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color0 o1 */
5496 0x0200001f, 0x80000005, 0xe00f0002, /* dcl_texcoord0 o2 */
5497 0x0200001f, 0x8000000b, 0xe00f0003, /* dcl_fog o3 */
5498 0x0200001f, 0x80000003, 0xe00f0004, /* dcl_normal o4 */
5499 0x0200001f, 0x8000000c, 0xe00f0005, /* dcl_depth o5 */
5500 0x0200001f, 0x80000006, 0xe00f0006, /* dcl_tangent o6 */
5501 0x0200001f, 0x80000001, 0xe00f0007, /* dcl_blendweight o7 */
5502 0x05000051, 0xa00f0001, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c1, 0.1, 0.0, 0.0, 0.0 */
5503 0x05000051, 0xa00f0002, 0x00000000, 0x3e4ccccd, 0x00000000, 0x3f800000, /* def c2, 0.0, 0.2, 0.0, 1.0 */
5504 0x05000051, 0xa00f0003, 0x3ecccccd, 0x3f59999a, 0x3f666666, 0x00000000, /* def c3, 0.4, 0.85,0.9, 0.0 */
5505 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c0, 1.0, 1.0, 1.0, 1.0 */
5506
5507 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5508 0x02000001, 0xe00f0001, 0xa0e40001, /* mov o1, c1 */
5509 0x02000001, 0xe00f0002, 0xa0e40002, /* mov o2, c2 */
5510 0x02000001, 0xe00f0003, 0xa0e40003, /* mov o3, c3 */
5511 0x02000001, 0xe00f0004, 0xa0e40000, /* mov o4, c0 */
5512 0x02000001, 0xe00f0005, 0xa0e40000, /* mov o5, c0 */
5513 0x02000001, 0xe00f0006, 0xa0e40000, /* mov o6, c0 */
5514 0x02000001, 0xe00f0007, 0xa0e40000, /* mov o7, c0 */
5515 0x0000ffff /* end */
5516 };
5517 static const DWORD ps_1_code[] = {
5518 0xffff0104, /* ps_1_4 */
5519 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5520 0x00000040, 0x80070001, 0xb0e40000, /* texcrd r1.xyz, t0 */
5521 0x00000001, 0x80080001, 0xa0ff0000, /* mov r1.a, c0.a */
5522 0x00000002, 0x800f0000, 0x90e40000, 0x80e40001, /* add r0, v0, r1 */
5523 0x0000ffff /* end */
5524 };
5525 static const DWORD ps_2_code[] = {
5526 0xffff0200, /* ps_2_0 */
5527 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
5528 0x0200001f, 0x80000000, 0x900f0000, /* dcl v0 */
5529 0x0200001f, 0x80000000, 0x900f0001, /* dcl v1 */
5530
5531 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5532 0x03000002, 0x800f0000, 0x80e40000,0xb0e40000, /* add r0, r0, t0 */
5533 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5534 0x0000ffff /* end */
5535 };
5536 static const DWORD ps_3_code[] = {
5537 0xffff0300, /* ps_3_0 */
5538 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0 v0 */
5539 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
5540 0x0200001f, 0x8000000b, 0x900f0002, /* dcl_fog v2 */
5541
5542 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5543 0x03000002, 0x800f0000, 0x80e40000, 0x90e40001, /* add r0, r0, v1 */
5544 0x03000002, 0x800f0000, 0x80e40000, 0x90e40002, /* mov r0, r0, v2 */
5545 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5546 0x0000ffff /* end */
5547 };
5548
5549 float quad1[] = {
5550 -1.0, -1.0, 0.1,
5551 0.0, -1.0, 0.1,
5552 -1.0, 0.0, 0.1,
5553 0.0, 0.0, 0.1
5554 };
5555 float quad2[] = {
5556 0.0, -1.0, 0.1,
5557 1.0, -1.0, 0.1,
5558 0.0, 0.0, 0.1,
5559 1.0, 0.0, 0.1
5560 };
5561 float quad3[] = {
5562 -1.0, 0.0, 0.1,
5563 0.0, 0.0, 0.1,
5564 -1.0, 1.0, 0.1,
5565 0.0, 1.0, 0.1
5566 };
5567 float quad4[] = {
5568 0.0, 0.0, 0.1,
5569 1.0, 0.0, 0.1,
5570 0.0, 1.0, 0.1,
5571 1.0, 1.0, 0.1
5572 };
5573
5574 HRESULT hr;
5575 DWORD color;
5576 IDirect3DVertexShader9 *vertexshader = NULL;
5577 IDirect3DPixelShader9 *ps_1_shader = NULL;
5578 IDirect3DPixelShader9 *ps_2_shader = NULL;
5579 IDirect3DPixelShader9 *ps_3_shader = NULL;
5580 IDirect3DTexture9 *texture = NULL;
5581 D3DLOCKED_RECT lr;
5582 unsigned int x, y;
5583
5584 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
5585
5586 hr = IDirect3DDevice9_CreateTexture(device, 512, 512, 1, 0, D3DFMT_A16B16G16R16, D3DPOOL_MANAGED, &texture, NULL);
5587 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %s\n", DXGetErrorString9(hr));
5588 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
5589 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %s\n", DXGetErrorString9(hr));
5590 for(y = 0; y < 512; y++) {
5591 for(x = 0; x < 512; x++) {
5592 double r_f = (double) x / (double) 512;
5593 double g_f = (double) y / (double) 512;
5594 unsigned short *dst = (unsigned short *) (((unsigned char *) lr.pBits) + y * lr.Pitch + x * 8);
5595 unsigned short r = (unsigned short) (r_f * 65535.0);
5596 unsigned short g = (unsigned short) (g_f * 65535.0);
5597 dst[0] = r;
5598 dst[1] = g;
5599 dst[2] = 0;
5600 dst[3] = 65535;
5601 }
5602 }
5603 hr = IDirect3DTexture9_UnlockRect(texture, 0);
5604 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %s\n", DXGetErrorString9(hr));
5605
5606 hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vertexshader);
5607 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5608 hr = IDirect3DDevice9_CreatePixelShader(device, ps_1_code, &ps_1_shader);
5609 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5610 hr = IDirect3DDevice9_CreatePixelShader(device, ps_2_code, &ps_2_shader);
5611 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5612 hr = IDirect3DDevice9_CreatePixelShader(device, ps_3_code, &ps_3_shader);
5613 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
5614 hr = IDirect3DDevice9_SetVertexShader(device, vertexshader);
5615 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5616 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5617
5618 hr = IDirect3DDevice9_BeginScene(device);
5619 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5620 if(SUCCEEDED(hr))
5621 {
5622 hr = IDirect3DDevice9_SetPixelShader(device, ps_1_shader);
5623 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5624 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5625 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5626
5627 hr = IDirect3DDevice9_SetPixelShader(device, ps_2_shader);
5628 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5629 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5630 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5631
5632 hr = IDirect3DDevice9_SetPixelShader(device, ps_3_shader);
5633 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5634 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5635 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5636
5637 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5638 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5639 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
5640 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
5641 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
5642 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
5643 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
5644 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
5645 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5646 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5647
5648 hr = IDirect3DDevice9_EndScene(device);
5649 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5650 }
5651 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5652 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5653
5654 color = getPixelColor(device, 160, 120);
5655 ok((color & 0x00ff0000) >= 0x00790000 && (color & 0x00ff0000) <= 0x00810000 &&
5656 (color & 0x0000ff00) == 0x0000ff00 &&
5657 (color & 0x000000ff) >= 0x000000e4 && (color & 0x000000ff) <= 0x000000e6,
5658 "ps_3_0 returned color 0x%08x, expected 0x0080ffe5\n", color);
5659 color = getPixelColor(device, 160, 360);
5660 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5661 (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003400 &&
5662 (color & 0x000000ff) == 0x00000000,
5663 "ps_1_4 returned color 0x%08x, expected 0x00203300\n", color);
5664 color = getPixelColor(device, 480, 360);
5665 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5666 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5667 (color & 0x000000ff) == 0x00000000,
5668 "ps_2_0 returned color 0x%08x, expected 0x00203300\n", color);
5669 color = getPixelColor(device, 480, 160);
5670 ok( color == 0x00ffffff /* Nvidia driver garbage with HW vp */ || (
5671 (color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5672 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5673 (color & 0x000000ff) == 0x00000000),
5674 "fixed function fragment processing returned color 0x%08x, expected 0x00203300\n", color);
5675
5676 /* cleanup */
5677 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
5678 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %s\n", DXGetErrorString9(hr));
5679 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5680 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
5681 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5682 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5683 if(vertexshader) IDirect3DVertexShader9_Release(vertexshader);
5684 if(ps_1_shader) IDirect3DPixelShader9_Release(ps_1_shader);
5685 if(ps_2_shader) IDirect3DPixelShader9_Release(ps_2_shader);
5686 if(ps_3_shader) IDirect3DPixelShader9_Release(ps_3_shader);
5687 if(texture) IDirect3DTexture9_Release(texture);
5688 }
5689
5690 void test_compare_instructions(IDirect3DDevice9 *device)
5691 {
5692 DWORD shader_sge_vec_code[] = {
5693 0xfffe0101, /* vs_1_1 */
5694 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5695 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5696 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5697 0x0000000d, 0xd00f0000, 0x80e40000, 0xa0e40001, /* sge oD0, r0, c1 */
5698 0x0000ffff /* end */
5699 };
5700 DWORD shader_slt_vec_code[] = {
5701 0xfffe0101, /* vs_1_1 */
5702 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5703 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5704 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5705 0x0000000c, 0xd00f0000, 0x80e40000, 0xa0e40001, /* slt oD0, r0, c1 */
5706 0x0000ffff /* end */
5707 };
5708 DWORD shader_sge_scalar_code[] = {
5709 0xfffe0101, /* vs_1_1 */
5710 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5711 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5712 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5713 0x0000000d, 0xd0010000, 0x80000000, 0xa0550001, /* slt oD0.r, r0.r, c1.b */
5714 0x0000000d, 0xd0020000, 0x80550000, 0xa0aa0001, /* slt oD0.g, r0.g, c1.r */
5715 0x0000000d, 0xd0040000, 0x80aa0000, 0xa0000001, /* slt oD0.b, r0.b, c1.g */
5716 0x0000ffff /* end */
5717 };
5718 DWORD shader_slt_scalar_code[] = {
5719 0xfffe0101, /* vs_1_1 */
5720 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5721 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5722 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5723 0x0000000c, 0xd0010000, 0x80000000, 0xa0aa0001, /* slt oD0.r, r0.r, c1.b */
5724 0x0000000c, 0xd0020000, 0x80550000, 0xa0000001, /* slt oD0.g, r0.g, c1.r */
5725 0x0000000c, 0xd0040000, 0x80aa0000, 0xa0550001, /* slt oD0.b, r0.b, c1.g */
5726 0x0000ffff /* end */
5727 };
5728 IDirect3DVertexShader9 *shader_sge_vec;
5729 IDirect3DVertexShader9 *shader_slt_vec;
5730 IDirect3DVertexShader9 *shader_sge_scalar;
5731 IDirect3DVertexShader9 *shader_slt_scalar;
5732 HRESULT hr, color;
5733 float quad1[] = {
5734 -1.0, -1.0, 0.1,
5735 0.0, -1.0, 0.1,
5736 -1.0, 0.0, 0.1,
5737 0.0, 0.0, 0.1
5738 };
5739 float quad2[] = {
5740 0.0, -1.0, 0.1,
5741 1.0, -1.0, 0.1,
5742 0.0, 0.0, 0.1,
5743 1.0, 0.0, 0.1
5744 };
5745 float quad3[] = {
5746 -1.0, 0.0, 0.1,
5747 0.0, 0.0, 0.1,
5748 -1.0, 1.0, 0.1,
5749 0.0, 1.0, 0.1
5750 };
5751 float quad4[] = {
5752 0.0, 0.0, 0.1,
5753 1.0, 0.0, 0.1,
5754 0.0, 1.0, 0.1,
5755 1.0, 1.0, 0.1
5756 };
5757 const float const0[4] = {0.8, 0.2, 0.2, 0.2};
5758 const float const1[4] = {0.2, 0.8, 0.2, 0.2};
5759
5760 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5761
5762 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_vec_code, &shader_sge_vec);
5763 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5764 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_vec_code, &shader_slt_vec);
5765 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5766 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_scalar_code, &shader_sge_scalar);
5767 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5768 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_scalar_code, &shader_slt_scalar);
5769 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
5770 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5771 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5772 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, const1, 1);
5773 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5774 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5775 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
5776
5777 hr = IDirect3DDevice9_BeginScene(device);
5778 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
5779 if(SUCCEEDED(hr))
5780 {
5781 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_vec);
5782 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5783 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5784 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5785
5786 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_vec);
5787 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5788 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5789 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5790
5791 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_scalar);
5792 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5793 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5794 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5795
5796 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5797 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5798
5799 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_scalar);
5800 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
5801 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5802 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5803
5804 hr = IDirect3DDevice9_EndScene(device);
5805 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
5806 }
5807
5808 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5809 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
5810
5811 color = getPixelColor(device, 160, 360);
5812 ok(color == 0x00FF00FF, "Compare test: Quad 1(sge vec) returned color 0x%08x, expected 0x00FF00FF\n", color);
5813 color = getPixelColor(device, 480, 360);
5814 ok(color == 0x0000FF00, "Compare test: Quad 2(slt vec) returned color 0x%08x, expected 0x0000FF00\n", color);
5815 color = getPixelColor(device, 160, 120);
5816 ok(color == 0x00FFFFFF, "Compare test: Quad 3(sge scalar) returned color 0x%08x, expected 0x00FFFFFF\n", color);
5817 color = getPixelColor(device, 480, 160);
5818 ok(color == 0x000000ff, "Compare test: Quad 4(slt scalar) returned color 0x%08x, expected 0x000000ff\n", color);
5819
5820 IDirect3DVertexShader9_Release(shader_sge_vec);
5821 IDirect3DVertexShader9_Release(shader_slt_vec);
5822 IDirect3DVertexShader9_Release(shader_sge_scalar);
5823 IDirect3DVertexShader9_Release(shader_slt_scalar);
5824 }
5825
5826 void test_vshader_input(IDirect3DDevice9 *device)
5827 {
5828 DWORD swapped_shader_code_3[] = {
5829 0xfffe0300, /* vs_3_0 */
5830 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5831 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5832 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5833 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5834 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5835 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5836 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5837 0x03000002, 0xe00f0001, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5838 0x0000ffff /* end */
5839 };
5840 DWORD swapped_shader_code_1[] = {
5841 0xfffe0101, /* vs_1_1 */
5842 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5843 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5844 0x0000001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5845 0x00000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5846 0x00000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5847 0x00000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5848 0x0000ffff /* end */
5849 };
5850 DWORD swapped_shader_code_2[] = {
5851 0xfffe0200, /* vs_2_0 */
5852 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5853 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5854 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5855 0x02000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5856 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5857 0x03000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5858 0x0000ffff /* end */
5859 };
5860 DWORD texcoord_color_shader_code_3[] = {
5861 0xfffe0300, /* vs_3_0 */
5862 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5863 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5864 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5865 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5866 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5867 0x02000001, 0xe00f0001, 0x90e40001, /* mov o1, v1 */
5868 0x0000ffff /* end */
5869 };
5870 DWORD texcoord_color_shader_code_2[] = {
5871 0xfffe0200, /* vs_2_0 */
5872 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5873 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5874 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5875 0x02000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5876 0x0000ffff /* end */
5877 };
5878 DWORD texcoord_color_shader_code_1[] = {
5879 0xfffe0101, /* vs_1_1 */
5880 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5881 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5882 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5883 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5884 0x0000ffff /* end */
5885 };
5886 DWORD color_color_shader_code_3[] = {
5887 0xfffe0300, /* vs_3_0 */
5888 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5889 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5890 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5891 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5892 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5893 0x03000005, 0xe00f0001, 0xa0e40000, 0x90e40001, /* mul o1, c0, v1 */
5894 0x0000ffff /* end */
5895 };
5896 DWORD color_color_shader_code_2[] = {
5897 0xfffe0200, /* vs_2_0 */
5898 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5899 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5900 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5901 0x03000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5902 0x0000ffff /* end */
5903 };
5904 DWORD color_color_shader_code_1[] = {
5905 0xfffe0101, /* vs_1_1 */
5906 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5907 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5908 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5909 0x00000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5910 0x0000ffff /* end */
5911 };
5912 IDirect3DVertexShader9 *swapped_shader, *texcoord_color_shader, *color_color_shader;
5913 HRESULT hr;
5914 DWORD color, r, g, b;
5915 float quad1[] = {
5916 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5917 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5918 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5919 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5920 };
5921 float quad2[] = {
5922 0.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5923 1.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5924 0.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5925 1.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
5926 };
5927 float quad3[] = {
5928 -1.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 0.0,
5929 0.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
5930 -1.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 1.0, 0.0,
5931 0.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0,
5932 };
5933 float quad4[] = {
5934 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5935 1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5936 0.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5937 1.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
5938 };
5939 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd[] = {
5940 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5941 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5942 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5943 D3DDECL_END()
5944 };
5945 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_rightorder[] = {
5946 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5947 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5948 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5949 D3DDECL_END()
5950 };
5951 static const D3DVERTEXELEMENT9 decl_elements_onetexcrd[] = {
5952 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5953 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5954 D3DDECL_END()
5955 };
5956 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_wrongidx[] = {
5957 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5958 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
5959 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
5960 D3DDECL_END()
5961 };
5962 static const D3DVERTEXELEMENT9 decl_elements_texcoord_color[] = {
5963 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5964 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5965 D3DDECL_END()
5966 };
5967 static const D3DVERTEXELEMENT9 decl_elements_color_color[] = {
5968 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5969 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5970 D3DDECL_END()
5971 };
5972 static const D3DVERTEXELEMENT9 decl_elements_color_ubyte[] = {
5973 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5974 {0, 12, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5975 D3DDECL_END()
5976 };
5977 static const D3DVERTEXELEMENT9 decl_elements_color_float[] = {
5978 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5979 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5980 D3DDECL_END()
5981 };
5982 IDirect3DVertexDeclaration9 *decl_twotexcrd, *decl_onetexcrd, *decl_twotex_wrongidx, *decl_twotexcrd_rightorder;
5983 IDirect3DVertexDeclaration9 *decl_texcoord_color, *decl_color_color, *decl_color_ubyte, *decl_color_float;
5984 unsigned int i;
5985 float normalize[4] = {1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0};
5986 float no_normalize[4] = {1.0, 1.0, 1.0, 1.0};
5987
5988 struct vertex quad1_color[] = {
5989 {-1.0, -1.0, 0.1, 0x00ff8040},
5990 { 0.0, -1.0, 0.1, 0x00ff8040},
5991 {-1.0, 0.0, 0.1, 0x00ff8040},
5992 { 0.0, 0.0, 0.1, 0x00ff8040}
5993 };
5994 struct vertex quad2_color[] = {
5995 { 0.0, -1.0, 0.1, 0x00ff8040},
5996 { 1.0, -1.0, 0.1, 0x00ff8040},
5997 { 0.0, 0.0, 0.1, 0x00ff8040},
5998 { 1.0, 0.0, 0.1, 0x00ff8040}
5999 };
6000 struct vertex quad3_color[] = {
6001 {-1.0, 0.0, 0.1, 0x00ff8040},
6002 { 0.0, 0.0, 0.1, 0x00ff8040},
6003 {-1.0, 1.0, 0.1, 0x00ff8040},
6004 { 0.0, 1.0, 0.1, 0x00ff8040}
6005 };
6006 float quad4_color[] = {
6007 0.0, 0.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6008 1.0, 0.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6009 0.0, 1.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6010 1.0, 1.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6011 };
6012
6013 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd, &decl_twotexcrd);
6014 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6015 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_onetexcrd, &decl_onetexcrd);
6016 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6017 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_wrongidx, &decl_twotex_wrongidx);
6018 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6019 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_rightorder, &decl_twotexcrd_rightorder);
6020 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6021
6022 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_texcoord_color, &decl_texcoord_color);
6023 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6024 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_color, &decl_color_color);
6025 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6026 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_ubyte, &decl_color_ubyte);
6027 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6028 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_float, &decl_color_float);
6029 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6030
6031 for(i = 1; i <= 3; i++) {
6032 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
6033 if(i == 3) {
6034 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_3, &swapped_shader);
6035 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6036 } else if(i == 2){
6037 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_2, &swapped_shader);
6038 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6039 } else if(i == 1) {
6040 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_1, &swapped_shader);
6041 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6042 }
6043
6044 hr = IDirect3DDevice9_BeginScene(device);
6045 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6046 if(SUCCEEDED(hr))
6047 {
6048 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6049 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6050
6051 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6052 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6053 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 11);
6054 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6055
6056 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6057 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6058 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 11);
6059 if(i == 3 || i == 2) {
6060 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6061 } else if(i == 1) {
6062 /* Succeeds or fails, depending on SW or HW vertex processing */
6063 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6064 }
6065
6066 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd_rightorder);
6067 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6068 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 11);
6069 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6070
6071 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotex_wrongidx);
6072 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6073 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 11);
6074 if(i == 3 || i == 2) {
6075 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6076 } else if(i == 1) {
6077 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = 1\n", hr);
6078 }
6079
6080 hr = IDirect3DDevice9_EndScene(device);
6081 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6082 }
6083
6084 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6085 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6086
6087 if(i == 3 || i == 2) {
6088 color = getPixelColor(device, 160, 360);
6089 ok(color == 0x00FFFF80 || color == 0x00FFFF7f || color == 0x00FFFF81,
6090 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6091
6092 /* The last value of the read but undefined stream is used, it is 0x00. The defined input is vec4(1, 0, 0, 0) */
6093 color = getPixelColor(device, 480, 360);
6094 ok(color == 0x00FFFF00 || color ==0x00FF0000,
6095 "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6096 color = getPixelColor(device, 160, 120);
6097 /* Same as above, accept both the last used value and 0.0 for the undefined streams */
6098 ok(color == 0x00FF0080 || color == 0x00FF007f || color == 0x00FF0081 || color == 0x00FF0000,
6099 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6100
6101 color = getPixelColor(device, 480, 160);
6102 ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6103 } else if(i == 1) {
6104 color = getPixelColor(device, 160, 360);
6105 ok(color == 0x00FFFF80 || color == 0x00FFFF7f || color == 0x00FFFF81,
6106 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6107 color = getPixelColor(device, 480, 360);
6108 /* Accept the clear color as well in this case, since SW VP returns an error */
6109 ok(color == 0x00FFFF00 || color == 0x00FF0000, "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6110 color = getPixelColor(device, 160, 120);
6111 ok(color == 0x00FF0080 || color == 0x00FF0000 || color == 0x00FF007f || color == 0x00FF0081,
6112 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
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 }
6116
6117 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff808080, 0.0, 0);
6118 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6119
6120 /* Now find out if the whole streams are re-read, or just the last active value for the
6121 * vertices is used.
6122 */
6123 hr = IDirect3DDevice9_BeginScene(device);
6124 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6125 if(SUCCEEDED(hr))
6126 {
6127 float quad1_modified[] = {
6128 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0,
6129 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0,
6130 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0,
6131 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0,
6132 };
6133 float quad2_modified[] = {
6134 0.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6135 1.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6136 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6137 1.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6138 };
6139
6140 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6141 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6142
6143 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6144 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6145 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 3, quad1_modified, sizeof(float) * 11);
6146 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6147
6148 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6149 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6150 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_modified, sizeof(float) * 11);
6151 if(i == 3 || i == 2) {
6152 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6153 } else if(i == 1) {
6154 /* Succeeds or fails, depending on SW or HW vertex processing */
6155 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6156 }
6157
6158 hr = IDirect3DDevice9_EndScene(device);
6159 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6160 }
6161 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6162 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6163
6164 color = getPixelColor(device, 480, 350);
6165 /* vs_1_1 may fail, accept the clear color. Some drivers also set the undefined streams to 0, accept that
6166 * as well.
6167 *
6168 * NOTE: This test fails on the reference rasterizer. In the refrast, the 4 vertices have different colors,
6169 * i.e., the whole old stream is read, and not just the last used attribute. Some games require that this
6170 * does *not* happen, otherwise they can crash because of a read from a bad pointer, so do not accept the
6171 * refrast's result.
6172 *
6173 * A test app for this behavior is Half Life 2 Episode 2 in dxlevel 95, and related games(Portal, TF2).
6174 */
6175 ok(color == 0x000000FF || color == 0x00808080 || color == 0x00000000,
6176 "Input test: Quad 2(different colors) returned color 0x%08x, expected 0x000000FF, 0x00808080 or 0x00000000\n", color);
6177 color = getPixelColor(device, 160, 120);
6178
6179 IDirect3DDevice9_SetVertexShader(device, NULL);
6180 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6181
6182 IDirect3DVertexShader9_Release(swapped_shader);
6183 }
6184
6185 for(i = 1; i <= 3; i++) {
6186 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
6187 if(i == 3) {
6188 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_3, &texcoord_color_shader);
6189 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6190 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_3, &color_color_shader);
6191 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6192 } else if(i == 2){
6193 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_2, &texcoord_color_shader);
6194 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6195 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_2, &color_color_shader);
6196 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6197 } else if(i == 1) {
6198 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_1, &texcoord_color_shader);
6199 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6200 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_1, &color_color_shader);
6201 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6202 }
6203
6204 hr = IDirect3DDevice9_BeginScene(device);
6205 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6206 if(SUCCEEDED(hr))
6207 {
6208 hr = IDirect3DDevice9_SetVertexShader(device, texcoord_color_shader);
6209 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6210 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_texcoord_color);
6211 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6212 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1_color, sizeof(quad1_color[0]));
6213 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6214
6215 hr = IDirect3DDevice9_SetVertexShader(device, color_color_shader);
6216 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6217
6218 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, normalize, 1);
6219 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6220 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_ubyte);
6221 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6222 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_color, sizeof(quad2_color[0]));
6223 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6224
6225 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, no_normalize, 1);
6226 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6227 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_color);
6228 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6229 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3_color, sizeof(quad3_color[0]));
6230 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6231
6232 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_float);
6233 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %s\n", DXGetErrorString9(hr));
6234 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4_color, sizeof(float) * 7);
6235 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6236
6237 hr = IDirect3DDevice9_EndScene(device);
6238 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6239 }
6240 IDirect3DDevice9_SetVertexShader(device, NULL);
6241 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6242
6243 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6244 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6245
6246 color = getPixelColor(device, 160, 360);
6247 r = (color & 0x00ff0000) >> 16;
6248 g = (color & 0x0000ff00) >> 8;
6249 b = (color & 0x000000ff) >> 0;
6250 ok(r >= 0xfe && r <= 0xff && g >= 0x7f && g <= 0x81 && b >= 0x3f && b <= 0x41,
6251 "Input test: Quad 1(color-texcoord) returned color 0x%08x, expected 0x00ff8040\n", color);
6252 color = getPixelColor(device, 480, 360);
6253 r = (color & 0x00ff0000) >> 16;
6254 g = (color & 0x0000ff00) >> 8;
6255 b = (color & 0x000000ff) >> 0;
6256 ok(r >= 0x3f && r <= 0x41 && g >= 0x7f && g <= 0x81 && b >= 0xfe && b <= 0xff,
6257 "Input test: Quad 2(color-ubyte) returned color 0x%08x, expected 0x004080ff\n", color);
6258 color = getPixelColor(device, 160, 120);
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 3(color-color) returned color 0x%08x, expected 0x00ff8040\n", color);
6264 color = getPixelColor(device, 480, 160);
6265 r = (color & 0x00ff0000) >> 16;
6266 g = (color & 0x0000ff00) >> 8;
6267 b = (color & 0x000000ff) >> 0;
6268 ok(r >= 0xfe && r <= 0xff && g >= 0xfe && g <= 0xff && b <= 0x01,
6269 "Input test: Quad 4(color-float) returned color 0x%08x, expected 0x00FFFF00\n", color);
6270
6271 IDirect3DVertexShader9_Release(texcoord_color_shader);
6272 IDirect3DVertexShader9_Release(color_color_shader);
6273 }
6274
6275 IDirect3DVertexDeclaration9_Release(decl_twotexcrd);
6276 IDirect3DVertexDeclaration9_Release(decl_onetexcrd);
6277 IDirect3DVertexDeclaration9_Release(decl_twotex_wrongidx);
6278 IDirect3DVertexDeclaration9_Release(decl_twotexcrd_rightorder);
6279
6280 IDirect3DVertexDeclaration9_Release(decl_texcoord_color);
6281 IDirect3DVertexDeclaration9_Release(decl_color_color);
6282 IDirect3DVertexDeclaration9_Release(decl_color_ubyte);
6283 IDirect3DVertexDeclaration9_Release(decl_color_float);
6284 }
6285
6286 static void srgbtexture_test(IDirect3DDevice9 *device)
6287 {
6288 /* Fill a texture with 0x7f (~ .5), and then turn on the D3DSAMP_SRGBTEXTURE
6289 * texture stage state to render a quad using that texture. The resulting
6290 * color components should be 0x36 (~ 0.21), per this formula:
6291 * linear_color = ((srgb_color + 0.055) / 1.055) ^ 2.4
6292 * This is true where srgb_color > 0.04045.
6293 */
6294 IDirect3D9 *d3d = NULL;
6295 HRESULT hr;
6296 LPDIRECT3DTEXTURE9 texture = NULL;
6297 LPDIRECT3DSURFACE9 surface = NULL;
6298 D3DLOCKED_RECT lr;
6299 DWORD color;
6300 float quad[] = {
6301 -1.0, 1.0, 0.0, 0.0, 0.0,
6302 1.0, 1.0, 0.0, 1.0, 0.0,
6303 -1.0, -1.0, 0.0, 0.0, 1.0,
6304 1.0, -1.0, 0.0, 1.0, 1.0,
6305 };
6306
6307
6308 memset(&lr, 0, sizeof(lr));
6309 IDirect3DDevice9_GetDirect3D(device, &d3d);
6310 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6311 D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_TEXTURE,
6312 D3DFMT_A8R8G8B8) != D3D_OK) {
6313 skip("D3DFMT_A8R8G8B8 textures with SRGBREAD not supported\n");
6314 goto out;
6315 }
6316
6317 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0,
6318 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
6319 &texture, NULL);
6320 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
6321 if(!texture) {
6322 skip("Failed to create A8R8G8B8 texture with SRGBREAD\n");
6323 goto out;
6324 }
6325 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
6326 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
6327
6328 fill_surface(surface, 0xff7f7f7f);
6329 IDirect3DSurface9_Release(surface);
6330
6331 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6332 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6333 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
6334 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
6335
6336 hr = IDirect3DDevice9_BeginScene(device);
6337 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
6338 if(SUCCEEDED(hr))
6339 {
6340 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, TRUE);
6341 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
6342
6343 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6344 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
6345
6346
6347 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
6348 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
6349
6350 hr = IDirect3DDevice9_EndScene(device);
6351 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
6352 }
6353
6354 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6355 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
6356 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
6357 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %s\n", DXGetErrorString9(hr));
6358
6359 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6360 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6361
6362 color = getPixelColor(device, 320, 240);
6363 ok(color == 0x00363636 || color == 0x00373737, "srgb quad has color %08x, expected 0x00363636\n", color);
6364
6365 out:
6366 if(texture) IDirect3DTexture9_Release(texture);
6367 IDirect3D9_Release(d3d);
6368 }
6369
6370 static void shademode_test(IDirect3DDevice9 *device)
6371 {
6372 /* Render a quad and try all of the different fixed function shading models. */
6373 HRESULT hr;
6374 DWORD color0, color1;
6375 DWORD color0_gouraud = 0, color1_gouraud = 0;
6376 BYTE r, g, b;
6377 DWORD shademode = D3DSHADE_FLAT;
6378 DWORD primtype = D3DPT_TRIANGLESTRIP;
6379 LPVOID data = NULL;
6380 LPDIRECT3DVERTEXBUFFER9 vb_strip = NULL;
6381 LPDIRECT3DVERTEXBUFFER9 vb_list = NULL;
6382 UINT i, j;
6383 struct vertex quad_strip[] =
6384 {
6385 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6386 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6387 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6388 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6389 };
6390 struct vertex quad_list[] =
6391 {
6392 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6393 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6394 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6395
6396 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6397 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6398 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6399 };
6400
6401 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_strip),
6402 0, 0, D3DPOOL_MANAGED, &vb_strip, NULL);
6403 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6404 if (FAILED(hr)) goto bail;
6405
6406 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_list),
6407 0, 0, D3DPOOL_MANAGED, &vb_list, NULL);
6408 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6409 if (FAILED(hr)) goto bail;
6410
6411 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6412 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6413
6414 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6415 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
6416
6417 hr = IDirect3DVertexBuffer9_Lock(vb_strip, 0, sizeof(quad_strip), (void **) &data, 0);
6418 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
6419 memcpy(data, quad_strip, sizeof(quad_strip));
6420 hr = IDirect3DVertexBuffer9_Unlock(vb_strip);
6421 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
6422
6423 hr = IDirect3DVertexBuffer9_Lock(vb_list, 0, sizeof(quad_list), (void **) &data, 0);
6424 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
6425 memcpy(data, quad_list, sizeof(quad_list));
6426 hr = IDirect3DVertexBuffer9_Unlock(vb_list);
6427 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
6428
6429 /* Try it first with a TRIANGLESTRIP. Do it with different geometry because
6430 * the color fixups we have to do for FLAT shading will be dependent on that. */
6431 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_strip, 0, sizeof(quad_strip[0]));
6432 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6433
6434 /* First loop uses a TRIANGLESTRIP geometry, 2nd uses a TRIANGLELIST */
6435 for (j=0; j<2; j++) {
6436
6437 /* Inner loop just changes the D3DRS_SHADEMODE */
6438 for (i=0; i<3; i++) {
6439 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6440 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6441
6442 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, shademode);
6443 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6444
6445 hr = IDirect3DDevice9_BeginScene(device);
6446 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
6447 if(SUCCEEDED(hr))
6448 {
6449 hr = IDirect3DDevice9_DrawPrimitive(device, primtype, 0, 2);
6450 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed with %s\n", DXGetErrorString9(hr));
6451
6452 hr = IDirect3DDevice9_EndScene(device);
6453 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
6454 }
6455
6456 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6457 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6458
6459 /* Sample two spots from the output */
6460 color0 = getPixelColor(device, 100, 100); /* Inside first triangle */
6461 color1 = getPixelColor(device, 500, 350); /* Inside second triangle */
6462 switch(shademode) {
6463 case D3DSHADE_FLAT:
6464 /* Should take the color of the first vertex of each triangle */
6465 todo_wine ok(color0 == 0x00ff0000, "FLAT shading has color0 %08x, expected 0x00ff0000 (todo)\n", color0);
6466 todo_wine ok(color1 == 0x0000ff00, "FLAT shading has color1 %08x, expected 0x0000ff00 (todo)\n", color1);
6467 shademode = D3DSHADE_GOURAUD;
6468 break;
6469 case D3DSHADE_GOURAUD:
6470 /* Should be an interpolated blend */
6471
6472 r = (color0 & 0x00ff0000) >> 16;
6473 g = (color0 & 0x0000ff00) >> 8;
6474 b = (color0 & 0x000000ff);
6475 ok(r >= 0x0c && r <= 0x0e && g == 0xca && b >= 0x27 && b <= 0x28,
6476 "GOURAUD shading has color0 %08x, expected 0x000dca28\n", color0);
6477 r = (color1 & 0x00ff0000) >> 16;
6478 g = (color1 & 0x0000ff00) >> 8;
6479 b = (color1 & 0x000000ff);
6480 ok(r >= 0x0c && r <= 0x0d && g >= 0x44 && g <= 0x45 && b >= 0xc7 && b <= 0xc8,
6481 "GOURAUD shading has color1 %08x, expected 0x000d45c7\n", color1);
6482
6483 color0_gouraud = color0;
6484 color1_gouraud = color1;
6485
6486 shademode = D3DSHADE_PHONG;
6487 break;
6488 case D3DSHADE_PHONG:
6489 /* Should be the same as GOURAUD, since no hardware implements this */
6490 r = (color0 & 0x00ff0000) >> 16;
6491 g = (color0 & 0x0000ff00) >> 8;
6492 b = (color0 & 0x000000ff);
6493 ok(r >= 0x0c && r <= 0x0e && g == 0xca && b >= 0x27 && b <= 0x28,
6494 "PHONG shading has color0 %08x, expected 0x000dca28\n", color0);
6495 r = (color1 & 0x00ff0000) >> 16;
6496 g = (color1 & 0x0000ff00) >> 8;
6497 b = (color1 & 0x000000ff);
6498 ok(r >= 0x0c && r <= 0x0d && g >= 0x44 && g <= 0x45 && b >= 0xc7 && b <= 0xc8,
6499 "PHONG shading has color1 %08x, expected 0x000d45c7\n", color1);
6500
6501 ok(color0 == color0_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6502 color0_gouraud, color0);
6503 ok(color1 == color1_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6504 color1_gouraud, color1);
6505 break;
6506 }
6507 }
6508 /* Now, do it all over again with a TRIANGLELIST */
6509 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_list, 0, sizeof(quad_list[0]));
6510 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6511 primtype = D3DPT_TRIANGLELIST;
6512 shademode = D3DSHADE_FLAT;
6513 }
6514
6515 bail:
6516 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
6517 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
6518 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
6519 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6520
6521 if (vb_strip)
6522 IDirect3DVertexBuffer9_Release(vb_strip);
6523 if (vb_list)
6524 IDirect3DVertexBuffer9_Release(vb_list);
6525 }
6526
6527
6528 static void fog_srgbwrite_test(IDirect3DDevice9 *device)
6529 {
6530 /* Draw a black quad, half fogged with white fog -> grey color. Enable sRGB writing.
6531 * if sRGB writing is applied before fogging, the 0.0 will be multiplied with ~ 12.92, so still
6532 * stay 0.0. After that the fog gives 0.5. If sRGB writing is applied after fogging, the
6533 * 0.5 will run through the alternative path(0^5 ^ 0.41666 * 1.055 - 0.055), resulting in approx.
6534 * 0.73
6535 *
6536 * At the time of this writing, wined3d could not apply sRGB correction to fixed function rendering,
6537 * so use shaders for this task
6538 */
6539 IDirect3DPixelShader9 *pshader;
6540 IDirect3DVertexShader9 *vshader;
6541 IDirect3D9 *d3d;
6542 DWORD vshader_code[] = {
6543 0xfffe0101, /* vs_1_1 */
6544 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
6545 0x00000051, 0xa00f0000, 0x3f000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0 */
6546 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
6547 0x00000001, 0xc00f0001, 0xa0000000, /* mov oFog, c0.x */
6548 0x0000ffff /* end */
6549 };
6550 DWORD pshader_code[] = {
6551 0xffff0101, /* ps_1_1 */
6552 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
6553 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
6554 0x0000ffff /* end */
6555 };
6556 const float quad[] = {
6557 -1.0, -1.0, 0.1,
6558 1.0, -1.0, 0.1,
6559 -1.0, 1.0, 0.1,
6560 1.0, 1.0, 0.1
6561 };
6562 HRESULT hr;
6563 DWORD color;
6564
6565 IDirect3DDevice9_GetDirect3D(device, &d3d);
6566 /* Ask for srgb writing on D3DRTYPE_TEXTURE. Some Windows drivers do not report it on surfaces.
6567 * For some not entirely understood reasons D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE
6568 * passes on surfaces, while asking for SRGBWRITE alone fails. Textures advertize srgb writing
6569 * alone as well, so use that since it is not the point of this test to show how CheckDeviceFormat
6570 * works
6571 */
6572 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6573 D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE,
6574 D3DRTYPE_TEXTURE, D3DFMT_A8R8G8B8) != D3D_OK) {
6575 skip("No SRGBWRITEENABLE support on D3DFMT_X8R8G8B8\n");
6576 IDirect3D9_Release(d3d);
6577 return;
6578 }
6579 IDirect3D9_Release(d3d);
6580
6581 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
6582 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
6583
6584 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
6585 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6586 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
6587 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6588 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
6589 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6590 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xffffffff);
6591 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6592 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, TRUE);
6593 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6594
6595 hr = IDirect3DDevice9_CreateVertexShader(device, vshader_code, &vshader);
6596 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %s\n", DXGetErrorString9(hr));
6597 hr = IDirect3DDevice9_CreatePixelShader(device, pshader_code, &pshader);
6598 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %s\n", DXGetErrorString9(hr));
6599 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
6600 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
6601 hr = IDirect3DDevice9_SetVertexShader(device, vshader);
6602 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6603 hr = IDirect3DDevice9_SetPixelShader(device, pshader);
6604 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
6605
6606 hr = IDirect3DDevice9_BeginScene(device);
6607 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
6608 if(SUCCEEDED(hr)) {
6609 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 3);
6610 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6611
6612 hr = IDirect3DDevice9_EndScene(device);
6613 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
6614 }
6615
6616 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
6617 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %s\n", DXGetErrorString9(hr));
6618 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
6619 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %s\n", DXGetErrorString9(hr));
6620 IDirect3DPixelShader9_Release(pshader);
6621 IDirect3DVertexShader9_Release(vshader);
6622
6623 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
6624 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6625 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, FALSE);
6626 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6627
6628 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6629 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
6630 color = getPixelColor(device, 160, 360);
6631 ok(color == 0x00808080 || color == 0x007f7f7f || color == 0x00818181,
6632 "Fog with D3DRS_SRGBWRITEENABLE returned color 0x%08x, expected 0x00808080\n", color);
6633 }
6634
6635 static void alpha_test(IDirect3DDevice9 *device)
6636 {
6637 HRESULT hr;
6638 IDirect3DTexture9 *offscreenTexture;
6639 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
6640 DWORD color, red, green, blue;
6641
6642 struct vertex quad1[] =
6643 {
6644 {-1.0f, -1.0f, 0.1f, 0x4000ff00},
6645 {-1.0f, 0.0f, 0.1f, 0x4000ff00},
6646 { 1.0f, -1.0f, 0.1f, 0x4000ff00},
6647 { 1.0f, 0.0f, 0.1f, 0x4000ff00},
6648 };
6649 struct vertex quad2[] =
6650 {
6651 {-1.0f, 0.0f, 0.1f, 0xc00000ff},
6652 {-1.0f, 1.0f, 0.1f, 0xc00000ff},
6653 { 1.0f, 0.0f, 0.1f, 0xc00000ff},
6654 { 1.0f, 1.0f, 0.1f, 0xc00000ff},
6655 };
6656 static const float composite_quad[][5] = {
6657 { 0.0f, -1.0f, 0.1f, 0.0f, 1.0f},
6658 { 0.0f, 1.0f, 0.1f, 0.0f, 0.0f},
6659 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f},
6660 { 1.0f, 1.0f, 0.1f, 1.0f, 0.0f},
6661 };
6662
6663 /* Clear the render target with alpha = 0.5 */
6664 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6665 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6666
6667 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
6668 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %#08x\n", hr);
6669
6670 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
6671 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
6672 if(!backbuffer) {
6673 goto out;
6674 }
6675
6676 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
6677 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
6678 if(!offscreen) {
6679 goto out;
6680 }
6681
6682 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6683 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6684
6685 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
6686 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
6687 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
6688 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
6689 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
6690 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
6691 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
6692 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
6693 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6694 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
6695
6696 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
6697 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6698 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
6699
6700 /* Draw two quads, one with src alpha blending, one with dest alpha blending. The
6701 * SRCALPHA / INVSRCALPHA blend doesn't give any surprises. Colors are blended based on
6702 * the input alpha
6703 *
6704 * The DESTALPHA / INVDESTALPHA do not "work" on the regular buffer because there is no alpha.
6705 * They give essentially ZERO and ONE blend factors
6706 */
6707 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6708 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6709 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6710 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6711 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6712 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6713
6714 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6715 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6716 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6717 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6718 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6719 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6720
6721 /* Switch to the offscreen buffer, and redo the testing. SRCALPHA and DESTALPHA. The offscreen buffer
6722 * has a alpha channel on its own. Clear the offscreen buffer with alpha = 0.5 again, then draw the
6723 * quads again. The SRCALPHA/INVSRCALPHA doesn't give any surprises, but the DESTALPHA/INVDESTALPHA
6724 * blending works as supposed now - blend factor is 0.5 in both cases, not 0.75 as from the input
6725 * vertices
6726 */
6727 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
6728 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6729 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6730 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6731
6732 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6733 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6734 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6735 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6736 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6737 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6738
6739 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6740 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6741 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6742 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6743 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6744 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6745
6746 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
6747 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6748
6749 /* Render the offscreen texture onto the frame buffer to be able to compare it regularly.
6750 * Disable alpha blending for the final composition
6751 */
6752 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
6753 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6754 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6755 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6756
6757 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
6758 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6759 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, composite_quad, sizeof(float) * 5);
6760 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6761 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6762 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6763
6764 hr = IDirect3DDevice9_EndScene(device);
6765 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
6766 }
6767
6768 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6769
6770 color = getPixelColor(device, 160, 360);
6771 red = (color & 0x00ff0000) >> 16;
6772 green = (color & 0x0000ff00) >> 8;
6773 blue = (color & 0x000000ff);
6774 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
6775 "SRCALPHA on frame buffer returned color %08x, expected 0x00bf4000\n", color);
6776
6777 color = getPixelColor(device, 160, 120);
6778 red = (color & 0x00ff0000) >> 16;
6779 green = (color & 0x0000ff00) >> 8;
6780 blue = (color & 0x000000ff);
6781 ok(red == 0x00 && green == 0x00 && blue >= 0xfe && blue <= 0xff ,
6782 "DSTALPHA on frame buffer returned color %08x, expected 0x00ff0000\n", color);
6783
6784 color = getPixelColor(device, 480, 360);
6785 red = (color & 0x00ff0000) >> 16;
6786 green = (color & 0x0000ff00) >> 8;
6787 blue = (color & 0x000000ff);
6788 ok(red >= 0xbe && red <= 0xc0 && green >= 0x39 && green <= 0x41 && blue == 0x00,
6789 "SRCALPHA on texture returned color %08x, expected bar\n", color);
6790
6791 color = getPixelColor(device, 480, 120);
6792 red = (color & 0x00ff0000) >> 16;
6793 green = (color & 0x0000ff00) >> 8;
6794 blue = (color & 0x000000ff);
6795 ok(red >= 0x7e && red <= 0x81 && green == 0x00 && blue >= 0x7e && blue <= 0x81,
6796 "DSTALPHA on texture returned color %08x, expected 0x00800080\n", color);
6797
6798 out:
6799 /* restore things */
6800 if(backbuffer) {
6801 IDirect3DSurface9_Release(backbuffer);
6802 }
6803 if(offscreenTexture) {
6804 IDirect3DTexture9_Release(offscreenTexture);
6805 }
6806 if(offscreen) {
6807 IDirect3DSurface9_Release(offscreen);
6808 }
6809 }
6810
6811 struct vertex_shortcolor {
6812 float x, y, z;
6813 unsigned short r, g, b, a;
6814 };
6815 struct vertex_floatcolor {
6816 float x, y, z;
6817 float r, g, b, a;
6818 };
6819
6820 static void fixed_function_decl_test(IDirect3DDevice9 *device)
6821 {
6822 HRESULT hr;
6823 BOOL s_ok, ub_ok, f_ok;
6824 DWORD color, size, i;
6825 void *data;
6826 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor[] = {
6827 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6828 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6829 D3DDECL_END()
6830 };
6831 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor_2streams[] = {
6832 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6833 {1, 0, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6834 D3DDECL_END()
6835 };
6836 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n[] = {
6837 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6838 {0, 12, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6839 D3DDECL_END()
6840 };
6841 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n_2streams[] = {
6842 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6843 {1, 0, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6844 D3DDECL_END()
6845 };
6846 static const D3DVERTEXELEMENT9 decl_elements_short4[] = {
6847 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6848 {0, 12, D3DDECLTYPE_USHORT4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6849 D3DDECL_END()
6850 };
6851 static const D3DVERTEXELEMENT9 decl_elements_float[] = {
6852 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6853 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6854 D3DDECL_END()
6855 };
6856 static const D3DVERTEXELEMENT9 decl_elements_positiont[] = {
6857 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
6858 {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6859 D3DDECL_END()
6860 };
6861 IDirect3DVertexDeclaration9 *dcl_float = NULL, *dcl_short = NULL, *dcl_ubyte = NULL, *dcl_color = NULL;
6862 IDirect3DVertexDeclaration9 *dcl_color_2 = NULL, *dcl_ubyte_2 = NULL, *dcl_positiont;
6863 IDirect3DVertexBuffer9 *vb, *vb2;
6864 struct vertex quad1[] = /* D3DCOLOR */
6865 {
6866 {-1.0f, -1.0f, 0.1f, 0x00ffff00},
6867 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6868 { 0.0f, -1.0f, 0.1f, 0x00ffff00},
6869 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6870 };
6871 struct vertex quad2[] = /* UBYTE4N */
6872 {
6873 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6874 {-1.0f, 1.0f, 0.1f, 0x00ffff00},
6875 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6876 { 0.0f, 1.0f, 0.1f, 0x00ffff00},
6877 };
6878 struct vertex_shortcolor quad3[] = /* short */
6879 {
6880 { 0.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6881 { 0.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6882 { 1.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6883 { 1.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6884 };
6885 struct vertex_floatcolor quad4[] =
6886 {
6887 { 0.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6888 { 0.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6889 { 1.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6890 { 1.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6891 };
6892 DWORD colors[] = {
6893 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6894 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6895 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6896 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6897 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6898 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6899 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6900 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6901 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6902 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
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 };
6910 float quads[] = {
6911 -1.0, -1.0, 0.1,
6912 -1.0, 0.0, 0.1,
6913 0.0, -1.0, 0.1,
6914 0.0, 0.0, 0.1,
6915
6916 0.0, -1.0, 0.1,
6917 0.0, 0.0, 0.1,
6918 1.0, -1.0, 0.1,
6919 1.0, 0.0, 0.1,
6920
6921 0.0, 0.0, 0.1,
6922 0.0, 1.0, 0.1,
6923 1.0, 0.0, 0.1,
6924 1.0, 1.0, 0.1,
6925
6926 -1.0, 0.0, 0.1,
6927 -1.0, 1.0, 0.1,
6928 0.0, 0.0, 0.1,
6929 0.0, 1.0, 0.1
6930 };
6931 struct tvertex quad_transformed[] = {
6932 { 90, 110, 0.1, 2.0, 0x00ffff00},
6933 { 570, 110, 0.1, 2.0, 0x00ffff00},
6934 { 90, 300, 0.1, 2.0, 0x00ffff00},
6935 { 570, 300, 0.1, 2.0, 0x00ffff00}
6936 };
6937 D3DCAPS9 caps;
6938
6939 memset(&caps, 0, sizeof(caps));
6940 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
6941 ok(hr == D3D_OK, "GetDeviceCaps failed, hr = %08x\n", hr);
6942
6943 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6944 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6945
6946 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor, &dcl_color);
6947 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6948 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_short4, &dcl_short);
6949 ok(SUCCEEDED(hr) || hr == E_FAIL, "CreateVertexDeclaration failed (%08x)\n", hr);
6950 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_float, &dcl_float);
6951 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6952 if(caps.DeclTypes & D3DDTCAPS_UBYTE4N) {
6953 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n_2streams, &dcl_ubyte_2);
6954 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6955 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n, &dcl_ubyte);
6956 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6957 } else {
6958 trace("D3DDTCAPS_UBYTE4N not supported\n");
6959 dcl_ubyte_2 = NULL;
6960 dcl_ubyte = NULL;
6961 }
6962 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor_2streams, &dcl_color_2);
6963 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6964 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_positiont, &dcl_positiont);
6965 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6966
6967 size = max(sizeof(quad1), max(sizeof(quad2), max(sizeof(quad3), max(sizeof(quad4), sizeof(quads)))));
6968 hr = IDirect3DDevice9_CreateVertexBuffer(device, size,
6969 0, 0, D3DPOOL_MANAGED, &vb, NULL);
6970 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
6971
6972 hr = IDirect3DDevice9_BeginScene(device);
6973 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
6974 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
6975 if(SUCCEEDED(hr)) {
6976 if(dcl_color) {
6977 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
6978 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
6979 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6980 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6981 }
6982
6983 /* Tests with non-standard fixed function types fail on the refrast. The ATI driver partially
6984 * accepts them, the nvidia driver accepts them all. All those differences even though we're
6985 * using software vertex processing. Doh!
6986 */
6987 if(dcl_ubyte) {
6988 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
6989 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
6990 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6991 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6992 ub_ok = SUCCEEDED(hr);
6993 }
6994
6995 if(dcl_short) {
6996 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
6997 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
6998 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(quad3[0]));
6999 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7000 s_ok = SUCCEEDED(hr);
7001 }
7002
7003 if(dcl_float) {
7004 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7005 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7006 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(quad4[0]));
7007 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7008 f_ok = SUCCEEDED(hr);
7009 }
7010
7011 hr = IDirect3DDevice9_EndScene(device);
7012 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7013 }
7014
7015 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7016 if(dcl_short) {
7017 color = getPixelColor(device, 480, 360);
7018 ok(color == 0x000000ff || !s_ok,
7019 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7020 }
7021 if(dcl_ubyte) {
7022 color = getPixelColor(device, 160, 120);
7023 ok(color == 0x0000ffff || !ub_ok,
7024 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7025 }
7026 if(dcl_color) {
7027 color = getPixelColor(device, 160, 360);
7028 ok(color == 0x00ffff00,
7029 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7030 }
7031 if(dcl_float) {
7032 color = getPixelColor(device, 480, 120);
7033 ok(color == 0x00ff0000 || !f_ok,
7034 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7035 }
7036
7037 /* The following test with vertex buffers doesn't serve to find out new information from windows.
7038 * It is a plain regression test because wined3d uses different codepaths for attribute conversion
7039 * with vertex buffers. It makes sure that the vertex buffer one works, while the above tests
7040 * whether the immediate mode code works
7041 */
7042 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7043 hr = IDirect3DDevice9_BeginScene(device);
7044 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7045 if(SUCCEEDED(hr)) {
7046 if(dcl_color) {
7047 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad1), (void **) &data, 0);
7048 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7049 memcpy(data, quad1, sizeof(quad1));
7050 hr = IDirect3DVertexBuffer9_Unlock(vb);
7051 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7052 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7053 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7054 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad1[0]));
7055 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7056 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7057 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7058 }
7059
7060 if(dcl_ubyte) {
7061 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad2), (void **) &data, 0);
7062 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7063 memcpy(data, quad2, sizeof(quad2));
7064 hr = IDirect3DVertexBuffer9_Unlock(vb);
7065 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7066 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7067 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7068 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad2[0]));
7069 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7070 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7071 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7072 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7073 ub_ok = SUCCEEDED(hr);
7074 }
7075
7076 if(dcl_short) {
7077 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad3), (void **) &data, 0);
7078 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7079 memcpy(data, quad3, sizeof(quad3));
7080 hr = IDirect3DVertexBuffer9_Unlock(vb);
7081 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7082 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7083 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7084 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad3[0]));
7085 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7086 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7087 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7088 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7089 s_ok = SUCCEEDED(hr);
7090 }
7091
7092 if(dcl_float) {
7093 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad4), (void **) &data, 0);
7094 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7095 memcpy(data, quad4, sizeof(quad4));
7096 hr = IDirect3DVertexBuffer9_Unlock(vb);
7097 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7098 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7099 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7100 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad4[0]));
7101 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7102 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7103 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7104 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7105 f_ok = SUCCEEDED(hr);
7106 }
7107
7108 hr = IDirect3DDevice9_EndScene(device);
7109 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7110 }
7111
7112 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7113 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7114 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7115 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7116
7117 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7118 if(dcl_short) {
7119 color = getPixelColor(device, 480, 360);
7120 ok(color == 0x000000ff || !s_ok,
7121 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7122 }
7123 if(dcl_ubyte) {
7124 color = getPixelColor(device, 160, 120);
7125 ok(color == 0x0000ffff || !ub_ok,
7126 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7127 }
7128 if(dcl_color) {
7129 color = getPixelColor(device, 160, 360);
7130 ok(color == 0x00ffff00,
7131 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7132 }
7133 if(dcl_float) {
7134 color = getPixelColor(device, 480, 120);
7135 ok(color == 0x00ff0000 || !f_ok,
7136 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7137 }
7138
7139 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7140 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
7141
7142 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad_transformed), (void **) &data, 0);
7143 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7144 memcpy(data, quad_transformed, sizeof(quad_transformed));
7145 hr = IDirect3DVertexBuffer9_Unlock(vb);
7146 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7147
7148 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_positiont);
7149 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7150
7151 hr = IDirect3DDevice9_BeginScene(device);
7152 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7153 if(SUCCEEDED(hr)) {
7154 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad_transformed[0]));
7155 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7156 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7157 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7158
7159 hr = IDirect3DDevice9_EndScene(device);
7160 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7161 }
7162
7163 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7164 color = getPixelColor(device, 88, 108);
7165 ok(color == 0x000000ff,
7166 "pixel 88/108 has color %08x, expected 0x000000ff\n", color);
7167 color = getPixelColor(device, 92, 108);
7168 ok(color == 0x000000ff,
7169 "pixel 92/108 has color %08x, expected 0x000000ff\n", color);
7170 color = getPixelColor(device, 88, 112);
7171 ok(color == 0x000000ff,
7172 "pixel 88/112 has color %08x, expected 0x000000ff\n", color);
7173 color = getPixelColor(device, 92, 112);
7174 ok(color == 0x00ffff00,
7175 "pixel 92/112 has color %08x, expected 0x00ffff00\n", color);
7176
7177 color = getPixelColor(device, 568, 108);
7178 ok(color == 0x000000ff,
7179 "pixel 568/108 has color %08x, expected 0x000000ff\n", color);
7180 color = getPixelColor(device, 572, 108);
7181 ok(color == 0x000000ff,
7182 "pixel 572/108 has color %08x, expected 0x000000ff\n", color);
7183 color = getPixelColor(device, 568, 112);
7184 ok(color == 0x00ffff00,
7185 "pixel 568/112 has color %08x, expected 0x00ffff00\n", color);
7186 color = getPixelColor(device, 572, 112);
7187 ok(color == 0x000000ff,
7188 "pixel 572/112 has color %08x, expected 0x000000ff\n", color);
7189
7190 color = getPixelColor(device, 88, 298);
7191 ok(color == 0x000000ff,
7192 "pixel 88/298 has color %08x, expected 0x000000ff\n", color);
7193 color = getPixelColor(device, 92, 298);
7194 ok(color == 0x00ffff00,
7195 "pixel 92/298 has color %08x, expected 0x00ffff00\n", color);
7196 color = getPixelColor(device, 88, 302);
7197 ok(color == 0x000000ff,
7198 "pixel 88/302 has color %08x, expected 0x000000ff\n", color);
7199 color = getPixelColor(device, 92, 302);
7200 ok(color == 0x000000ff,
7201 "pixel 92/302 has color %08x, expected 0x000000ff\n", color);
7202
7203 color = getPixelColor(device, 568, 298);
7204 ok(color == 0x00ffff00,
7205 "pixel 568/298 has color %08x, expected 0x00ffff00\n", color);
7206 color = getPixelColor(device, 572, 298);
7207 ok(color == 0x000000ff,
7208 "pixel 572/298 has color %08x, expected 0x000000ff\n", color);
7209 color = getPixelColor(device, 568, 302);
7210 ok(color == 0x000000ff,
7211 "pixel 568/302 has color %08x, expected 0x000000ff\n", color);
7212 color = getPixelColor(device, 572, 302);
7213 ok(color == 0x000000ff,
7214 "pixel 572/302 has color %08x, expected 0x000000ff\n", color);
7215
7216 /* This test is pointless without those two declarations: */
7217 if((!dcl_color_2) || (!dcl_ubyte_2)) {
7218 skip("color-ubyte switching test declarations aren't supported\n");
7219 goto out;
7220 }
7221
7222 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quads), (void **) &data, 0);
7223 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7224 memcpy(data, quads, sizeof(quads));
7225 hr = IDirect3DVertexBuffer9_Unlock(vb);
7226 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7227 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(colors),
7228 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
7229 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
7230 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(colors), (void **) &data, 0);
7231 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
7232 memcpy(data, colors, sizeof(colors));
7233 hr = IDirect3DVertexBuffer9_Unlock(vb2);
7234 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7235
7236 for(i = 0; i < 2; i++) {
7237 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
7238 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
7239
7240 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(float) * 3);
7241 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7242 if(i == 0) {
7243 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 0, sizeof(DWORD) * 4);
7244 } else {
7245 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 8, sizeof(DWORD) * 4);
7246 }
7247 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7248
7249 hr = IDirect3DDevice9_BeginScene(device);
7250 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
7251 ub_ok = FALSE;
7252 if(SUCCEEDED(hr)) {
7253 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7254 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7255 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7256 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7257 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7258 ub_ok = SUCCEEDED(hr);
7259
7260 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color_2);
7261 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7262 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7263 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7264
7265 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7266 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %s\n", DXGetErrorString9(hr));
7267 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7268 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7269 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7270 ub_ok = (SUCCEEDED(hr) && ub_ok);
7271
7272 hr = IDirect3DDevice9_EndScene(device);
7273 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
7274 }
7275
7276 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7277 if(i == 0) {
7278 color = getPixelColor(device, 480, 360);
7279 ok(color == 0x00ff0000,
7280 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ff0000\n", color);
7281 color = getPixelColor(device, 160, 120);
7282 ok(color == 0x00ffffff,
7283 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7284 color = getPixelColor(device, 160, 360);
7285 ok(color == 0x000000ff || !ub_ok,
7286 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7287 color = getPixelColor(device, 480, 120);
7288 ok(color == 0x000000ff || !ub_ok,
7289 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7290 } else {
7291 color = getPixelColor(device, 480, 360);
7292 ok(color == 0x000000ff,
7293 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x000000ff\n", color);
7294 color = getPixelColor(device, 160, 120);
7295 ok(color == 0x00ffffff,
7296 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7297 color = getPixelColor(device, 160, 360);
7298 ok(color == 0x00ff0000 || !ub_ok,
7299 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7300 color = getPixelColor(device, 480, 120);
7301 ok(color == 0x00ff0000 || !ub_ok,
7302 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7303 }
7304 }
7305
7306 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7307 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7308 hr = IDirect3DDevice9_SetStreamSource(device, 1, NULL, 0, 0);
7309 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %s\n", DXGetErrorString9(hr));
7310 IDirect3DVertexBuffer9_Release(vb2);
7311
7312 out:
7313 IDirect3DVertexBuffer9_Release(vb);
7314 if(dcl_float) IDirect3DVertexDeclaration9_Release(dcl_float);
7315 if(dcl_short) IDirect3DVertexDeclaration9_Release(dcl_short);
7316 if(dcl_ubyte) IDirect3DVertexDeclaration9_Release(dcl_ubyte);
7317 if(dcl_color) IDirect3DVertexDeclaration9_Release(dcl_color);
7318 if(dcl_color_2) IDirect3DVertexDeclaration9_Release(dcl_color_2);
7319 if(dcl_ubyte_2) IDirect3DVertexDeclaration9_Release(dcl_ubyte_2);
7320 if(dcl_positiont) IDirect3DVertexDeclaration9_Release(dcl_positiont);
7321 }
7322
7323 struct vertex_float16color {
7324 float x, y, z;
7325 DWORD c1, c2;
7326 };
7327
7328 static void test_vshader_float16(IDirect3DDevice9 *device)
7329 {
7330 HRESULT hr;
7331 DWORD color;
7332 void *data;
7333 static const D3DVERTEXELEMENT9 decl_elements[] = {
7334 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7335 {0, 12, D3DDECLTYPE_FLOAT16_4,D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
7336 D3DDECL_END()
7337 };
7338 IDirect3DVertexDeclaration9 *vdecl = NULL;
7339 IDirect3DVertexBuffer9 *buffer = NULL;
7340 IDirect3DVertexShader9 *shader;
7341 DWORD shader_code[] = {
7342 0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000001f, 0x8000000a,
7343 0x900f0001, 0x00000001, 0xc00f0000, 0x90e40000, 0x00000001, 0xd00f0000,
7344 0x90e40001, 0x0000ffff
7345 };
7346 struct vertex_float16color quad[] = {
7347 { -1.0, -1.0, 0.1, 0x3c000000, 0x00000000 }, /* green */
7348 { -1.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7349 { 0.0, -1.0, 0.1, 0x3c000000, 0x00000000 },
7350 { 0.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7351
7352 { 0.0, -1.0, 0.1, 0x00003c00, 0x00000000 }, /* red */
7353 { 0.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7354 { 1.0, -1.0, 0.1, 0x00003c00, 0x00000000 },
7355 { 1.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7356
7357 { 0.0, 0.0, 0.1, 0x00000000, 0x00003c00 }, /* blue */
7358 { 0.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7359 { 1.0, 0.0, 0.1, 0x00000000, 0x00003c00 },
7360 { 1.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7361
7362 { -1.0, 0.0, 0.1, 0x00000000, 0x3c000000 }, /* alpha */
7363 { -1.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7364 { 0.0, 0.0, 0.1, 0x00000000, 0x3c000000 },
7365 { 0.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7366 };
7367
7368 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7369 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7370
7371 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vdecl);
7372 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%s\n", DXGetErrorString9(hr));
7373 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
7374 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7375 hr = IDirect3DDevice9_SetVertexShader(device, shader);
7376 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7377
7378 hr = IDirect3DDevice9_BeginScene(device);
7379 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7380 if(SUCCEEDED(hr)) {
7381 hr = IDirect3DDevice9_SetVertexDeclaration(device, vdecl);
7382 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7383 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 0, sizeof(quad[0]));
7384 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7385 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 4, sizeof(quad[0]));
7386 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7387 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 8, sizeof(quad[0]));
7388 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7389 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 12, sizeof(quad[0]));
7390 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7391
7392 hr = IDirect3DDevice9_EndScene(device);
7393 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
7394 }
7395 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7396 color = getPixelColor(device, 480, 360);
7397 ok(color == 0x00ff0000,
7398 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7399 color = getPixelColor(device, 160, 120);
7400 ok(color == 0x00000000,
7401 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7402 color = getPixelColor(device, 160, 360);
7403 ok(color == 0x0000ff00,
7404 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7405 color = getPixelColor(device, 480, 120);
7406 ok(color == 0x000000ff,
7407 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7408
7409 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7410 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7411
7412 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0,
7413 D3DPOOL_MANAGED, &buffer, NULL);
7414 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexBuffer failed, hr=%s\n", DXGetErrorString9(hr));
7415 hr = IDirect3DVertexBuffer9_Lock(buffer, 0, sizeof(quad), (void **) &data, 0);
7416 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed, hr=%s\n", DXGetErrorString9(hr));
7417 memcpy(data, quad, sizeof(quad));
7418 hr = IDirect3DVertexBuffer9_Unlock(buffer);
7419 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed, hr=%s\n", DXGetErrorString9(hr));
7420 hr = IDirect3DDevice9_SetStreamSource(device, 0, buffer, 0, sizeof(quad[0]));
7421 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%s\n", DXGetErrorString9(hr));
7422
7423 hr = IDirect3DDevice9_BeginScene(device);
7424 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7425 if(SUCCEEDED(hr)) {
7426 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7427 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7428 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7429 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7430 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7431 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7432 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 12, 2);
7433 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7434
7435 hr = IDirect3DDevice9_EndScene(device);
7436 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
7437 }
7438
7439 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7440 color = getPixelColor(device, 480, 360);
7441 ok(color == 0x00ff0000,
7442 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7443 color = getPixelColor(device, 160, 120);
7444 ok(color == 0x00000000,
7445 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7446 color = getPixelColor(device, 160, 360);
7447 ok(color == 0x0000ff00,
7448 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7449 color = getPixelColor(device, 480, 120);
7450 ok(color == 0x000000ff,
7451 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7452
7453 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7454 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%s\n", DXGetErrorString9(hr));
7455 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7456 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7457 IDirect3DDevice9_SetVertexShader(device, NULL);
7458 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
7459
7460 IDirect3DVertexDeclaration9_Release(vdecl);
7461 IDirect3DVertexShader9_Release(shader);
7462 IDirect3DVertexBuffer9_Release(buffer);
7463 }
7464
7465 static void conditional_np2_repeat_test(IDirect3DDevice9 *device)
7466 {
7467 D3DCAPS9 caps;
7468 IDirect3DTexture9 *texture;
7469 HRESULT hr;
7470 D3DLOCKED_RECT rect;
7471 unsigned int x, y;
7472 DWORD *dst, color;
7473 const float quad[] = {
7474 -1.0, -1.0, 0.1, -0.2, -0.2,
7475 1.0, -1.0, 0.1, 1.2, -0.2,
7476 -1.0, 1.0, 0.1, -0.2, 1.2,
7477 1.0, 1.0, 0.1, 1.2, 1.2
7478 };
7479 memset(&caps, 0, sizeof(caps));
7480
7481 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7482 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
7483 if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7484 /* NP2 conditional requires the POW2 flag. Check that while we're at it */
7485 ok((caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) == 0,
7486 "Card has conditional NP2 support without power of two restriction set\n");
7487 skip("Card has unconditional pow2 support, skipping conditional NP2 tests\n");
7488 return;
7489 } else if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7490 skip("No conditional NP2 support, skipping conditional NP2 tests\n");
7491 return;
7492 }
7493
7494 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
7495 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7496
7497 hr = IDirect3DDevice9_CreateTexture(device, 10, 10, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
7498 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%s\n", DXGetErrorString9(hr));
7499
7500 memset(&rect, 0, sizeof(rect));
7501 hr = IDirect3DTexture9_LockRect(texture, 0, &rect, NULL, 0);
7502 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed hr=%s\n", DXGetErrorString9(hr));
7503 for(y = 0; y < 10; y++) {
7504 for(x = 0; x < 10; x++) {
7505 dst = (DWORD *) ((BYTE *) rect.pBits + y * rect.Pitch + x * sizeof(DWORD));
7506 if(x == 0 || x == 9 || y == 0 || y == 9) {
7507 *dst = 0x00ff0000;
7508 } else {
7509 *dst = 0x000000ff;
7510 }
7511 }
7512 }
7513 hr = IDirect3DTexture9_UnlockRect(texture, 0);
7514 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed hr=%s\n", DXGetErrorString9(hr));
7515
7516 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7517 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%s\n", DXGetErrorString9(hr));
7518 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
7519 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%s\n", DXGetErrorString9(hr));
7520 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
7521 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%s\n", DXGetErrorString9(hr));
7522 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7523 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%s\n", DXGetErrorString9(hr));
7524
7525 hr = IDirect3DDevice9_BeginScene(device);
7526 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7527 if(SUCCEEDED(hr)) {
7528 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
7529 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7530
7531 hr = IDirect3DDevice9_EndScene(device);
7532 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
7533 }
7534
7535 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7536
7537 color = getPixelColor(device, 1, 1);
7538 ok(color == 0x00ff0000, "NP2: Pixel 1, 1 has color %08x, expected 0x00ff0000\n", color);
7539 color = getPixelColor(device, 639, 479);
7540 ok(color == 0x00ff0000, "NP2: Pixel 639, 479 has color %08x, expected 0x00ff0000\n", color);
7541
7542 color = getPixelColor(device, 135, 101);
7543 ok(color == 0x00ff0000, "NP2: Pixel 135, 101 has color %08x, expected 0x00ff0000\n", color);
7544 color = getPixelColor(device, 140, 101);
7545 ok(color == 0x00ff0000, "NP2: Pixel 140, 101 has color %08x, expected 0x00ff0000\n", color);
7546 color = getPixelColor(device, 135, 105);
7547 ok(color == 0x00ff0000, "NP2: Pixel 135, 105 has color %08x, expected 0x00ff0000\n", color);
7548 color = getPixelColor(device, 140, 105);
7549 ok(color == 0x000000ff, "NP2: Pixel 140, 105 has color %08x, expected 0x000000ff\n", color);
7550
7551 color = getPixelColor(device, 135, 376);
7552 ok(color == 0x00ff0000, "NP2: Pixel 135, 376 has color %08x, expected 0x00ff0000\n", color);
7553 color = getPixelColor(device, 140, 376);
7554 ok(color == 0x000000ff, "NP2: Pixel 140, 376 has color %08x, expected 0x000000ff\n", color);
7555 color = getPixelColor(device, 135, 379);
7556 ok(color == 0x00ff0000, "NP2: Pixel 135, 379 has color %08x, expected 0x00ff0000\n", color);
7557 color = getPixelColor(device, 140, 379);
7558 ok(color == 0x00ff0000, "NP2: Pixel 140, 379 has color %08x, expected 0x00ff0000\n", color);
7559
7560 color = getPixelColor(device, 500, 101);
7561 ok(color == 0x00ff0000, "NP2: Pixel 500, 101 has color %08x, expected 0x00ff0000\n", color);
7562 color = getPixelColor(device, 504, 101);
7563 ok(color == 0x00ff0000, "NP2: Pixel 504, 101 has color %08x, expected 0x00ff0000\n", color);
7564 color = getPixelColor(device, 500, 105);
7565 ok(color == 0x000000ff, "NP2: Pixel 500, 105 has color %08x, expected 0x000000ff\n", color);
7566 color = getPixelColor(device, 504, 105);
7567 ok(color == 0x00ff0000, "NP2: Pixel 504, 105 has color %08x, expected 0x00ff0000\n", color);
7568
7569 color = getPixelColor(device, 500, 376);
7570 ok(color == 0x000000ff, "NP2: Pixel 500, 376 has color %08x, expected 0x000000ff\n", color);
7571 color = getPixelColor(device, 504, 376);
7572 ok(color == 0x00ff0000, "NP2: Pixel 504, 376 has color %08x, expected 0x00ff0000\n", color);
7573 color = getPixelColor(device, 500, 380);
7574 ok(color == 0x00ff0000, "NP2: Pixel 500, 380 has color %08x, expected 0x00ff0000\n", color);
7575 color = getPixelColor(device, 504, 380);
7576 ok(color == 0x00ff0000, "NP2: Pixel 504, 380 has color %08x, expected 0x00ff0000\n", color);
7577
7578 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7579 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%s\n", DXGetErrorString9(hr));
7580 IDirect3DTexture9_Release(texture);
7581 }
7582
7583 static void vFace_register_test(IDirect3DDevice9 *device)
7584 {
7585 HRESULT hr;
7586 DWORD color;
7587 const DWORD shader_code[] = {
7588 0xffff0300, /* ps_3_0 */
7589 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0.0, 1.0, 0.0, 0.0 */
7590 0x05000051, 0xa00f0001, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1.0, 0.0, 0.0, 0.0 */
7591 0x0200001f, 0x80000000, 0x900f1001, /* dcl vFace */
7592 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
7593 0x04000058, 0x800f0000, 0x90e41001, 0xa0e40000, 0x80e40001, /* cmp r0, vFace, c0, r1 */
7594 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
7595 0x0000ffff /* END */
7596 };
7597 IDirect3DPixelShader9 *shader;
7598 IDirect3DTexture9 *texture;
7599 IDirect3DSurface9 *surface, *backbuffer;
7600 const float quad[] = {
7601 -1.0, -1.0, 0.1,
7602 1.0, -1.0, 0.1,
7603 -1.0, 0.0, 0.1,
7604
7605 1.0, -1.0, 0.1,
7606 1.0, 0.0, 0.1,
7607 -1.0, 0.0, 0.1,
7608
7609 -1.0, 0.0, 0.1,
7610 -1.0, 1.0, 0.1,
7611 1.0, 0.0, 0.1,
7612
7613 1.0, 0.0, 0.1,
7614 -1.0, 1.0, 0.1,
7615 1.0, 1.0, 0.1,
7616 };
7617 const float blit[] = {
7618 0.0, -1.0, 0.1, 0.0, 0.0,
7619 1.0, -1.0, 0.1, 1.0, 0.0,
7620 0.0, 1.0, 0.1, 0.0, 1.0,
7621 1.0, 1.0, 0.1, 1.0, 1.0,
7622 };
7623
7624 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
7625 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
7626 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
7627 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%s\n", DXGetErrorString9(hr));
7628 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
7629 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed hr=%s\n", DXGetErrorString9(hr));
7630 hr = IDirect3DDevice9_SetPixelShader(device, shader);
7631 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
7632 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7633 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
7634 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
7635 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%s\n", DXGetErrorString9(hr));
7636
7637 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7638 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7639
7640 hr = IDirect3DDevice9_BeginScene(device);
7641 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
7642 if(SUCCEEDED(hr)) {
7643 /* First, draw to the texture and the back buffer to test both offscreen and onscreen cases */
7644 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
7645 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
7646 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7647 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
7648 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7649 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7650 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
7651 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
7652 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7653 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7654
7655 /* Blit the texture onto the back buffer to make it visible */
7656 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
7657 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
7658 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7659 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
7660 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7661 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%s\n", DXGetErrorString9(hr));
7662 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7663 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%s\n", DXGetErrorString9(hr));
7664 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7665 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
7666
7667 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, blit, sizeof(float) * 5);
7668 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
7669
7670 hr = IDirect3DDevice9_EndScene(device);
7671 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
7672 }
7673
7674 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7675 color = getPixelColor(device, 160, 360);
7676 ok(color == 0x00ff0000, "vFace: Onscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7677 color = getPixelColor(device, 160, 120);
7678 ok(color == 0x0000ff00, "vFace: Onscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7679 color = getPixelColor(device, 480, 360);
7680 ok(color == 0x0000ff00, "vFace: Offscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7681 color = getPixelColor(device, 480, 120);
7682 ok(color == 0x00ff0000, "vFace: Offscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7683
7684 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
7685 IDirect3DDevice9_SetTexture(device, 0, NULL);
7686 IDirect3DPixelShader9_Release(shader);
7687 IDirect3DSurface9_Release(surface);
7688 IDirect3DSurface9_Release(backbuffer);
7689 IDirect3DTexture9_Release(texture);
7690 }
7691
7692 static void fixed_function_bumpmap_test(IDirect3DDevice9 *device)
7693 {
7694 HRESULT hr;
7695 DWORD color;
7696 int i;
7697 D3DCAPS9 caps;
7698
7699 static const float quad[][7] = {
7700 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
7701 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
7702 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
7703 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
7704 };
7705
7706 static const D3DVERTEXELEMENT9 decl_elements[] = {
7707 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7708 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
7709 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
7710 D3DDECL_END()
7711 };
7712
7713 /* use asymmetric matrix to test loading */
7714 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
7715
7716 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
7717 IDirect3DTexture9 *texture = NULL;
7718
7719 memset(&caps, 0, sizeof(caps));
7720 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7721 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
7722 if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)) {
7723 skip("D3DTEXOPCAPS_BUMPENVMAP not set, skipping bumpmap tests\n");
7724 return;
7725 } else {
7726 /* This check is disabled, some Windows drivers do not handle D3DUSAGE_QUERY_LEGACYBUMPMAP properly.
7727 * They report that it is not supported, but after that bump mapping works properly. So just test
7728 * if the format is generally supported, and check the BUMPENVMAP flag
7729 */
7730 IDirect3D9 *d3d9;
7731
7732 IDirect3DDevice9_GetDirect3D(device, &d3d9);
7733 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7734 D3DRTYPE_TEXTURE, D3DFMT_V8U8);
7735 IDirect3D9_Release(d3d9);
7736 if(FAILED(hr)) {
7737 skip("D3DFMT_V8U8 not supported for legacy bump mapping\n");
7738 return;
7739 }
7740 }
7741
7742 /* Generate the textures */
7743 generate_bumpmap_textures(device);
7744
7745 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
7746 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7747 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
7748 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7749 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
7750 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7751 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
7752 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7753
7754 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAP);
7755 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7756 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
7757 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7758 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
7759 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7760
7761 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7762 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7763 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7764 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7765 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
7766 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7767
7768 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
7769 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7770
7771 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
7772 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
7773
7774 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
7775 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
7776
7777
7778 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
7779 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
7780 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
7781 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
7782
7783 hr = IDirect3DDevice9_BeginScene(device);
7784 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7785
7786 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7787 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7788
7789 hr = IDirect3DDevice9_EndScene(device);
7790 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7791
7792 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7793 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7794
7795 color = getPixelColor(device, 320-32, 240);
7796 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7797 color = getPixelColor(device, 320+32, 240);
7798 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7799 color = getPixelColor(device, 320, 240-32);
7800 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7801 color = getPixelColor(device, 320, 240+32);
7802 ok(color == 0x00ffffff, "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7803 color = getPixelColor(device, 320, 240);
7804 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7805 color = getPixelColor(device, 320+32, 240+32);
7806 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7807 color = getPixelColor(device, 320-32, 240+32);
7808 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7809 color = getPixelColor(device, 320+32, 240-32);
7810 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7811 color = getPixelColor(device, 320-32, 240-32);
7812 ok(color == 0x00000000, "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7813
7814 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7815 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
7816 IDirect3DVertexDeclaration9_Release(vertex_declaration);
7817
7818 for(i = 0; i < 2; i++) {
7819 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
7820 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
7821 IDirect3DTexture9_Release(texture); /* For the GetTexture */
7822 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
7823 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
7824 IDirect3DTexture9_Release(texture); /* To destroy it */
7825 }
7826
7827 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
7828 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7829 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
7830 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7831
7832 }
7833
7834 static void stencil_cull_test(IDirect3DDevice9 *device) {
7835 HRESULT hr;
7836 IDirect3DSurface9 *depthstencil = NULL;
7837 D3DSURFACE_DESC desc;
7838 float quad1[] = {
7839 -1.0, -1.0, 0.1,
7840 0.0, -1.0, 0.1,
7841 -1.0, 0.0, 0.1,
7842 0.0, 0.0, 0.1,
7843 };
7844 float quad2[] = {
7845 0.0, -1.0, 0.1,
7846 1.0, -1.0, 0.1,
7847 0.0, 0.0, 0.1,
7848 1.0, 0.0, 0.1,
7849 };
7850 float quad3[] = {
7851 0.0, 0.0, 0.1,
7852 1.0, 0.0, 0.1,
7853 0.0, 1.0, 0.1,
7854 1.0, 1.0, 0.1,
7855 };
7856 float quad4[] = {
7857 -1.0, 0.0, 0.1,
7858 0.0, 0.0, 0.1,
7859 -1.0, 1.0, 0.1,
7860 0.0, 1.0, 0.1,
7861 };
7862 struct vertex painter[] = {
7863 {-1.0, -1.0, 0.0, 0x00000000},
7864 { 1.0, -1.0, 0.0, 0x00000000},
7865 {-1.0, 1.0, 0.0, 0x00000000},
7866 { 1.0, 1.0, 0.0, 0x00000000},
7867 };
7868 WORD indices_cw[] = {0, 1, 3};
7869 WORD indices_ccw[] = {0, 2, 3};
7870 unsigned int i;
7871 DWORD color;
7872
7873 IDirect3DDevice9_GetDepthStencilSurface(device, &depthstencil);
7874 if(depthstencil == NULL) {
7875 skip("No depth stencil buffer\n");
7876 return;
7877 }
7878 hr = IDirect3DSurface9_GetDesc(depthstencil, &desc);
7879 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %s\n", DXGetErrorString9(hr));
7880 IDirect3DSurface9_Release(depthstencil);
7881 if(desc.Format != D3DFMT_D24S8 && desc.Format != D3DFMT_D24X4S4) {
7882 skip("No 4 or 8 bit stencil surface\n");
7883 return;
7884 }
7885
7886 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, 0x00ff0000, 0.0, 0x8);
7887 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
7888 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7889
7890 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_INCR);
7891 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7892 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
7893 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7894 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
7895 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7896 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, 0x3);
7897 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7898
7899 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_REPLACE);
7900 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7901 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR);
7902 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7903 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILPASS, D3DSTENCILOP_INCR);
7904 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7905
7906 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, TRUE);
7907 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7908 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
7909 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7910
7911 /* First pass: Fill the stencil buffer with some values... */
7912 hr = IDirect3DDevice9_BeginScene(device);
7913 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
7914 if(SUCCEEDED(hr))
7915 {
7916 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
7917 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7918 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7919 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
7920 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7921 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
7922
7923 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, TRUE);
7924 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7925 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
7926 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7927 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7928 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
7929 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7930 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
7931
7932 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
7933 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7934 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7935 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
7936 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7937 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
7938
7939 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CCW);
7940 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7941 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7942 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
7943 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
7944 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
7945
7946 hr = IDirect3DDevice9_EndScene(device);
7947 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
7948 }
7949
7950 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7951 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
7952 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7953 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
7954 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7955 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
7956 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7957 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
7958 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7959 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
7960 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7961 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFUNC, D3DCMP_EQUAL);
7962 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7963
7964 /* 2nd pass: Make the stencil values visible */
7965 hr = IDirect3DDevice9_BeginScene(device);
7966 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %s\n", DXGetErrorString9(hr));
7967 if(SUCCEEDED(hr))
7968 {
7969 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
7970 for(i = 0; i < 16; i++) {
7971 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, i);
7972 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7973
7974 painter[0].diffuse = (i * 16); /* Creates shades of blue */
7975 painter[1].diffuse = (i * 16);
7976 painter[2].diffuse = (i * 16);
7977 painter[3].diffuse = (i * 16);
7978 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, painter, sizeof(painter[0]));
7979 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
7980 }
7981 hr = IDirect3DDevice9_EndScene(device);
7982 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %s\n", DXGetErrorString9(hr));
7983 }
7984
7985 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7986 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
7987
7988 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
7989 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
7990
7991 color = getPixelColor(device, 160, 420);
7992 ok(color == 0x00000030, "CCW triangle, twoside FALSE, cull cw, replace, has color 0x%08x, expected 0x00000030\n", color);
7993 color = getPixelColor(device, 160, 300);
7994 ok(color == 0x00000080, "CW triangle, twoside FALSE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
7995
7996 color = getPixelColor(device, 480, 420);
7997 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull off, incr, has color 0x%08x, expected 0x00000090\n", color);
7998 color = getPixelColor(device, 480, 300);
7999 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull off, replace, has color 0x%08x, expected 0x00000030\n", color);
8000
8001 color = getPixelColor(device, 160, 180);
8002 ok(color == 0x00000080, "CCW triangle, twoside TRUE, cull ccw, culled, has color 0x%08x, expected 0x00000080\n", color);
8003 color = getPixelColor(device, 160, 60);
8004 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull ccw, replace, has color 0x%08x, expected 0x00000030\n", color);
8005
8006 color = getPixelColor(device, 480, 180);
8007 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull cw, incr, has color 0x%08x, expected 0x00000090\n", color);
8008 color = getPixelColor(device, 480, 60);
8009 ok(color == 0x00000080, "CW triangle, twoside TRUE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8010 }
8011
8012 static void vpos_register_test(IDirect3DDevice9 *device)
8013 {
8014 HRESULT hr;
8015 DWORD color;
8016 const DWORD shader_code[] = {
8017 0xffff0300, /* ps_3_0 */
8018 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8019 0x03000002, 0x80030000, 0x90541000, 0xa1fe0000, /* sub r0.xy, vPos.xy, c0.zw */
8020 0x02000001, 0x800f0001, 0xa0e40000, /* mov r1, c0 */
8021 0x02000001, 0x80080002, 0xa0550000, /* mov r2.a, c0.y */
8022 0x02000001, 0x80010002, 0xa0550000, /* mov r2.r, c0.y */
8023 0x04000058, 0x80020002, 0x80000000, 0x80000001, 0x80550001, /* cmp r2.g, r0.x, r1.x, r1.y */
8024 0x04000058, 0x80040002, 0x80550000, 0x80000001, 0x80550001, /* cmp r2.b, r0.y, r1.x, r1.y */
8025 0x02000001, 0x800f0800, 0x80e40002, /* mov oC0, r2 */
8026 0x0000ffff /* end */
8027 };
8028 const DWORD shader_frac_code[] = {
8029 0xffff0300, /* ps_3_0 */
8030 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
8031 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8032 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
8033 0x02000013, 0x80030000, 0x90541000, /* frc r0.xy, vPos.xy */
8034 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
8035 0x0000ffff /* end */
8036 };
8037 IDirect3DPixelShader9 *shader, *shader_frac;
8038 IDirect3DSurface9 *surface = NULL, *backbuffer;
8039 const float quad[] = {
8040 -1.0, -1.0, 0.1, 0.0, 0.0,
8041 1.0, -1.0, 0.1, 1.0, 0.0,
8042 -1.0, 1.0, 0.1, 0.0, 1.0,
8043 1.0, 1.0, 0.1, 1.0, 1.0,
8044 };
8045 D3DLOCKED_RECT lr;
8046 float constant[4] = {1.0, 0.0, 320, 240};
8047 DWORD *pos;
8048
8049 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8050 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8051 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
8052 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
8053 hr = IDirect3DDevice9_CreatePixelShader(device, shader_frac_code, &shader_frac);
8054 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%s\n", DXGetErrorString9(hr));
8055 hr = IDirect3DDevice9_SetPixelShader(device, shader);
8056 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8057 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8058 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
8059 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8060 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%s\n", DXGetErrorString9(hr));
8061
8062 hr = IDirect3DDevice9_BeginScene(device);
8063 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8064 if(SUCCEEDED(hr)) {
8065 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8066 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%s\n", DXGetErrorString9(hr));
8067 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8068 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8069 hr = IDirect3DDevice9_EndScene(device);
8070 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8071 }
8072
8073 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8074 /* This has to be pixel exact */
8075 color = getPixelColor(device, 319, 239);
8076 ok(color == 0x00000000, "vPos: Pixel 319,239 has color 0x%08x, expected 0x00000000\n", color);
8077 color = getPixelColor(device, 320, 239);
8078 ok(color == 0x0000ff00, "vPos: Pixel 320,239 has color 0x%08x, expected 0x0000ff00\n", color);
8079 color = getPixelColor(device, 319, 240);
8080 ok(color == 0x000000ff, "vPos: Pixel 319,240 has color 0x%08x, expected 0x000000ff\n", color);
8081 color = getPixelColor(device, 320, 240);
8082 ok(color == 0x0000ffff, "vPos: Pixel 320,240 has color 0x%08x, expected 0x0000ffff\n", color);
8083
8084 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_X8R8G8B8, 0, 0, TRUE,
8085 &surface, NULL);
8086 ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget failed hr=%s\n", DXGetErrorString9(hr));
8087 hr = IDirect3DDevice9_BeginScene(device);
8088 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8089 if(SUCCEEDED(hr)) {
8090 constant[2] = 16; constant[3] = 16;
8091 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8092 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%s\n", DXGetErrorString9(hr));
8093 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
8094 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8095 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8096 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8097 hr = IDirect3DDevice9_EndScene(device);
8098 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8099 }
8100 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8101 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%s\n", DXGetErrorString9(hr));
8102
8103 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8104 color = *pos & 0x00ffffff;
8105 ok(color == 0x00000000, "Pixel 14/14 has color 0x%08x, expected 0x00000000\n", color);
8106 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 18 * sizeof(DWORD));
8107 color = *pos & 0x00ffffff;
8108 ok(color == 0x0000ff00, "Pixel 14/18 has color 0x%08x, expected 0x0000ff00\n", color);
8109 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 14 * sizeof(DWORD));
8110 color = *pos & 0x00ffffff;
8111 ok(color == 0x000000ff, "Pixel 18/14 has color 0x%08x, expected 0x000000ff\n", color);
8112 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 18 * sizeof(DWORD));
8113 color = *pos & 0x00ffffff;
8114 ok(color == 0x0000ffff, "Pixel 18/18 has color 0x%08x, expected 0x0000ffff\n", color);
8115
8116 hr = IDirect3DSurface9_UnlockRect(surface);
8117 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%s\n", DXGetErrorString9(hr));
8118
8119 /* Test the fraction value of vPos. This is tested with the offscreen target and not the backbuffer to
8120 * have full control over the multisampling setting inside this test
8121 */
8122 hr = IDirect3DDevice9_SetPixelShader(device, shader_frac);
8123 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8124 hr = IDirect3DDevice9_BeginScene(device);
8125 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8126 if(SUCCEEDED(hr)) {
8127 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8128 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8129 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8130 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8131 hr = IDirect3DDevice9_EndScene(device);
8132 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8133 }
8134 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8135 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8136
8137 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8138 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%s\n", DXGetErrorString9(hr));
8139
8140 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8141 color = *pos & 0x00ffffff;
8142 ok(color == 0x00000000, "vPos fraction test has color 0x%08x, expected 0x00000000\n", color);
8143
8144 hr = IDirect3DSurface9_UnlockRect(surface);
8145 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%s\n", DXGetErrorString9(hr));
8146
8147 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8148 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%s\n", DXGetErrorString9(hr));
8149 IDirect3DPixelShader9_Release(shader);
8150 IDirect3DPixelShader9_Release(shader_frac);
8151 if(surface) IDirect3DSurface9_Release(surface);
8152 IDirect3DSurface9_Release(backbuffer);
8153 }
8154
8155 static void pointsize_test(IDirect3DDevice9 *device)
8156 {
8157 HRESULT hr;
8158 D3DCAPS9 caps;
8159 D3DMATRIX matrix;
8160 D3DMATRIX identity;
8161 float ptsize, ptsize_orig;
8162 DWORD color;
8163
8164 const float vertices[] = {
8165 64, 64, 0.1,
8166 128, 64, 0.1,
8167 192, 64, 0.1,
8168 256, 64, 0.1,
8169 320, 64, 0.1,
8170 384, 64, 0.1
8171 };
8172
8173 /* 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 */
8174 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;
8175 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;
8176 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;
8177 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;
8178
8179 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;
8180 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;
8181 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;
8182 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;
8183
8184 memset(&caps, 0, sizeof(caps));
8185 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8186 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%s\n", DXGetErrorString9(hr));
8187 if(caps.MaxPointSize < 32.0) {
8188 skip("MaxPointSize < 32.0, skipping(MaxPointsize = %f)\n", caps.MaxPointSize);
8189 return;
8190 }
8191
8192 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 0.0, 0);
8193 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8194 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &matrix);
8195 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%s\n", DXGetErrorString9(hr));
8196 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8197 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%s\n", DXGetErrorString9(hr));
8198 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE, (DWORD *) &ptsize_orig);
8199 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed hr=%s\n", DXGetErrorString9(hr));
8200
8201 hr = IDirect3DDevice9_BeginScene(device);
8202 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%s\n", DXGetErrorString9(hr));
8203 if(SUCCEEDED(hr)) {
8204 ptsize = 16.0;
8205 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8206 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8207 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[0], sizeof(float) * 3);
8208 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8209
8210 ptsize = 32.0;
8211 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8212 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8213 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[3], sizeof(float) * 3);
8214 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8215
8216 ptsize = 31.5;
8217 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8218 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8219 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[6], sizeof(float) * 3);
8220 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8221
8222 if(caps.MaxPointSize >= 64.0) {
8223 ptsize = 64.0;
8224 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8225 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8226 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[9], sizeof(float) * 3);
8227 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8228
8229 ptsize = 63.75;
8230 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8231 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8232 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[15], sizeof(float) * 3);
8233 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8234 }
8235
8236 ptsize = 1.0;
8237 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8238 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%s\n", DXGetErrorString9(hr));
8239 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[12], sizeof(float) * 3);
8240 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8241
8242 hr = IDirect3DDevice9_EndScene(device);
8243 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%s\n", DXGetErrorString9(hr));
8244 }
8245 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8246 color = getPixelColor(device, 64-9, 64-9);
8247 ok(color == 0x000000ff, "pSize: Pixel (64-9),(64-9) has color 0x%08x, expected 0x000000ff\n", color);
8248 color = getPixelColor(device, 64-8, 64-8);
8249 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (64-8),(64-8) has color 0x%08x, expected 0x00ffffff\n", color);
8250 color = getPixelColor(device, 64-7, 64-7);
8251 ok(color == 0x00ffffff, "pSize: Pixel (64-7),(64-7) has color 0x%08x, expected 0x00ffffff\n", color);
8252 color = getPixelColor(device, 64+7, 64+7);
8253 ok(color == 0x00ffffff, "pSize: Pixel (64+7),(64+7) has color 0x%08x, expected 0x00ffffff\n", color);
8254 color = getPixelColor(device, 64+8, 64+8);
8255 ok(color == 0x000000ff, "pSize: Pixel (64+8),(64+8) has color 0x%08x, expected 0x000000ff\n", color);
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
8259 color = getPixelColor(device, 128-17, 64-17);
8260 ok(color == 0x000000ff, "pSize: Pixel (128-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8261 color = getPixelColor(device, 128-16, 64-16);
8262 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (128-16),(64-16) has color 0x%08x, expected 0x00ffffff\n", color);
8263 color = getPixelColor(device, 128-15, 64-15);
8264 ok(color == 0x00ffffff, "pSize: Pixel (128-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8265 color = getPixelColor(device, 128+15, 64+15);
8266 ok(color == 0x00ffffff, "pSize: Pixel (128+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8267 color = getPixelColor(device, 128+16, 64+16);
8268 ok(color == 0x000000ff, "pSize: Pixel (128+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
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
8272 color = getPixelColor(device, 192-17, 64-17);
8273 ok(color == 0x000000ff, "pSize: Pixel (192-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8274 color = getPixelColor(device, 192-16, 64-16);
8275 ok(color == 0x000000ff, "pSize: Pixel (192-16),(64-16) has color 0x%08x, expected 0x000000ff\n", color);
8276 color = getPixelColor(device, 192-15, 64-15);
8277 ok(color == 0x00ffffff, "pSize: Pixel (192-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8278 color = getPixelColor(device, 192+15, 64+15);
8279 ok(color == 0x00ffffff, "pSize: Pixel (192+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8280 color = getPixelColor(device, 192+16, 64+16);
8281 ok(color == 0x000000ff, "pSize: Pixel (192+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
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
8285 if(caps.MaxPointSize >= 64.0) {
8286 color = getPixelColor(device, 256-33, 64-33);
8287 ok(color == 0x000000ff, "pSize: Pixel (256-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8288 color = getPixelColor(device, 256-32, 64-32);
8289 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (256-32),(64-32) has color 0x%08x, expected 0x00ffffff\n", color);
8290 color = getPixelColor(device, 256-31, 64-31);
8291 ok(color == 0x00ffffff, "pSize: Pixel (256-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8292 color = getPixelColor(device, 256+31, 64+31);
8293 ok(color == 0x00ffffff, "pSize: Pixel (256+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8294 color = getPixelColor(device, 256+32, 64+32);
8295 ok(color == 0x000000ff, "pSize: Pixel (256+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
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
8299 color = getPixelColor(device, 384-33, 64-33);
8300 ok(color == 0x000000ff, "pSize: Pixel (384-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8301 color = getPixelColor(device, 384-32, 64-32);
8302 ok(color == 0x000000ff, "pSize: Pixel (384-32),(64-32) has color 0x%08x, expected 0x000000ff\n", color);
8303 color = getPixelColor(device, 384-31, 64-31);
8304 ok(color == 0x00ffffff, "pSize: Pixel (384-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8305 color = getPixelColor(device, 384+31, 64+31);
8306 ok(color == 0x00ffffff, "pSize: Pixel (384+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8307 color = getPixelColor(device, 384+32, 64+32);
8308 ok(color == 0x000000ff, "pSize: Pixel (384+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
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 }
8312
8313 color = getPixelColor(device, 320-1, 64-1);
8314 ok(color == 0x000000ff, "pSize: Pixel (320-1),(64-1) has color 0x%08x, expected 0x000000ff\n", color);
8315 color = getPixelColor(device, 320-0, 64-0);
8316 ok(color == 0x00ffffff, "pSize: Pixel (320-0),(64-0) has color 0x%08x, expected 0x00ffffff\n", color);
8317 color = getPixelColor(device, 320+1, 64+1);
8318 ok(color == 0x000000ff, "pSize: Pixel (320+1),(64+1) has color 0x%08x, expected 0x000000ff\n", color);
8319
8320 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize_orig)));
8321 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed hr=%s\n", DXGetErrorString9(hr));
8322 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &identity);
8323 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%s\n", DXGetErrorString9(hr));
8324 }
8325
8326 static void multiple_rendertargets_test(IDirect3DDevice9 *device)
8327 {
8328 HRESULT hr;
8329 IDirect3DPixelShader9 *ps;
8330 IDirect3DTexture9 *tex1, *tex2;
8331 IDirect3DSurface9 *surf1, *surf2, *backbuf;
8332 D3DCAPS9 caps;
8333 DWORD color;
8334 DWORD shader_code[] = {
8335 0xffff0300, /* ps_3_0 */
8336 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0, 1, 0, 0 */
8337 0x05000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x00000000, /* def c1, 0, 0, 1, 0 */
8338 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
8339 0x02000001, 0x800f0801, 0xa0e40001, /* mov oC1, c1 */
8340 0x0000ffff /* END */
8341 };
8342 float quad[] = {
8343 -1.0, -1.0, 0.1,
8344 1.0, -1.0, 0.1,
8345 -1.0, 1.0, 0.1,
8346 1.0, 1.0, 0.1,
8347 };
8348 float texquad[] = {
8349 -1.0, -1.0, 0.1, 0.0, 0.0,
8350 0.0, -1.0, 0.1, 1.0, 0.0,
8351 -1.0, 1.0, 0.1, 0.0, 1.0,
8352 0.0, 1.0, 0.1, 1.0, 1.0,
8353
8354 0.0, -1.0, 0.1, 0.0, 0.0,
8355 1.0, -1.0, 0.1, 1.0, 0.0,
8356 0.0, 1.0, 0.1, 0.0, 1.0,
8357 1.0, 1.0, 0.1, 1.0, 1.0,
8358 };
8359
8360 memset(&caps, 0, sizeof(caps));
8361 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8362 ok(hr == D3D_OK, "IDirect3DDevice9_GetCaps failed, hr=%s\n", DXGetErrorString9(hr));
8363 if(caps.NumSimultaneousRTs < 2) {
8364 skip("Only 1 simultaneous render target supported, skipping MRT test\n");
8365 return;
8366 }
8367
8368 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 0.0, 0);
8369 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%s\n", DXGetErrorString9(hr));
8370
8371 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex1, NULL);
8372 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%s\n", DXGetErrorString9(hr));
8373 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex2, NULL);
8374 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%s\n", DXGetErrorString9(hr));
8375 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &ps);
8376 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8377
8378 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &backbuf);
8379 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8380 hr = IDirect3DTexture9_GetSurfaceLevel(tex1, 0, &surf1);
8381 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%s\n", DXGetErrorString9(hr));
8382 hr = IDirect3DTexture9_GetSurfaceLevel(tex2, 0, &surf2);
8383 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%s\n", DXGetErrorString9(hr));
8384
8385 hr = IDirect3DDevice9_SetPixelShader(device, ps);
8386 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8387 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surf1);
8388 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8389 hr = IDirect3DDevice9_SetRenderTarget(device, 1, surf2);
8390 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8391 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8392 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%s\n", DXGetErrorString9(hr));
8393
8394 hr = IDirect3DDevice9_BeginScene(device);
8395 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr=%s\n", DXGetErrorString9(hr));
8396 if(SUCCEEDED(hr)) {
8397 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
8398 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8399
8400 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8401 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%s\n", DXGetErrorString9(hr));
8402 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuf);
8403 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8404 hr = IDirect3DDevice9_SetRenderTarget(device, 1, NULL);
8405 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%s\n", DXGetErrorString9(hr));
8406 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8407 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%s\n", DXGetErrorString9(hr));
8408
8409 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
8410 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8411 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[0], 5 * sizeof(float));
8412 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8413
8414 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex2);
8415 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8416 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[20], 5 * sizeof(float));
8417 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%s\n", DXGetErrorString9(hr));
8418
8419 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
8420 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%s\n", DXGetErrorString9(hr));
8421
8422 hr = IDirect3DDevice9_EndScene(device);
8423 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%s\n", DXGetErrorString9(hr));
8424 }
8425
8426 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8427 color = getPixelColor(device, 160, 240);
8428 ok(color == 0x0000ff00, "Texture 1(output color 1) has color 0x%08x, expected 0x0000ff00\n", color);
8429 color = getPixelColor(device, 480, 240);
8430 ok(color == 0x000000ff, "Texture 2(output color 2) has color 0x%08x, expected 0x000000ff\n", color);
8431
8432 IDirect3DPixelShader9_Release(ps);
8433 IDirect3DTexture9_Release(tex1);
8434 IDirect3DTexture9_Release(tex2);
8435 IDirect3DSurface9_Release(surf1);
8436 IDirect3DSurface9_Release(surf2);
8437 IDirect3DSurface9_Release(backbuf);
8438 }
8439
8440 struct formats {
8441 const char *fmtName;
8442 D3DFORMAT textureFormat;
8443 DWORD resultColorBlending;
8444 DWORD resultColorNoBlending;
8445 };
8446
8447 const struct formats test_formats[] = {
8448 { "D3DFMT_G16R16", D3DFMT_G16R16, 0x00181800, 0x002010ff},
8449 { "D3DFMT_R16F", D3DFMT_R16F, 0x0018ffff, 0x0020ffff },
8450 { "D3DFMT_G16R16F", D3DFMT_G16R16F, 0x001818ff, 0x002010ff },
8451 { "D3DFMT_A16B16G16R16F", D3DFMT_A16B16G16R16F, 0x00181800, 0x00201000 },
8452 { "D3DFMT_R32F", D3DFMT_R32F, 0x0018ffff, 0x0020ffff },
8453 { "D3DFMT_G32R32F", D3DFMT_G32R32F, 0x001818ff, 0x002010ff },
8454 { "D3DFMT_A32B32G32R32F", D3DFMT_A32B32G32R32F, 0x00181800, 0x00201000 },
8455 { NULL, 0 }
8456 };
8457
8458 static void pixelshader_blending_test(IDirect3DDevice9 *device)
8459 {
8460 HRESULT hr;
8461 IDirect3DTexture9 *offscreenTexture = NULL;
8462 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
8463 IDirect3D9 *d3d = NULL;
8464 DWORD color;
8465 DWORD r0, g0, b0, r1, g1, b1;
8466 int fmt_index;
8467
8468 static const float quad[][5] = {
8469 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
8470 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
8471 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
8472 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
8473 };
8474
8475 /* Quad with R=0x10, G=0x20 */
8476 static const struct vertex quad1[] = {
8477 {-1.0f, -1.0f, 0.1f, 0x80102000},
8478 {-1.0f, 1.0f, 0.1f, 0x80102000},
8479 { 1.0f, -1.0f, 0.1f, 0x80102000},
8480 { 1.0f, 1.0f, 0.1f, 0x80102000},
8481 };
8482
8483 /* Quad with R=0x20, G=0x10 */
8484 static const struct vertex quad2[] = {
8485 {-1.0f, -1.0f, 0.1f, 0x80201000},
8486 {-1.0f, 1.0f, 0.1f, 0x80201000},
8487 { 1.0f, -1.0f, 0.1f, 0x80201000},
8488 { 1.0f, 1.0f, 0.1f, 0x80201000},
8489 };
8490
8491 IDirect3DDevice9_GetDirect3D(device, &d3d);
8492
8493 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8494 ok(hr == D3D_OK, "Can't get back buffer, hr = %s\n", DXGetErrorString9(hr));
8495 if(!backbuffer) {
8496 goto out;
8497 }
8498
8499 for(fmt_index=0; test_formats[fmt_index].textureFormat != 0; fmt_index++)
8500 {
8501 D3DFORMAT fmt = test_formats[fmt_index].textureFormat;
8502 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0, D3DRTYPE_TEXTURE, fmt) != D3D_OK) {
8503 skip("%s textures not supported\n", test_formats[fmt_index].fmtName);
8504 continue;
8505 }
8506
8507 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8508 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
8509
8510 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, fmt, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
8511 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %s\n", DXGetErrorString9(hr));
8512 if(!offscreenTexture) {
8513 continue;
8514 }
8515
8516 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
8517 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %s\n", DXGetErrorString9(hr));
8518 if(!offscreen) {
8519 continue;
8520 }
8521
8522 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8523 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8524
8525 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8526 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8527 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
8528 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8529 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
8530 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
8531 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
8532 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
8533 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
8534 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
8535
8536 /* Below we will draw two quads with different colors and try to blend them together.
8537 * The result color is compared with the expected outcome.
8538 */
8539 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
8540 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
8541 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
8542 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 0.0, 0);
8543 ok(hr == D3D_OK, "Clear failed, hr = %s\n", DXGetErrorString9(hr));
8544
8545 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
8546 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8547
8548 /* Draw a quad using color 0x0010200 */
8549 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_ONE);
8550 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8551 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_ZERO);
8552 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8553 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
8554 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8555
8556 /* Draw a quad using color 0x0020100 */
8557 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
8558 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8559 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
8560 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8561 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
8562 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8563
8564 /* We don't want to blend the result on the backbuffer */
8565 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
8566 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8567
8568 /* Prepare rendering the 'blended' texture quad to the backbuffer */
8569 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8570 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %s\n", DXGetErrorString9(hr));
8571 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
8572 ok(hr == D3D_OK, "SetTexture failed, %s\n", DXGetErrorString9(hr));
8573
8574 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8575 ok(hr == D3D_OK, "SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8576
8577 /* This time with the texture */
8578 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8579 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %s\n", DXGetErrorString9(hr));
8580
8581 IDirect3DDevice9_EndScene(device);
8582 }
8583 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8584
8585
8586 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, fmt) == D3D_OK) {
8587 /* Compare the color of the center quad with our expectation */
8588 color = getPixelColor(device, 320, 240);
8589 r0 = (color & 0x00ff0000) >> 16;
8590 g0 = (color & 0x0000ff00) >> 8;
8591 b0 = (color & 0x000000ff) >> 0;
8592
8593 r1 = (test_formats[fmt_index].resultColorBlending & 0x00ff0000) >> 16;
8594 g1 = (test_formats[fmt_index].resultColorBlending & 0x0000ff00) >> 8;
8595 b1 = (test_formats[fmt_index].resultColorBlending & 0x000000ff) >> 0;
8596
8597 ok(r0 >= max(r1, 1) - 1 && r0 <= r1 + 1 &&
8598 g0 >= max(g1, 1) - 1 && g0 <= g1 + 1 &&
8599 b0 >= max(b1, 1) - 1 && b0 <= b1 + 1,
8600 "Offscreen failed for %s: Got color %#08x, expected %#08x.\n", test_formats[fmt_index].fmtName, color, test_formats[fmt_index].resultColorBlending);
8601 } else {
8602 /* No pixel shader blending is supported so expected garbage.The type of 'garbage' depends on the driver version and OS.
8603 * E.g. on G16R16 ati reports (on old r9600 drivers) 0x00ffffff and on modern ones 0x002010ff which is also what Nvidia
8604 * reports. On Vista Nvidia seems to report 0x00ffffff on Geforce7 cards. */
8605 color = getPixelColor(device, 320, 240);
8606 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);
8607 }
8608
8609 IDirect3DDevice9_SetTexture(device, 0, NULL);
8610 if(offscreenTexture) {
8611 IDirect3DTexture9_Release(offscreenTexture);
8612 }
8613 if(offscreen) {
8614 IDirect3DSurface9_Release(offscreen);
8615 }
8616 }
8617
8618 out:
8619 /* restore things */
8620 if(backbuffer) {
8621 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8622 IDirect3DSurface9_Release(backbuffer);
8623 }
8624 }
8625
8626 static void tssargtemp_test(IDirect3DDevice9 *device)
8627 {
8628 HRESULT hr;
8629 DWORD color;
8630 static const struct vertex quad[] = {
8631 {-1.0, -1.0, 0.1, 0x00ff0000},
8632 { 1.0, -1.0, 0.1, 0x00ff0000},
8633 {-1.0, 1.0, 0.1, 0x00ff0000},
8634 { 1.0, 1.0, 0.1, 0x00ff0000}
8635 };
8636 D3DCAPS9 caps;
8637
8638 memset(&caps, 0, sizeof(caps));
8639 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8640 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed with %s\n", DXGetErrorString9(hr));
8641 if(!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_TSSARGTEMP)) {
8642 skip("D3DPMISCCAPS_TSSARGTEMP not supported\n");
8643 return;
8644 }
8645
8646 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
8647 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
8648
8649 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8650 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8651 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
8652 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8653
8654 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8655 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8656 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TFACTOR);
8657 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8658 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_TEMP);
8659 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8660
8661 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_ADD);
8662 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8663 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG1, D3DTA_CURRENT);
8664 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8665 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG2, D3DTA_TEMP);
8666 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8667
8668 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8669 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8670
8671 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x0000ff00);
8672 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %s\n", DXGetErrorString9(hr));
8673 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8674 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %s\n", DXGetErrorString9(hr));
8675
8676 hr = IDirect3DDevice9_BeginScene(device);
8677 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr = %s\n", DXGetErrorString9(hr));
8678 if(SUCCEEDED(hr)) {
8679
8680 hr = IDirect3DDevice9_EndScene(device);
8681 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %s\n", DXGetErrorString9(hr));
8682 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8683 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
8684 }
8685 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8686 color = getPixelColor(device, 320, 240);
8687 ok(color == 0x00FFFF00, "TSSARGTEMP test returned color 0x%08x, expected 0x00FFFF00\n", color);
8688
8689 /* Set stage 1 back to default */
8690 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_CURRENT);
8691 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8692 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
8693 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8694 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
8695 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8696 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
8697 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8698 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8699 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %s\n", DXGetErrorString9(hr));
8700 }
8701
8702 struct testdata
8703 {
8704 DWORD idxVertex; /* number of instances in the first stream */
8705 DWORD idxColor; /* number of instances in the second stream */
8706 DWORD idxInstance; /* should be 1 ?? */
8707 DWORD color1; /* color 1 instance */
8708 DWORD color2; /* color 2 instance */
8709 DWORD color3; /* color 3 instance */
8710 DWORD color4; /* color 4 instance */
8711 WORD strVertex; /* specify which stream to use 0-2*/
8712 WORD strColor;
8713 WORD strInstance;
8714 };
8715
8716 static const struct testdata testcases[]=
8717 {
8718 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 0 */
8719 {3, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 1 */
8720 {2, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 2 */
8721 {1, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 3 */
8722 {0, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 4 */
8723 {4, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 5 */
8724 {4, 2, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 6 */
8725 {4, 1, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 7 */
8726 {4, 0, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 8 */
8727 {3, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 9 */
8728 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 0, 2}, /* 10 */
8729 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 2, 1}, /* 11 */
8730 {4, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 3, 1}, /* 12 */
8731 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 2, 0, 1}, /* 13 */
8732 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 2, 3}, /* 14 */
8733 /*
8734 This case is handled in a stand alone test, SetStreamSourceFreq(0,(D3DSTREAMSOURCE_INSTANCEDATA | 1)) has to return D3DERR_INVALIDCALL!
8735 {4, 4, 1, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 1, 0, D3DERR_INVALIDCALL},
8736 */
8737 };
8738
8739 /* Drawing Indexed Geometry with instances*/
8740 static void stream_test(IDirect3DDevice9 *device)
8741 {
8742 IDirect3DVertexBuffer9 *vb = NULL;
8743 IDirect3DVertexBuffer9 *vb2 = NULL;
8744 IDirect3DVertexBuffer9 *vb3 = NULL;
8745 IDirect3DIndexBuffer9 *ib = NULL;
8746 IDirect3DVertexDeclaration9 *pDecl = NULL;
8747 IDirect3DVertexShader9 *shader = NULL;
8748 HRESULT hr;
8749 BYTE *data;
8750 DWORD color;
8751 DWORD ind;
8752 int i;
8753
8754 const DWORD shader_code[] =
8755 {
8756 0xfffe0101, /* vs_1_1 */
8757 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
8758 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
8759 0x0000001f, 0x80000005, 0x900f0002, /* dcl_texcoord v2 */
8760 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
8761 0x00000002, 0xc00f0000, 0x80e40000, 0x90e40002, /* add oPos, r0, v2 */
8762 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
8763 0x0000ffff
8764 };
8765
8766 const float quad[][3] =
8767 {
8768 {-0.5f, -0.5f, 1.1f}, /*0 */
8769 {-0.5f, 0.5f, 1.1f}, /*1 */
8770 { 0.5f, -0.5f, 1.1f}, /*2 */
8771 { 0.5f, 0.5f, 1.1f}, /*3 */
8772 };
8773
8774 const float vertcolor[][4] =
8775 {
8776 {1.0f, 0.0f, 0.0f, 1.0f}, /*0 */
8777 {1.0f, 0.0f, 0.0f, 1.0f}, /*1 */
8778 {1.0f, 0.0f, 0.0f, 1.0f}, /*2 */
8779 {1.0f, 0.0f, 0.0f, 1.0f}, /*3 */
8780 };
8781
8782 /* 4 position for 4 instances */
8783 const float instancepos[][3] =
8784 {
8785 {-0.6f,-0.6f, 0.0f},
8786 { 0.6f,-0.6f, 0.0f},
8787 { 0.6f, 0.6f, 0.0f},
8788 {-0.6f, 0.6f, 0.0f},
8789 };
8790
8791 short indices[] = {0, 1, 2, 1, 2, 3};
8792
8793 D3DVERTEXELEMENT9 decl[] =
8794 {
8795 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
8796 {1, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
8797 {2, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
8798 D3DDECL_END()
8799 };
8800
8801 /* set the default value because it isn't done in wine? */
8802 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
8803 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8804
8805 /* check for D3DSTREAMSOURCE_INDEXEDDATA at stream0 */
8806 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 0, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
8807 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8808
8809 /* check wrong cases */
8810 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 0);
8811 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8812 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8813 ok(hr == D3D_OK && ind == 1, "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8814 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 2);
8815 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8816 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8817 ok(hr == D3D_OK && ind == 2, "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8818 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INDEXEDDATA | 0));
8819 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8820 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8821 ok(hr == D3D_OK && ind == (D3DSTREAMSOURCE_INDEXEDDATA | 0), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8822 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | 0));
8823 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8824 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8825 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8826 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA | 0));
8827 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8828 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
8829 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8830
8831 /* set the default value back */
8832 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
8833 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s\n", DXGetErrorString9(hr));
8834
8835 /* create all VertexBuffers*/
8836 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0, D3DPOOL_MANAGED, &vb, NULL);
8837 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8838 if(!vb) {
8839 skip("Failed to create a vertex buffer\n");
8840 return;
8841 }
8842 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(vertcolor), 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
8843 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8844 if(!vb2) {
8845 skip("Failed to create a vertex buffer\n");
8846 goto out;
8847 }
8848 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(instancepos), 0, 0, D3DPOOL_MANAGED, &vb3, NULL);
8849 ok(hr == D3D_OK, "CreateVertexBuffer failed with %s\n", DXGetErrorString9(hr));
8850 if(!vb3) {
8851 skip("Failed to create a vertex buffer\n");
8852 goto out;
8853 }
8854
8855 /* create IndexBuffer*/
8856 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
8857 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %s\n", DXGetErrorString9(hr));
8858 if(!ib) {
8859 skip("Failed to create a index buffer\n");
8860 goto out;
8861 }
8862
8863 /* copy all Buffers (Vertex + Index)*/
8864 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
8865 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8866 memcpy(data, quad, sizeof(quad));
8867 hr = IDirect3DVertexBuffer9_Unlock(vb);
8868 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8869 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(vertcolor), (void **) &data, 0);
8870 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8871 memcpy(data, vertcolor, sizeof(vertcolor));
8872 hr = IDirect3DVertexBuffer9_Unlock(vb2);
8873 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8874 hr = IDirect3DVertexBuffer9_Lock(vb3, 0, sizeof(instancepos), (void **) &data, 0);
8875 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8876 memcpy(data, instancepos, sizeof(instancepos));
8877 hr = IDirect3DVertexBuffer9_Unlock(vb3);
8878 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8879 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
8880 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %s\n", DXGetErrorString9(hr));
8881 memcpy(data, indices, sizeof(indices));
8882 hr = IDirect3DIndexBuffer9_Unlock(ib);
8883 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8884
8885 /* create VertexShader */
8886 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
8887 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%s\n", DXGetErrorString9(hr));
8888 if(!shader) {
8889 skip("Failed to create a vetex shader\n");
8890 goto out;
8891 }
8892
8893 hr = IDirect3DDevice9_SetVertexShader(device, shader);
8894 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%s\n", DXGetErrorString9(hr));
8895
8896 hr = IDirect3DDevice9_SetIndices(device, ib);
8897 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s\n", DXGetErrorString9(hr));
8898
8899 /* run all tests */
8900 for( i = 0; i < sizeof(testcases)/sizeof(testcases[0]); ++i)
8901 {
8902 struct testdata act = testcases[i];
8903 decl[0].Stream = act.strVertex;
8904 decl[1].Stream = act.strColor;
8905 decl[2].Stream = act.strInstance;
8906 /* create VertexDeclarations */
8907 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl, &pDecl);
8908 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%s (case %i)\n", DXGetErrorString9(hr), i);
8909
8910 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8911 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x (case %i)\n", hr, i);
8912
8913 hr = IDirect3DDevice9_BeginScene(device);
8914 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x (case %i)\n", hr, i);
8915 if(SUCCEEDED(hr))
8916 {
8917 hr = IDirect3DDevice9_SetVertexDeclaration(device, pDecl);
8918 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x (case %i)\n", hr, i);
8919
8920 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxVertex));
8921 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8922 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, vb, 0, sizeof(quad[0]));
8923 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8924
8925 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strColor, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxColor));
8926 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8927 hr = IDirect3DDevice9_SetStreamSource(device, act.strColor, vb2, 0, sizeof(vertcolor[0]));
8928 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8929
8930 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strInstance, (D3DSTREAMSOURCE_INSTANCEDATA | act.idxInstance));
8931 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8932 hr = IDirect3DDevice9_SetStreamSource(device, act.strInstance, vb3, 0, sizeof(instancepos[0]));
8933 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8934
8935 /* don't know if this is right (1*3 and 4*1)*/
8936 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 0, 1 * 3 , 0, 4*1);
8937 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x (case %i)\n", hr, i);
8938 hr = IDirect3DDevice9_EndScene(device);
8939 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x (case %i)\n", hr, i);
8940
8941 /* set all StreamSource && StreamSourceFreq back to default */
8942 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, 1);
8943 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8944 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, NULL, 0, 0);
8945 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8946 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxColor, 1);
8947 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8948 hr = IDirect3DDevice9_SetStreamSource(device, act.idxColor, NULL, 0, 0);
8949 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8950 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxInstance, 1);
8951 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %s (case %i)\n", DXGetErrorString9(hr), i);
8952 hr = IDirect3DDevice9_SetStreamSource(device, act.idxInstance, NULL, 0, 0);
8953 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
8954 }
8955
8956 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8957 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x (case %i)\n", hr, i);
8958
8959 hr = IDirect3DVertexDeclaration9_Release(pDecl);
8960 ok(hr == D3D_OK, "IDirect3DVertexDeclaration9_Release failed with %08x (case %i)\n", hr, i);
8961
8962 color = getPixelColor(device, 160, 360);
8963 ok(color == act.color1, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color1, i);
8964 color = getPixelColor(device, 480, 360);
8965 ok(color == act.color2, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color2, i);
8966 color = getPixelColor(device, 480, 120);
8967 ok(color == act.color3, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color3, i);
8968 color = getPixelColor(device, 160, 120);
8969 ok(color == act.color4, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color4, i);
8970 }
8971
8972 hr = IDirect3DDevice9_SetIndices(device, NULL);
8973 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
8974
8975 out:
8976 if(vb) IDirect3DVertexBuffer9_Release(vb);
8977 if(vb2)IDirect3DVertexBuffer9_Release(vb2);
8978 if(vb3)IDirect3DVertexBuffer9_Release(vb3);
8979 if(ib)IDirect3DIndexBuffer9_Release(ib);
8980 if(shader)IDirect3DVertexShader9_Release(shader);
8981 }
8982
8983 static void np2_stretch_rect_test(IDirect3DDevice9 *device) {
8984 IDirect3DSurface9 *src = NULL, *dst = NULL, *backbuffer = NULL;
8985 IDirect3DTexture9 *dsttex = NULL;
8986 HRESULT hr;
8987 DWORD color;
8988 D3DRECT r1 = {0, 0, 50, 50 };
8989 D3DRECT r2 = {50, 0, 100, 50 };
8990 D3DRECT r3 = {50, 50, 100, 100};
8991 D3DRECT r4 = {0, 50, 50, 100};
8992 const float quad[] = {
8993 -1.0, -1.0, 0.1, 0.0, 0.0,
8994 1.0, -1.0, 0.1, 1.0, 0.0,
8995 -1.0, 1.0, 0.1, 0.0, 1.0,
8996 1.0, 1.0, 0.1, 1.0, 1.0,
8997 };
8998
8999 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
9000 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %s\n", DXGetErrorString9(hr));
9001
9002 hr = IDirect3DDevice9_CreateRenderTarget(device, 100, 100, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &src, NULL );
9003 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateRenderTarget failed with %s\n", DXGetErrorString9(hr));
9004 hr = IDirect3DDevice9_CreateTexture(device, 25, 25, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &dsttex, NULL);
9005 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture failed with %s\n", DXGetErrorString9(hr));
9006
9007 if(!src || !dsttex) {
9008 skip("One or more test resources could not be created\n");
9009 goto cleanup;
9010 }
9011
9012 hr = IDirect3DTexture9_GetSurfaceLevel(dsttex, 0, &dst);
9013 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %s\n", DXGetErrorString9(hr));
9014
9015 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
9016 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9017
9018 /* Clear the StretchRect destination for debugging */
9019 hr = IDirect3DDevice9_SetRenderTarget(device, 0, dst);
9020 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9021 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
9022 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9023
9024 hr = IDirect3DDevice9_SetRenderTarget(device, 0, src);
9025 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9026
9027 hr = IDirect3DDevice9_Clear(device, 1, &r1, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9028 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9029 hr = IDirect3DDevice9_Clear(device, 1, &r2, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
9030 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9031 hr = IDirect3DDevice9_Clear(device, 1, &r3, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
9032 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9033 hr = IDirect3DDevice9_Clear(device, 1, &r4, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
9034 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
9035
9036 /* Stretchrect before setting the render target back to the backbuffer. This will make Wine use
9037 * the target -> texture GL blit path
9038 */
9039 hr = IDirect3DDevice9_StretchRect(device, src, NULL, dst, NULL, D3DTEXF_POINT);
9040 ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %s\n", DXGetErrorString9(hr));
9041 IDirect3DSurface9_Release(dst);
9042
9043 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
9044 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %s\n", DXGetErrorString9(hr));
9045
9046 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) dsttex);
9047 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9048 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
9049 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
9050 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9051 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9052 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9053 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9054
9055 hr = IDirect3DDevice9_BeginScene(device);
9056 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
9057 if(SUCCEEDED(hr)) {
9058 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
9059 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
9060 hr = IDirect3DDevice9_EndScene(device);
9061 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
9062 }
9063
9064 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9065 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %s\n", DXGetErrorString9(hr));
9066 color = getPixelColor(device, 160, 360);
9067 ok(color == 0x00ff0000, "stretchrect: Pixel 160,360 has color 0x%08x, expected 0x00ff0000\n", color);
9068 color = getPixelColor(device, 480, 360);
9069 ok(color == 0x0000ff00, "stretchrect: Pixel 480,360 has color 0x%08x, expected 0x0000ff00\n", color);
9070 color = getPixelColor(device, 480, 120);
9071 ok(color == 0x000000ff, "stretchrect: Pixel 480,120 has color 0x%08x, expected 0x000000ff\n", color);
9072 color = getPixelColor(device, 160, 120);
9073 ok(color == 0x00000000, "stretchrect: Pixel 160,120 has color 0x%08x, expected 0x00000000\n", color);
9074
9075 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
9076 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9077 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9078 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %s\n", DXGetErrorString9(hr));
9079
9080 cleanup:
9081 if(src) IDirect3DSurface9_Release(src);
9082 if(backbuffer) IDirect3DSurface9_Release(backbuffer);
9083 if(dsttex) IDirect3DTexture9_Release(dsttex);
9084 }
9085
9086 START_TEST(visual)
9087 {
9088 IDirect3DDevice9 *device_ptr;
9089 D3DCAPS9 caps;
9090 HRESULT hr;
9091 DWORD color;
9092
9093 d3d9_handle = LoadLibraryA("d3d9.dll");
9094 if (!d3d9_handle)
9095 {
9096 skip("Could not load d3d9.dll\n");
9097 return;
9098 }
9099
9100 device_ptr = init_d3d9();
9101 if (!device_ptr)
9102 {
9103 skip("Creating the device failed\n");
9104 return;
9105 }
9106
9107 IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps);
9108
9109 /* Check for the reliability of the returned data */
9110 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9111 if(FAILED(hr))
9112 {
9113 trace("Clear failed, can't assure correctness of the test results, skipping\n");
9114 goto cleanup;
9115 }
9116 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9117
9118 color = getPixelColor(device_ptr, 1, 1);
9119 if(color !=0x00ff0000)
9120 {
9121 trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9122 goto cleanup;
9123 }
9124
9125 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
9126 if(FAILED(hr))
9127 {
9128 trace("Clear failed, can't assure correctness of the test results, skipping\n");
9129 goto cleanup;
9130 }
9131 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9132
9133 color = getPixelColor(device_ptr, 639, 479);
9134 if(color != 0x0000ddee)
9135 {
9136 trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9137 goto cleanup;
9138 }
9139
9140 /* Now execute the real tests */
9141 stretchrect_test(device_ptr);
9142 lighting_test(device_ptr);
9143 clear_test(device_ptr);
9144 fog_test(device_ptr);
9145 if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
9146 {
9147 test_cube_wrap(device_ptr);
9148 } else {
9149 skip("No cube texture support\n");
9150 }
9151 z_range_test(device_ptr);
9152 if(caps.TextureCaps & D3DPTEXTURECAPS_MIPMAP)
9153 {
9154 maxmip_test(device_ptr);
9155 }
9156 else
9157 {
9158 skip("No mipmap support\n");
9159 }
9160 offscreen_test(device_ptr);
9161 alpha_test(device_ptr);
9162 shademode_test(device_ptr);
9163 srgbtexture_test(device_ptr);
9164 release_buffer_test(device_ptr);
9165 float_texture_test(device_ptr);
9166 g16r16_texture_test(device_ptr);
9167 pixelshader_blending_test(device_ptr);
9168 texture_transform_flags_test(device_ptr);
9169 autogen_mipmap_test(device_ptr);
9170 fixed_function_decl_test(device_ptr);
9171 conditional_np2_repeat_test(device_ptr);
9172 fixed_function_bumpmap_test(device_ptr);
9173 if(caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) {
9174 stencil_cull_test(device_ptr);
9175 } else {
9176 skip("No two sided stencil support\n");
9177 }
9178 pointsize_test(device_ptr);
9179 tssargtemp_test(device_ptr);
9180 np2_stretch_rect_test(device_ptr);
9181
9182 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
9183 {
9184 test_constant_clamp_vs(device_ptr);
9185 test_compare_instructions(device_ptr);
9186 }
9187 else skip("No vs_1_1 support\n");
9188
9189 if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
9190 {
9191 test_mova(device_ptr);
9192 if (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9193 test_vshader_input(device_ptr);
9194 test_vshader_float16(device_ptr);
9195 stream_test(device_ptr);
9196 } else {
9197 skip("No vs_3_0 support\n");
9198 }
9199 }
9200 else skip("No vs_2_0 support\n");
9201
9202 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1) && caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9203 {
9204 fog_with_shader_test(device_ptr);
9205 fog_srgbwrite_test(device_ptr);
9206 }
9207 else skip("No vs_1_1 and ps_1_1 support\n");
9208
9209 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9210 {
9211 texbem_test(device_ptr);
9212 texdepth_test(device_ptr);
9213 texkill_test(device_ptr);
9214 x8l8v8u8_test(device_ptr);
9215 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 4)) {
9216 constant_clamp_ps_test(device_ptr);
9217 cnd_test(device_ptr);
9218 if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) {
9219 dp2add_ps_test(device_ptr);
9220 if (caps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) {
9221 nested_loop_test(device_ptr);
9222 fixed_function_varying_test(device_ptr);
9223 vFace_register_test(device_ptr);
9224 vpos_register_test(device_ptr);
9225 multiple_rendertargets_test(device_ptr);
9226 if(caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9227 vshader_version_varying_test(device_ptr);
9228 pshader_version_varying_test(device_ptr);
9229 } else {
9230 skip("No vs_3_0 support\n");
9231 }
9232 } else {
9233 skip("No ps_3_0 support\n");
9234 }
9235 } else {
9236 skip("No ps_2_0 support\n");
9237 }
9238 }
9239 }
9240 else skip("No ps_1_1 support\n");
9241
9242 cleanup:
9243 if(device_ptr) {
9244 ULONG ref;
9245
9246 D3DPRESENT_PARAMETERS present_parameters;
9247 IDirect3DSwapChain9 *swapchain;
9248 IDirect3DDevice9_GetSwapChain(device_ptr, 0, &swapchain);
9249 IDirect3DSwapChain9_GetPresentParameters(swapchain, &present_parameters);
9250 IDirect3DSwapChain9_Release(swapchain);
9251 ref = IDirect3DDevice9_Release(device_ptr);
9252 DestroyWindow(present_parameters.hDeviceWindow);
9253 ok(ref == 0, "The device was not properly freed: refcount %u\n", ref);
9254 }
9255 }
GSOC 2012 project to enhance the control panel