?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 212f1dad91f15aefd8e676124180e0b86d7c9ee6
[wine/hacks.git] / dlls / d3d9 / tests / visual.c
blob5574313768b33e75d3cb3137be819d368530b1d7
1 /*
2 * Copyright 2005, 2007-2008 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 "wine/test.h"
34
35 static HMODULE d3d9_handle = 0;
36
37 static HWND create_window(void)
38 {
39 WNDCLASS wc = {0};
40 HWND ret;
41 wc.lpfnWndProc = DefWindowProc;
42 wc.lpszClassName = "d3d9_test_wc";
43 RegisterClass(&wc);
44
45 ret = CreateWindow("d3d9_test_wc", "d3d9_test",
46 WS_MAXIMIZE | WS_VISIBLE | WS_CAPTION , 0, 0, 640, 480, 0, 0, 0, 0);
47 return ret;
48 }
49
50 static BOOL color_match(D3DCOLOR c1, D3DCOLOR c2, BYTE max_diff)
51 {
52 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
53 c1 >>= 8; c2 >>= 8;
54 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
55 c1 >>= 8; c2 >>= 8;
56 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
57 c1 >>= 8; c2 >>= 8;
58 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
59 return TRUE;
60 }
61
62 /* Locks a given surface and returns the color at (x,y). It's the caller's
63 * responsibility to only pass in lockable surfaces and valid x,y coordinates */
64 static DWORD getPixelColorFromSurface(IDirect3DSurface9 *surface, UINT x, UINT y)
65 {
66 DWORD color;
67 HRESULT hr;
68 D3DSURFACE_DESC desc;
69 RECT rectToLock = {x, y, x+1, y+1};
70 D3DLOCKED_RECT lockedRect;
71
72 hr = IDirect3DSurface9_GetDesc(surface, &desc);
73 if(FAILED(hr)) /* This is not a test */
74 {
75 trace("Can't get the surface description, hr=%08x\n", hr);
76 return 0xdeadbeef;
77 }
78
79 hr = IDirect3DSurface9_LockRect(surface, &lockedRect, &rectToLock, D3DLOCK_READONLY);
80 if(FAILED(hr)) /* This is not a test */
81 {
82 trace("Can't lock the surface, hr=%08x\n", hr);
83 return 0xdeadbeef;
84 }
85 switch(desc.Format) {
86 case D3DFMT_A8R8G8B8:
87 {
88 color = ((DWORD *) lockedRect.pBits)[0] & 0xffffffff;
89 break;
90 }
91 default:
92 trace("Error: unknown surface format: %d\n", desc.Format);
93 color = 0xdeadbeef;
94 break;
95 }
96 hr = IDirect3DSurface9_UnlockRect(surface);
97 if(FAILED(hr))
98 {
99 trace("Can't unlock the surface, hr=%08x\n", hr);
100 }
101 return color;
102 }
103
104 static DWORD getPixelColor(IDirect3DDevice9 *device, UINT x, UINT y)
105 {
106 DWORD ret;
107 IDirect3DSurface9 *surf;
108 HRESULT hr;
109 D3DLOCKED_RECT lockedRect;
110 RECT rectToLock = {x, y, x+1, y+1};
111
112 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 640, 480, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf, NULL);
113 if(FAILED(hr) || !surf ) /* This is not a test */
114 {
115 trace("Can't create an offscreen plain surface to read the render target data, hr=%08x\n", hr);
116 return 0xdeadbeef;
117 }
118
119 hr = IDirect3DDevice9_GetFrontBufferData(device, 0, surf);
120 if(FAILED(hr))
121 {
122 trace("Can't read the front buffer data, hr=%08x\n", hr);
123 ret = 0xdeadbeed;
124 goto out;
125 }
126
127 hr = IDirect3DSurface9_LockRect(surf, &lockedRect, &rectToLock, D3DLOCK_READONLY);
128 if(FAILED(hr))
129 {
130 trace("Can't lock the offscreen surface, hr=%08x\n", hr);
131 ret = 0xdeadbeec;
132 goto out;
133 }
134
135 /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
136 * really important for these tests
137 */
138 ret = ((DWORD *) lockedRect.pBits)[0] & 0x00ffffff;
139 hr = IDirect3DSurface9_UnlockRect(surf);
140 if(FAILED(hr))
141 {
142 trace("Can't unlock the offscreen surface, hr=%08x\n", hr);
143 }
144
145 out:
146 if(surf) IDirect3DSurface9_Release(surf);
147 return ret;
148 }
149
150 static IDirect3DDevice9 *init_d3d9(void)
151 {
152 IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
153 IDirect3D9 *d3d9_ptr = 0;
154 IDirect3DDevice9 *device_ptr = 0;
155 D3DPRESENT_PARAMETERS present_parameters;
156 HRESULT hr;
157 D3DADAPTER_IDENTIFIER9 identifier;
158
159 d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
160 ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
161 if (!d3d9_create) return NULL;
162
163 d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
164 if (!d3d9_ptr)
165 {
166 skip("could not create D3D9\n");
167 return NULL;
168 }
169
170 ZeroMemory(&present_parameters, sizeof(present_parameters));
171 present_parameters.Windowed = FALSE;
172 present_parameters.hDeviceWindow = create_window();
173 present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
174 present_parameters.BackBufferWidth = 640;
175 present_parameters.BackBufferHeight = 480;
176 present_parameters.BackBufferFormat = D3DFMT_A8R8G8B8;
177 present_parameters.EnableAutoDepthStencil = TRUE;
178 present_parameters.AutoDepthStencilFormat = D3DFMT_D24S8;
179
180 memset(&identifier, 0, sizeof(identifier));
181 hr = IDirect3D9_GetAdapterIdentifier(d3d9_ptr, 0, 0, &identifier);
182 ok(hr == D3D_OK, "Failed to get adapter identifier description\n");
183 trace("Driver string: \"%s\"\n", identifier.Driver);
184 trace("Description string: \"%s\"\n", identifier.Description);
185 trace("Device name string: \"%s\"\n", identifier.DeviceName);
186 trace("Driver version %d.%d.%d.%d\n",
187 HIWORD(U(identifier.DriverVersion).HighPart), LOWORD(U(identifier.DriverVersion).HighPart),
188 HIWORD(U(identifier.DriverVersion).LowPart), LOWORD(U(identifier.DriverVersion).LowPart));
189
190 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
191 if(FAILED(hr)) {
192 present_parameters.AutoDepthStencilFormat = D3DFMT_D16;
193 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_HARDWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
194 if(FAILED(hr)) {
195 hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
196 }
197 }
198 ok(hr == D3D_OK || hr == D3DERR_NOTAVAILABLE, "IDirect3D_CreateDevice returned: %08x\n", hr);
199
200 return device_ptr;
201 }
202
203 struct vertex
204 {
205 float x, y, z;
206 DWORD diffuse;
207 };
208
209 struct tvertex
210 {
211 float x, y, z, rhw;
212 DWORD diffuse;
213 };
214
215 struct nvertex
216 {
217 float x, y, z;
218 float nx, ny, nz;
219 DWORD diffuse;
220 };
221
222 static void lighting_test(IDirect3DDevice9 *device)
223 {
224 HRESULT hr;
225 DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
226 DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
227 DWORD color;
228 D3DMATERIAL9 material, old_material;
229 DWORD cop, carg;
230
231 float mat[16] = { 1.0f, 0.0f, 0.0f, 0.0f,
232 0.0f, 1.0f, 0.0f, 0.0f,
233 0.0f, 0.0f, 1.0f, 0.0f,
234 0.0f, 0.0f, 0.0f, 1.0f };
235
236 struct vertex unlitquad[] =
237 {
238 {-1.0f, -1.0f, 0.1f, 0xffff0000},
239 {-1.0f, 0.0f, 0.1f, 0xffff0000},
240 { 0.0f, 0.0f, 0.1f, 0xffff0000},
241 { 0.0f, -1.0f, 0.1f, 0xffff0000},
242 };
243 struct vertex litquad[] =
244 {
245 {-1.0f, 0.0f, 0.1f, 0xff00ff00},
246 {-1.0f, 1.0f, 0.1f, 0xff00ff00},
247 { 0.0f, 1.0f, 0.1f, 0xff00ff00},
248 { 0.0f, 0.0f, 0.1f, 0xff00ff00},
249 };
250 struct nvertex unlitnquad[] =
251 {
252 { 0.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
253 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
254 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
255 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xff0000ff},
256 };
257 struct nvertex litnquad[] =
258 {
259 { 0.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
260 { 0.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
261 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
262 { 1.0f, 0.0f, 0.1f, 1.0f, 1.0f, 1.0f, 0xffffff00},
263 };
264 WORD Indices[] = {0, 1, 2, 2, 3, 0};
265
266 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
267 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
268
269 /* Setup some states that may cause issues */
270 hr = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(0), (D3DMATRIX *) mat);
271 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %08x\n", hr);
272 hr = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, (D3DMATRIX *)mat);
273 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %08x\n", hr);
274 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, (D3DMATRIX *) mat);
275 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %08x\n", hr);
276 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
277 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
278 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE);
279 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
280 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
281 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
282 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
283 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
284 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHATESTENABLE, FALSE);
285 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
286 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
287 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
288 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
289 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
290 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
291 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
292 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);
293 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
294
295 hr = IDirect3DDevice9_SetFVF(device, fvf);
296 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
297
298 hr = IDirect3DDevice9_BeginScene(device);
299 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
300 if(hr == D3D_OK)
301 {
302 /* No lights are defined... That means, lit vertices should be entirely black */
303 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
304 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
305 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
306 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitquad, sizeof(unlitquad[0]));
307 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
308
309 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
310 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
311 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
312 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litquad, sizeof(litquad[0]));
313 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
314
315 hr = IDirect3DDevice9_SetFVF(device, nfvf);
316 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
317
318 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
319 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
320 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
321 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitnquad, sizeof(unlitnquad[0]));
322 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
323
324 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
325 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
326 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
327 2 /*PrimCount */, Indices, D3DFMT_INDEX16, litnquad, sizeof(litnquad[0]));
328 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
329
330 IDirect3DDevice9_EndScene(device);
331 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
332 }
333
334 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
335
336 color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
337 ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
338 color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
339 ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
340 color = getPixelColor(device, 480, 360); /* lower left quad - unlit with normals */
341 ok(color == 0x000000ff, "Unlit quad with normals has color %08x\n", color);
342 color = getPixelColor(device, 480, 120); /* upper left quad - lit with normals */
343 ok(color == 0x00000000, "Lit quad with normals has color %08x\n", color);
344
345 hr = IDirect3DDevice9_GetMaterial(device, &old_material);
346 ok(hr == D3D_OK, "IDirect3DDevice9_GetMaterial returned %08x\n", hr);
347 memset(&material, 0, sizeof(material));
348 material.Diffuse.r = 0.0;
349 material.Diffuse.g = 0.0;
350 material.Diffuse.b = 0.0;
351 material.Diffuse.a = 1.0;
352 material.Ambient.r = 0.0;
353 material.Ambient.g = 0.0;
354 material.Ambient.b = 0.0;
355 material.Ambient.a = 0.0;
356 material.Specular.r = 0.0;
357 material.Specular.g = 0.0;
358 material.Specular.b = 0.0;
359 material.Specular.a = 0.0;
360 material.Emissive.r = 0.0;
361 material.Emissive.g = 0.0;
362 material.Emissive.b = 0.0;
363 material.Emissive.a = 0.0;
364 material.Power = 0.0;
365 IDirect3DDevice9_SetMaterial(device, &material);
366 ok(hr == D3D_OK, "IDirect3DDevice9_SetMaterial returned %08x\n", hr);
367
368 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
369 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
370 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
371 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
372
373 hr = IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_COLOROP, &cop);
374 ok(hr == D3D_OK, "IDirect3DDevice9_GetTextureStageState returned %08x\n", hr);
375 hr = IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_COLORARG1, &carg);
376 ok(hr == D3D_OK, "IDirect3DDevice9_GetTextureStageState returned %08x\n", hr);
377 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
378 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
379 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE | D3DTA_ALPHAREPLICATE);
380 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
381
382 hr = IDirect3DDevice9_BeginScene(device);
383 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
384 if(SUCCEEDED(hr)) {
385 struct vertex lighting_test[] = {
386 {-1.0, -1.0, 0.1, 0x8000ff00},
387 { 1.0, -1.0, 0.1, 0x80000000},
388 {-1.0, 1.0, 0.1, 0x8000ff00},
389 { 1.0, 1.0, 0.1, 0x80000000}
390 };
391 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
392 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
393 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, lighting_test, sizeof(lighting_test[0]));
394 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
395
396 hr = IDirect3DDevice9_EndScene(device);
397 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
398 }
399
400 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
401 color = getPixelColor(device, 320, 240);
402 ok(color == 0x00ffffff, "Lit vertex alpha test returned color %08x, expected 0x00ffffff\n", color);
403
404 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, cop);
405 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
406 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
407 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
408 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2);
409 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
410 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
411 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
412 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, carg);
413 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
414 hr = IDirect3DDevice9_SetMaterial(device, &old_material);
415 ok(hr == D3D_OK, "IDirect3DDevice9_SetMaterial returned %08x\n", hr);
416 }
417
418 static void clear_test(IDirect3DDevice9 *device)
419 {
420 /* Tests the correctness of clearing parameters */
421 HRESULT hr;
422 D3DRECT rect[2];
423 D3DRECT rect_negneg;
424 DWORD color;
425 D3DVIEWPORT9 old_vp, vp;
426 RECT scissor;
427 DWORD oldColorWrite;
428 BOOL invalid_clear_failed = FALSE;
429
430 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
431 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
432
433 /* Positive x, negative y */
434 rect[0].x1 = 0;
435 rect[0].y1 = 480;
436 rect[0].x2 = 320;
437 rect[0].y2 = 240;
438
439 /* Positive x, positive y */
440 rect[1].x1 = 0;
441 rect[1].y1 = 0;
442 rect[1].x2 = 320;
443 rect[1].y2 = 240;
444 /* Clear 2 rectangles with one call. The refrast returns an error in this case, every real driver tested so far
445 * returns D3D_OK, but ignores the rectangle silently
446 */
447 hr = IDirect3DDevice9_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
448 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %08x\n", hr);
449 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
450
451 /* negative x, negative y */
452 rect_negneg.x1 = 640;
453 rect_negneg.y1 = 240;
454 rect_negneg.x2 = 320;
455 rect_negneg.y2 = 0;
456 hr = IDirect3DDevice9_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
457 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %08x\n", hr);
458 if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
459
460 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
461
462 color = getPixelColor(device, 160, 360); /* lower left quad */
463 ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
464 color = getPixelColor(device, 160, 120); /* upper left quad */
465 if(invalid_clear_failed) {
466 /* If the negative rectangle was refused, the other rectangles in the list shouldn't be cleared either */
467 ok(color == 0x00ffffff, "Clear rectangle 1(pos, pos) has color %08x\n", color);
468 } else {
469 /* If the negative rectangle was dropped silently, the correct ones are cleared */
470 ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
471 }
472 color = getPixelColor(device, 480, 360); /* lower right quad */
473 ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
474 color = getPixelColor(device, 480, 120); /* upper right quad */
475 ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
476
477 /* Test how the viewport affects clears */
478 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
479 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
480 hr = IDirect3DDevice9_GetViewport(device, &old_vp);
481 ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %08x\n", hr);
482
483 vp.X = 160;
484 vp.Y = 120;
485 vp.Width = 160;
486 vp.Height = 120;
487 vp.MinZ = 0.0;
488 vp.MaxZ = 1.0;
489 hr = IDirect3DDevice9_SetViewport(device, &vp);
490 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
491 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
492 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
493
494 vp.X = 320;
495 vp.Y = 240;
496 vp.Width = 320;
497 vp.Height = 240;
498 vp.MinZ = 0.0;
499 vp.MaxZ = 1.0;
500 hr = IDirect3DDevice9_SetViewport(device, &vp);
501 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
502 rect[0].x1 = 160;
503 rect[0].y1 = 120;
504 rect[0].x2 = 480;
505 rect[0].y2 = 360;
506 hr = IDirect3DDevice9_Clear(device, 1, &rect[0], D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
507 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
508
509 hr = IDirect3DDevice9_SetViewport(device, &old_vp);
510 ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
511
512 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
513 color = getPixelColor(device, 158, 118);
514 ok(color == 0x00ffffff, "(158,118) has color %08x\n", color);
515 color = getPixelColor(device, 162, 118);
516 ok(color == 0x00ffffff, "(162,118) has color %08x\n", color);
517 color = getPixelColor(device, 158, 122);
518 ok(color == 0x00ffffff, "(158,122) has color %08x\n", color);
519 color = getPixelColor(device, 162, 122);
520 ok(color == 0x000000ff, "(162,122) has color %08x\n", color);
521
522 color = getPixelColor(device, 318, 238);
523 ok(color == 0x000000ff, "(318,238) has color %08x\n", color);
524 color = getPixelColor(device, 322, 238);
525 ok(color == 0x00ffffff, "(322,328) has color %08x\n", color);
526 color = getPixelColor(device, 318, 242);
527 ok(color == 0x00ffffff, "(318,242) has color %08x\n", color);
528 color = getPixelColor(device, 322, 242);
529 ok(color == 0x0000ff00, "(322,242) has color %08x\n", color);
530
531 color = getPixelColor(device, 478, 358);
532 ok(color == 0x0000ff00, "(478,358 has color %08x\n", color);
533 color = getPixelColor(device, 482, 358);
534 ok(color == 0x00ffffff, "(482,358) has color %08x\n", color);
535 color = getPixelColor(device, 478, 362);
536 ok(color == 0x00ffffff, "(478,362) has color %08x\n", color);
537 color = getPixelColor(device, 482, 362);
538 ok(color == 0x00ffffff, "(482,362) has color %08x\n", color);
539
540 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
541 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
542
543 scissor.left = 160;
544 scissor.right = 480;
545 scissor.top = 120;
546 scissor.bottom = 360;
547 hr = IDirect3DDevice9_SetScissorRect(device, &scissor);
548 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
549 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, TRUE);
550 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
551
552 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
553 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
554 hr = IDirect3DDevice9_Clear(device, 1, &rect[1], D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
555 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
556
557 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
558 ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
559
560 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
561 color = getPixelColor(device, 158, 118);
562 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
563 color = getPixelColor(device, 162, 118);
564 ok(color == 0x00ffffff, "Pixel 162/118 has color %08x\n", color);
565 color = getPixelColor(device, 158, 122);
566 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
567 color = getPixelColor(device, 162, 122);
568 ok(color == 0x00ff0000, "Pixel 162/122 has color %08x\n", color);
569
570 color = getPixelColor(device, 158, 358);
571 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
572 color = getPixelColor(device, 162, 358);
573 ok(color == 0x0000ff00, "Pixel 162/358 has color %08x\n", color);
574 color = getPixelColor(device, 158, 358);
575 ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
576 color = getPixelColor(device, 162, 362);
577 ok(color == 0x00ffffff, "Pixel 162/362 has color %08x\n", color);
578
579 color = getPixelColor(device, 478, 118);
580 ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
581 color = getPixelColor(device, 478, 122);
582 ok(color == 0x0000ff00, "Pixel 162/118 has color %08x\n", color);
583 color = getPixelColor(device, 482, 122);
584 ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
585 color = getPixelColor(device, 482, 358);
586 ok(color == 0x00ffffff, "Pixel 162/122 has color %08x\n", color);
587
588 color = getPixelColor(device, 478, 358);
589 ok(color == 0x0000ff00, "Pixel 478/358 has color %08x\n", color);
590 color = getPixelColor(device, 478, 362);
591 ok(color == 0x00ffffff, "Pixel 478/118 has color %08x\n", color);
592 color = getPixelColor(device, 482, 358);
593 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
594 color = getPixelColor(device, 482, 362);
595 ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
596
597 color = getPixelColor(device, 318, 238);
598 ok(color == 0x00ff0000, "Pixel 318/238 has color %08x\n", color);
599 color = getPixelColor(device, 318, 242);
600 ok(color == 0x0000ff00, "Pixel 318/242 has color %08x\n", color);
601 color = getPixelColor(device, 322, 238);
602 ok(color == 0x0000ff00, "Pixel 322/238 has color %08x\n", color);
603 color = getPixelColor(device, 322, 242);
604 ok(color == 0x0000ff00, "Pixel 322/242 has color %08x\n", color);
605
606 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_COLORWRITEENABLE, &oldColorWrite);
607 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
608 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
609 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
610
611 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
612 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
613
614 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, oldColorWrite);
615 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
616
617 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
618
619 /* Colorwriteenable does not affect the clear */
620 color = getPixelColor(device, 320, 240);
621 ok(color == 0x00ffffff, "Color write protected clear returned color %08x\n", color);
622 }
623
624 typedef struct {
625 float in[4];
626 DWORD out;
627 } test_data_t;
628
629 /*
630 * c7 mova ARGB mov ARGB
631 * -2.4 -2 0x00ffff00 -3 0x00ff0000
632 * -1.6 -2 0x00ffff00 -2 0x00ffff00
633 * -0.4 0 0x0000ffff -1 0x0000ff00
634 * 0.4 0 0x0000ffff 0 0x0000ffff
635 * 1.6 2 0x00ff00ff 1 0x000000ff
636 * 2.4 2 0x00ff00ff 2 0x00ff00ff
637 */
638 static void test_mova(IDirect3DDevice9 *device)
639 {
640 static const DWORD mova_test[] = {
641 0xfffe0200, /* vs_2_0 */
642 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
643 0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
644 0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
645 0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
646 0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
647 0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
648 0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
649 0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
650 0x0200002e, 0xb0010000, 0xa0000007, /* mova a0.x, c7.x */
651 0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000, /* mov oD0, c[a0.x + 3] */
652 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
653 0x0000ffff /* END */
654 };
655 static const DWORD mov_test[] = {
656 0xfffe0101, /* vs_1_1 */
657 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
658 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
659 0x00000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0 */
660 0x00000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0 */
661 0x00000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0 */
662 0x00000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0 */
663 0x00000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0 */
664 0x00000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0 */
665 0x00000001, 0xb0010000, 0xa0000007, /* mov a0.x, c7.x */
666 0x00000001, 0xd00f0000, 0xa0e42003, /* mov oD0, c[a0.x + 3] */
667 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
668 0x0000ffff /* END */
669 };
670
671 static const test_data_t test_data[2][6] = {
672 {
673 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff0000},
674 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
675 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ff00},
676 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
677 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x000000ff},
678 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
679 },
680 {
681 {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
682 {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
683 {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
684 {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
685 {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff},
686 {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
687 }
688 };
689
690 static const float quad[][3] = {
691 {-1.0f, -1.0f, 0.0f},
692 {-1.0f, 1.0f, 0.0f},
693 { 1.0f, -1.0f, 0.0f},
694 { 1.0f, 1.0f, 0.0f},
695 };
696
697 static const D3DVERTEXELEMENT9 decl_elements[] = {
698 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
699 D3DDECL_END()
700 };
701
702 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
703 IDirect3DVertexShader9 *mova_shader = NULL;
704 IDirect3DVertexShader9 *mov_shader = NULL;
705 HRESULT hr;
706 UINT i, j;
707
708 hr = IDirect3DDevice9_CreateVertexShader(device, mova_test, &mova_shader);
709 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
710 hr = IDirect3DDevice9_CreateVertexShader(device, mov_test, &mov_shader);
711 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
712 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
713 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
714 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
715 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
716
717 hr = IDirect3DDevice9_SetVertexShader(device, mov_shader);
718 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
719 for(j = 0; j < 2; ++j)
720 {
721 for (i = 0; i < (sizeof(test_data[0]) / sizeof(test_data_t)); ++i)
722 {
723 DWORD color;
724
725 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 7, test_data[j][i].in, 1);
726 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
727
728 hr = IDirect3DDevice9_BeginScene(device);
729 ok(SUCCEEDED(hr), "BeginScene failed (%08x)\n", hr);
730
731 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], 3 * sizeof(float));
732 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
733
734 hr = IDirect3DDevice9_EndScene(device);
735 ok(SUCCEEDED(hr), "EndScene failed (%08x)\n", hr);
736
737 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
738 ok(SUCCEEDED(hr), "Present failed (%08x)\n", hr);
739
740 color = getPixelColor(device, 320, 240);
741 ok(color == test_data[j][i].out, "Expected color %08x, got %08x (for input %f, instruction %s)\n",
742 test_data[j][i].out, color, test_data[j][i].in[0], j == 0 ? "mov" : "mova");
743
744 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
745 ok(SUCCEEDED(hr), "Clear failed (%08x)\n", hr);
746 }
747 hr = IDirect3DDevice9_SetVertexShader(device, mova_shader);
748 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
749 }
750
751 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
752 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
753
754 IDirect3DVertexDeclaration9_Release(vertex_declaration);
755 IDirect3DVertexShader9_Release(mova_shader);
756 IDirect3DVertexShader9_Release(mov_shader);
757 }
758
759 struct sVertex {
760 float x, y, z;
761 DWORD diffuse;
762 DWORD specular;
763 };
764
765 struct sVertexT {
766 float x, y, z, rhw;
767 DWORD diffuse;
768 DWORD specular;
769 };
770
771 static void fog_test(IDirect3DDevice9 *device)
772 {
773 HRESULT hr;
774 DWORD color;
775 BYTE r, g, b;
776 float start = 0.0f, end = 1.0f;
777 D3DCAPS9 caps;
778 int i;
779
780 /* Gets full z based fog with linear fog, no fog with specular color */
781 struct sVertex unstransformed_1[] = {
782 {-1, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
783 {-1, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
784 { 0, 0, 0.1f, 0xFFFF0000, 0xFF000000 },
785 { 0, -1, 0.1f, 0xFFFF0000, 0xFF000000 },
786 };
787 /* Ok, I am too lazy to deal with transform matrices */
788 struct sVertex unstransformed_2[] = {
789 {-1, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
790 {-1, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
791 { 0, 1, 1.0f, 0xFFFF0000, 0xFF000000 },
792 { 0, 0, 1.0f, 0xFFFF0000, 0xFF000000 },
793 };
794 /* Untransformed ones. Give them a different diffuse color to make the test look
795 * nicer. It also makes making sure that they are drawn correctly easier.
796 */
797 struct sVertexT transformed_1[] = {
798 {320, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
799 {640, 0, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
800 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
801 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
802 };
803 struct sVertexT transformed_2[] = {
804 {320, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
805 {640, 240, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
806 {640, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
807 {320, 480, 1.0f, 1.0f, 0xFFFFFF00, 0xFF000000 },
808 };
809 struct vertex rev_fog_quads[] = {
810 {-1.0, -1.0, 0.1, 0x000000ff},
811 {-1.0, 0.0, 0.1, 0x000000ff},
812 { 0.0, 0.0, 0.1, 0x000000ff},
813 { 0.0, -1.0, 0.1, 0x000000ff},
814
815 { 0.0, -1.0, 0.9, 0x000000ff},
816 { 0.0, 0.0, 0.9, 0x000000ff},
817 { 1.0, 0.0, 0.9, 0x000000ff},
818 { 1.0, -1.0, 0.9, 0x000000ff},
819
820 { 0.0, 0.0, 0.4, 0x000000ff},
821 { 0.0, 1.0, 0.4, 0x000000ff},
822 { 1.0, 1.0, 0.4, 0x000000ff},
823 { 1.0, 0.0, 0.4, 0x000000ff},
824
825 {-1.0, 0.0, 0.7, 0x000000ff},
826 {-1.0, 1.0, 0.7, 0x000000ff},
827 { 0.0, 1.0, 0.7, 0x000000ff},
828 { 0.0, 0.0, 0.7, 0x000000ff},
829 };
830 WORD Indices[] = {0, 1, 2, 2, 3, 0};
831
832 memset(&caps, 0, sizeof(caps));
833 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
834 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %08x\n", hr);
835 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
836 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
837
838 /* Setup initial states: No lighting, fog on, fog color */
839 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
840 ok(hr == D3D_OK, "Turning off lighting returned %08x\n", hr);
841 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
842 ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
843 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
844 ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
845
846 /* First test: Both table fog and vertex fog off */
847 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
848 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
849 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
850 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
851
852 /* Start = 0, end = 1. Should be default, but set them */
853 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
854 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
855 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
856 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
857
858 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
859 {
860 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
861 ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
862 /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
863 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
864 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
865 sizeof(unstransformed_1[0]));
866 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
867
868 /* That makes it use the Z value */
869 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
870 ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
871 /* Untransformed, vertex fog != none (or table fog != none):
872 * Use the Z value as input into the equation
873 */
874 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
875 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
876 sizeof(unstransformed_1[0]));
877 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
878
879 /* transformed verts */
880 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
881 ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
882 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
883 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
884 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
885 sizeof(transformed_1[0]));
886 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
887
888 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
889 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
890 /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
891 * equation
892 */
893 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
894 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_2,
895 sizeof(transformed_2[0]));
896
897 hr = IDirect3DDevice9_EndScene(device);
898 ok(hr == D3D_OK, "EndScene returned %08x\n", hr);
899 }
900 else
901 {
902 ok(FALSE, "BeginScene failed\n");
903 }
904
905 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
906 color = getPixelColor(device, 160, 360);
907 ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
908 color = getPixelColor(device, 160, 120);
909 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
910 color = getPixelColor(device, 480, 120);
911 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
912 if(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
913 {
914 color = getPixelColor(device, 480, 360);
915 ok(color == 0x0000FF00 || color == 0x0000FE00, "Transformed vertex with linear table fog has color %08x\n", color);
916 }
917 else
918 {
919 /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
920 * The settings above result in no fogging with vertex fog
921 */
922 color = getPixelColor(device, 480, 120);
923 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
924 trace("Info: Table fog not supported by this device\n");
925 }
926
927 /* Now test the special case fogstart == fogend */
928 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
929 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
930
931 if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
932 {
933 start = 512;
934 end = 512;
935 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
936 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
937 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
938 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
939
940 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
941 ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
942 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
943 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %08x\n", hr);
944 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
945 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
946
947 /* Untransformed vertex, z coord = 0.1, fogstart = 512, fogend = 512. Would result in
948 * a completely fog-free primitive because start > zcoord, but because start == end, the primitive
949 * is fully covered by fog. The same happens to the 2nd untransformed quad with z = 1.0.
950 * The third transformed quad remains unfogged because the fogcoords are read from the specular
951 * color and has fixed fogstart and fogend.
952 */
953 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
954 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
955 sizeof(unstransformed_1[0]));
956 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
957 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
958 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
959 sizeof(unstransformed_1[0]));
960 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
961
962 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
963 ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
964 /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
965 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
966 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
967 sizeof(transformed_1[0]));
968 ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
969
970 hr = IDirect3DDevice9_EndScene(device);
971 ok(hr == D3D_OK, "EndScene returned %08x\n", hr);
972 }
973 else
974 {
975 ok(FALSE, "BeginScene failed\n");
976 }
977 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
978 color = getPixelColor(device, 160, 360);
979 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 0.1 has color %08x\n", color);
980 color = getPixelColor(device, 160, 120);
981 ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 1.0 has color %08x\n", color);
982 color = getPixelColor(device, 480, 120);
983 ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
984
985 /* Test "reversed" fog without shaders. With shaders this fails on a few Windows D3D implementations,
986 * but without shaders it seems to work everywhere
987 */
988 end = 0.2;
989 start = 0.8;
990 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
991 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
992 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
993 ok(hr == D3D_OK, "Setting fog end returned %08x\n", hr);
994 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
995 ok( hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
996
997 /* Test reversed fog without shaders. ATI cards have problems with reversed fog and shaders, so
998 * it doesn't seem very important for games. ATI cards also have problems with reversed table fog,
999 * so skip this for now
1000 */
1001 for(i = 0; i < 1 /*2 - Table fog test disabled, fails on ATI */; i++) {
1002 const char *mode = (i ? "table" : "vertex");
1003 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1004 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
1005 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, i == 0 ? D3DFOG_LINEAR : D3DFOG_NONE);
1006 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1007 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, i == 0 ? D3DFOG_NONE : D3DFOG_LINEAR);
1008 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1009 hr = IDirect3DDevice9_BeginScene(device);
1010 ok( hr == D3D_OK, "IDirect3DDDevice9_BeginScene returned %08x\n", hr);
1011 if(SUCCEEDED(hr)) {
1012 WORD Indices2[] = { 0, 1, 2, 2, 3, 0,
1013 4, 5, 6, 6, 7, 4,
1014 8, 9, 10, 10, 11, 8,
1015 12, 13, 14, 14, 15, 12};
1016
1017 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */,
1018 16 /* NumVerts */, 8 /*PrimCount */, Indices2, D3DFMT_INDEX16, rev_fog_quads,
1019 sizeof(rev_fog_quads[0]));
1020
1021 hr = IDirect3DDevice9_EndScene(device);
1022 ok( hr == D3D_OK, "IDirect3DDDevice9_EndScene returned %08x\n", hr);
1023 }
1024 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1025 color = getPixelColor(device, 160, 360);
1026 ok(color == 0x0000FF00 || color == 0x0000FE00, "Reversed %s fog: z=0.1 has color 0x%08x, expected 0x0000ff00\n", mode, color);
1027
1028 color = getPixelColor(device, 160, 120);
1029 r = (color & 0x00ff0000) >> 16;
1030 g = (color & 0x0000ff00) >> 8;
1031 b = (color & 0x000000ff);
1032 ok(r == 0x00 && g >= 0x29 && g <= 0x2d && b >= 0xd2 && b <= 0xd6,
1033 "Reversed %s fog: z=0.7 has color 0x%08x, expected\n", mode, color);
1034
1035 color = getPixelColor(device, 480, 120);
1036 r = (color & 0x00ff0000) >> 16;
1037 g = (color & 0x0000ff00) >> 8;
1038 b = (color & 0x000000ff);
1039 ok(r == 0x00 && g >= 0xa8 && g <= 0xac && b >= 0x53 && b <= 0x57,
1040 "Reversed %s fog: z=0.4 has color 0x%08x, expected\n", mode, color);
1041
1042 color = getPixelColor(device, 480, 360);
1043 ok(color == 0x000000ff, "Reversed %s fog: z=0.9 has color 0x%08x, expected 0x000000ff\n", mode, color);
1044
1045 if(!(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)) {
1046 skip("D3DPRASTERCAPS_FOGTABLE not supported, skipping reversed table fog test\n");
1047 break;
1048 }
1049 }
1050 /* Turn off the fog master switch to avoid confusing other tests */
1051 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1052 ok(hr == D3D_OK, "Turning off fog calculations returned %08x\n", hr);
1053 start = 0.0;
1054 end = 1.0;
1055 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
1056 ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
1057 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
1058 ok(hr == D3D_OK, "Setting fog end returned %08x\n", hr);
1059 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
1060 ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %08x\n", hr);
1061 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
1062 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
1063 }
1064
1065 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
1066 * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
1067 * regardless of the actual addressing mode set. */
1068 static void test_cube_wrap(IDirect3DDevice9 *device)
1069 {
1070 static const float quad[][6] = {
1071 {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1072 {-1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1073 { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1074 { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1075 };
1076
1077 static const D3DVERTEXELEMENT9 decl_elements[] = {
1078 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1079 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1080 D3DDECL_END()
1081 };
1082
1083 static const struct {
1084 D3DTEXTUREADDRESS mode;
1085 const char *name;
1086 } address_modes[] = {
1087 {D3DTADDRESS_WRAP, "D3DTADDRESS_WRAP"},
1088 {D3DTADDRESS_MIRROR, "D3DTADDRESS_MIRROR"},
1089 {D3DTADDRESS_CLAMP, "D3DTADDRESS_CLAMP"},
1090 {D3DTADDRESS_BORDER, "D3DTADDRESS_BORDER"},
1091 {D3DTADDRESS_MIRRORONCE, "D3DTADDRESS_MIRRORONCE"},
1092 };
1093
1094 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1095 IDirect3DCubeTexture9 *texture = NULL;
1096 IDirect3DSurface9 *surface = NULL;
1097 D3DLOCKED_RECT locked_rect;
1098 HRESULT hr;
1099 UINT x;
1100 INT y, face;
1101
1102 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1103 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1104 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1105 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1106
1107 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 128, 128,
1108 D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
1109 ok(SUCCEEDED(hr), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr);
1110
1111 hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, 0);
1112 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1113
1114 for (y = 0; y < 128; ++y)
1115 {
1116 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1117 for (x = 0; x < 64; ++x)
1118 {
1119 *ptr++ = 0xffff0000;
1120 }
1121 for (x = 64; x < 128; ++x)
1122 {
1123 *ptr++ = 0xff0000ff;
1124 }
1125 }
1126
1127 hr = IDirect3DSurface9_UnlockRect(surface);
1128 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1129
1130 hr = IDirect3DDevice9_CreateCubeTexture(device, 128, 1, 0, D3DFMT_A8R8G8B8,
1131 D3DPOOL_DEFAULT, &texture, NULL);
1132 ok(SUCCEEDED(hr), "CreateCubeTexture failed (0x%08x)\n", hr);
1133
1134 /* Create cube faces */
1135 for (face = 0; face < 6; ++face)
1136 {
1137 IDirect3DSurface9 *face_surface = NULL;
1138
1139 hr= IDirect3DCubeTexture9_GetCubeMapSurface(texture, face, 0, &face_surface);
1140 ok(SUCCEEDED(hr), "GetCubeMapSurface failed (0x%08x)\n", hr);
1141
1142 hr = IDirect3DDevice9_UpdateSurface(device, surface, NULL, face_surface, NULL);
1143 ok(SUCCEEDED(hr), "UpdateSurface failed (0x%08x)\n", hr);
1144
1145 IDirect3DSurface9_Release(face_surface);
1146 }
1147
1148 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
1149 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1150
1151 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1152 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1153 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1154 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1155 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_BORDERCOLOR, 0xff00ff00);
1156 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr);
1157
1158 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1159 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1160
1161 for (x = 0; x < (sizeof(address_modes) / sizeof(*address_modes)); ++x)
1162 {
1163 DWORD color;
1164
1165 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, address_modes[x].mode);
1166 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1167 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, address_modes[x].mode);
1168 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1169
1170 hr = IDirect3DDevice9_BeginScene(device);
1171 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1172
1173 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1174 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1175
1176 hr = IDirect3DDevice9_EndScene(device);
1177 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1178
1179 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1180 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1181
1182 /* Due to the nature of this test, we sample essentially at the edge
1183 * between two faces. Because of this it's undefined from which face
1184 * the driver will sample. Fortunately that's not important for this
1185 * test, since all we care about is that it doesn't sample from the
1186 * other side of the surface or from the border. */
1187 color = getPixelColor(device, 320, 240);
1188 ok(color == 0x00ff0000 || color == 0x000000ff,
1189 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
1190 color, address_modes[x].name);
1191
1192 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1193 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1194 }
1195
1196 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1197 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1198
1199 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1200 IDirect3DCubeTexture9_Release(texture);
1201 IDirect3DSurface9_Release(surface);
1202 }
1203
1204 static void offscreen_test(IDirect3DDevice9 *device)
1205 {
1206 HRESULT hr;
1207 IDirect3DTexture9 *offscreenTexture = NULL;
1208 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
1209 DWORD color;
1210
1211 static const float quad[][5] = {
1212 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
1213 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
1214 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
1215 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
1216 };
1217
1218 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1219 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
1220
1221 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1222 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
1223 if(!offscreenTexture) {
1224 trace("Failed to create an X8R8G8B8 offscreen texture, trying R5G6B5\n");
1225 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1226 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
1227 if(!offscreenTexture) {
1228 skip("Cannot create an offscreen render target\n");
1229 goto out;
1230 }
1231 }
1232
1233 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
1234 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
1235 if(!backbuffer) {
1236 goto out;
1237 }
1238
1239 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
1240 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
1241 if(!offscreen) {
1242 goto out;
1243 }
1244
1245 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
1246 ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
1247
1248 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1249 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
1250 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
1251 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
1252 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1253 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1254 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1255 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1256 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1257 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1258
1259 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
1260 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
1261 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
1262 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1263 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
1264
1265 /* Draw without textures - Should result in a white quad */
1266 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1267 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
1268
1269 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1270 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
1271 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
1272 ok(hr == D3D_OK, "SetTexture failed, %08x\n", hr);
1273
1274 /* This time with the texture */
1275 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1276 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
1277
1278 IDirect3DDevice9_EndScene(device);
1279 }
1280
1281 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1282
1283 /* Center quad - should be white */
1284 color = getPixelColor(device, 320, 240);
1285 ok(color == 0x00ffffff, "Offscreen failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1286 /* Some quad in the cleared part of the texture */
1287 color = getPixelColor(device, 170, 240);
1288 ok(color == 0x00ff00ff, "Offscreen failed: Got color 0x%08x, expected 0x00ff00ff.\n", color);
1289 /* Part of the originally cleared back buffer */
1290 color = getPixelColor(device, 10, 10);
1291 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1292 if(0) {
1293 /* Lower left corner of the screen, where back buffer offscreen rendering draws the offscreen texture.
1294 * It should be red, but the offscreen texture may leave some junk there. Not tested yet. Depending on
1295 * the offscreen rendering mode this test would succeed or fail
1296 */
1297 color = getPixelColor(device, 10, 470);
1298 ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1299 }
1300
1301 out:
1302 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1303
1304 /* restore things */
1305 if(backbuffer) {
1306 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1307 IDirect3DSurface9_Release(backbuffer);
1308 }
1309 if(offscreenTexture) {
1310 IDirect3DTexture9_Release(offscreenTexture);
1311 }
1312 if(offscreen) {
1313 IDirect3DSurface9_Release(offscreen);
1314 }
1315 }
1316
1317 /* This test tests fog in combination with shaders.
1318 * What's tested: linear fog (vertex and table) with pixel shader
1319 * linear table fog with non foggy vertex shader
1320 * vertex fog with foggy vertex shader
1321 * What's not tested: non linear fog with shader
1322 * table fog with foggy vertex shader
1323 */
1324 static void fog_with_shader_test(IDirect3DDevice9 *device)
1325 {
1326 HRESULT hr;
1327 DWORD color;
1328 union {
1329 float f;
1330 DWORD i;
1331 } start, end;
1332 unsigned int i, j;
1333
1334 /* basic vertex shader without fog computation ("non foggy") */
1335 static const DWORD vertex_shader_code1[] = {
1336 0xfffe0101, /* vs_1_1 */
1337 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1338 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1339 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1340 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1341 0x0000ffff
1342 };
1343 /* basic vertex shader with reversed fog computation ("foggy") */
1344 static const DWORD vertex_shader_code2[] = {
1345 0xfffe0101, /* vs_1_1 */
1346 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1347 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
1348 0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
1349 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1350 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
1351 0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000, /* add r0, v0.z, c0.z */
1352 0x00000005, 0xc00f0001, 0x80000000, 0xa0000000, /* mul oFog, r0.x, c0.x */
1353 0x0000ffff
1354 };
1355 /* basic pixel shader */
1356 static const DWORD pixel_shader_code[] = {
1357 0xffff0101, /* ps_1_1 */
1358 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, vo */
1359 0x0000ffff
1360 };
1361
1362 static struct vertex quad[] = {
1363 {-1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1364 {-1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1365 { 1.0f, -1.0f, 0.0f, 0xFFFF0000 },
1366 { 1.0f, 1.0f, 0.0f, 0xFFFF0000 },
1367 };
1368
1369 static const D3DVERTEXELEMENT9 decl_elements[] = {
1370 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1371 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
1372 D3DDECL_END()
1373 };
1374
1375 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1376 IDirect3DVertexShader9 *vertex_shader[3] = {NULL, NULL, NULL};
1377 IDirect3DPixelShader9 *pixel_shader[2] = {NULL, NULL};
1378
1379 /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
1380 static const struct test_data_t {
1381 int vshader;
1382 int pshader;
1383 D3DFOGMODE vfog;
1384 D3DFOGMODE tfog;
1385 unsigned int color[11];
1386 } test_data[] = {
1387 /* only pixel shader: */
1388 {0, 1, 0, 3,
1389 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1390 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1391 {0, 1, 1, 3,
1392 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1393 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1394 {0, 1, 2, 3,
1395 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1396 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1397 {0, 1, 3, 0,
1398 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1399 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1400 {0, 1, 3, 3,
1401 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1402 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1403
1404 /* vertex shader */
1405 {1, 0, 0, 0,
1406 {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
1407 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
1408 {1, 0, 0, 3,
1409 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1410 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1411 {1, 0, 1, 3,
1412 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1413 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1414
1415 {1, 0, 2, 3,
1416 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1417 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1418 {1, 0, 3, 3,
1419 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1420 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1421
1422 /* vertex shader and pixel shader */
1423 {1, 1, 0, 3,
1424 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1425 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1426 {1, 1, 1, 3,
1427 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1428 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1429 {1, 1, 2, 3,
1430 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1431 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1432
1433 {1, 1, 3, 3,
1434 {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1435 0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1436
1437
1438 #if 0 /* FIXME: these fail on GeForce 8500 */
1439 /* foggy vertex shader */
1440 {2, 0, 0, 0,
1441 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1442 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1443 {2, 0, 1, 0,
1444 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1445 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1446 {2, 0, 2, 0,
1447 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1448 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1449 {2, 0, 3, 0,
1450 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1451 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1452 #endif
1453
1454 /* foggy vertex shader and pixel shader */
1455 {2, 1, 0, 0,
1456 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1457 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1458 {2, 1, 1, 0,
1459 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1460 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1461 {2, 1, 2, 0,
1462 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1463 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1464 {2, 1, 3, 0,
1465 {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1466 0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1467
1468 };
1469
1470 /* NOTE: changing these values will not affect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
1471 start.f=0.1f;
1472 end.f=0.9f;
1473
1474 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]);
1475 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1476 hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]);
1477 ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1478 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]);
1479 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1480 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1481 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
1482
1483 /* Setup initial states: No lighting, fog on, fog color */
1484 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1485 ok(hr == D3D_OK, "Turning off lighting failed (%08x)\n", hr);
1486 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
1487 ok(hr == D3D_OK, "Turning on fog calculations failed (%08x)\n", hr);
1488 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
1489 ok(hr == D3D_OK, "Setting fog color failed (%08x)\n", hr);
1490 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1491 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1492
1493 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
1494 ok(hr == D3D_OK, "Turning off table fog failed (%08x)\n", hr);
1495 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
1496 ok(hr == D3D_OK, "Turning off vertex fog failed (%08x)\n", hr);
1497
1498 /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
1499 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i);
1500 ok(hr == D3D_OK, "Setting fog start failed (%08x)\n", hr);
1501 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i);
1502 ok(hr == D3D_OK, "Setting fog end failed (%08x)\n", hr);
1503
1504 for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++)
1505 {
1506 hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]);
1507 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1508 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[test_data[i].pshader]);
1509 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1510 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog);
1511 ok( hr == D3D_OK, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1512 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog);
1513 ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1514
1515 for(j=0; j < 11; j++)
1516 {
1517 /* Don't use the whole zrange to prevent rounding errors */
1518 quad[0].z = 0.001f + (float)j / 10.02f;
1519 quad[1].z = 0.001f + (float)j / 10.02f;
1520 quad[2].z = 0.001f + (float)j / 10.02f;
1521 quad[3].z = 0.001f + (float)j / 10.02f;
1522
1523 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1524 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1525
1526 hr = IDirect3DDevice9_BeginScene(device);
1527 ok( hr == D3D_OK, "BeginScene returned failed (%08x)\n", hr);
1528
1529 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1530 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
1531
1532 hr = IDirect3DDevice9_EndScene(device);
1533 ok(hr == D3D_OK, "EndScene failed (%08x)\n", hr);
1534
1535 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1536
1537 /* As the red and green component are the result of blending use 5% tolerance on the expected value */
1538 color = getPixelColor(device, 128, 240);
1539 ok(color_match(color, test_data[i].color[j], 13),
1540 "fog vs%i ps%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%\n",
1541 test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, j, color, test_data[i].color[j]);
1542 }
1543 }
1544
1545 /* reset states */
1546 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1547 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1548 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1549 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1550 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1551 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1552 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1553 ok(hr == D3D_OK, "Turning off fog calculations failed (%08x)\n", hr);
1554
1555 IDirect3DVertexShader9_Release(vertex_shader[1]);
1556 IDirect3DVertexShader9_Release(vertex_shader[2]);
1557 IDirect3DPixelShader9_Release(pixel_shader[1]);
1558 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1559 }
1560
1561 static void generate_bumpmap_textures(IDirect3DDevice9 *device) {
1562 unsigned int i, x, y;
1563 HRESULT hr;
1564 IDirect3DTexture9 *texture[2] = {NULL, NULL};
1565 D3DLOCKED_RECT locked_rect;
1566
1567 /* Generate the textures */
1568 for(i=0; i<2; i++)
1569 {
1570 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, 0, i?D3DFMT_A8R8G8B8:D3DFMT_V8U8,
1571 D3DPOOL_MANAGED, &texture[i], NULL);
1572 ok(SUCCEEDED(hr), "CreateTexture failed (0x%08x)\n", hr);
1573
1574 hr = IDirect3DTexture9_LockRect(texture[i], 0, &locked_rect, NULL, 0);
1575 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1576 for (y = 0; y < 128; ++y)
1577 {
1578 if(i)
1579 { /* Set up black texture with 2x2 texel white spot in the middle */
1580 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1581 for (x = 0; x < 128; ++x)
1582 {
1583 if(y>62 && y<66 && x>62 && x<66)
1584 *ptr++ = 0xffffffff;
1585 else
1586 *ptr++ = 0xff000000;
1587 }
1588 }
1589 else
1590 { /* Set up a displacement map which points away from the center parallel to the closest axis.
1591 * (if multiplied with bumpenvmat)
1592 */
1593 WORD *ptr = (WORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1594 for (x = 0; x < 128; ++x)
1595 {
1596 if(abs(x-64)>abs(y-64))
1597 {
1598 if(x < 64)
1599 *ptr++ = 0xc000;
1600 else
1601 *ptr++ = 0x4000;
1602 }
1603 else
1604 {
1605 if(y < 64)
1606 *ptr++ = 0x0040;
1607 else
1608 *ptr++ = 0x00c0;
1609 }
1610 }
1611 }
1612 }
1613 hr = IDirect3DTexture9_UnlockRect(texture[i], 0);
1614 ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1615
1616 hr = IDirect3DDevice9_SetTexture(device, i, (IDirect3DBaseTexture9 *)texture[i]);
1617 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1618
1619 /* Disable texture filtering */
1620 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1621 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1622 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1623 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1624
1625 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1626 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr);
1627 hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1628 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr);
1629 }
1630 }
1631
1632 /* test the behavior of the texbem instruction
1633 * with normal 2D and projective 2D textures
1634 */
1635 static void texbem_test(IDirect3DDevice9 *device)
1636 {
1637 HRESULT hr;
1638 DWORD color;
1639 int i;
1640
1641 static const DWORD pixel_shader_code[] = {
1642 0xffff0101, /* ps_1_1*/
1643 0x00000042, 0xb00f0000, /* tex t0*/
1644 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
1645 0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
1646 0x0000ffff
1647 };
1648 static const DWORD double_texbem_code[] = {
1649 0xffff0103, /* ps_1_3 */
1650 0x00000042, 0xb00f0000, /* tex t0 */
1651 0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0 */
1652 0x00000042, 0xb00f0002, /* tex t2 */
1653 0x00000043, 0xb00f0003, 0xb0e40002, /* texbem t3, t2 */
1654 0x00000002, 0x800f0000, 0xb0e40001, 0xb0e40003, /* add r0, t1, t3 */
1655 0x0000ffff /* end */
1656 };
1657
1658
1659 static const float quad[][7] = {
1660 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
1661 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
1662 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
1663 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
1664 };
1665 static const float quad_proj[][9] = {
1666 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 128.0f},
1667 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 128.0f, 0.0f, 128.0f},
1668 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 128.0f, 0.0f, 0.0f, 128.0f},
1669 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 128.0f, 128.0f, 0.0f, 128.0f},
1670 };
1671
1672 static const D3DVERTEXELEMENT9 decl_elements[][4] = { {
1673 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1674 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1675 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1676 D3DDECL_END()
1677 },{
1678 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1679 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1680 {0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1681 D3DDECL_END()
1682 } };
1683
1684 /* use asymmetric matrix to test loading */
1685 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
1686
1687 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1688 IDirect3DPixelShader9 *pixel_shader = NULL;
1689 IDirect3DTexture9 *texture = NULL, *texture1, *texture2;
1690 D3DLOCKED_RECT locked_rect;
1691
1692 generate_bumpmap_textures(device);
1693
1694 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1695 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1696 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1697 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1698 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
1699
1700 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1701 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1702
1703 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1704 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1705
1706 for(i=0; i<2; i++)
1707 {
1708 if(i)
1709 {
1710 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
1711 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1712 }
1713
1714 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements[i], &vertex_declaration);
1715 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1716 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1717 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1718
1719 hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader);
1720 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1721 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1722 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1723
1724 hr = IDirect3DDevice9_BeginScene(device);
1725 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1726
1727 if(!i)
1728 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1729 else
1730 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad_proj[0], sizeof(quad_proj[0]));
1731 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1732
1733 hr = IDirect3DDevice9_EndScene(device);
1734 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1735
1736 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1737 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1738
1739 color = getPixelColor(device, 320-32, 240);
1740 ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1741 color = getPixelColor(device, 320+32, 240);
1742 ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1743 color = getPixelColor(device, 320, 240-32);
1744 ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1745 color = getPixelColor(device, 320, 240+32);
1746 ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1747
1748 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1749 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1750 IDirect3DPixelShader9_Release(pixel_shader);
1751
1752 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1753 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1754 IDirect3DVertexDeclaration9_Release(vertex_declaration);
1755 }
1756
1757 /* clean up */
1758 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1759 ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1760
1761 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
1762 ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1763
1764 for(i=0; i<2; i++)
1765 {
1766 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
1767 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
1768 IDirect3DTexture9_Release(texture); /* For the GetTexture */
1769 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
1770 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1771 IDirect3DTexture9_Release(texture);
1772 }
1773
1774 /* Test double texbem */
1775 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture, NULL);
1776 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1777 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture1, NULL);
1778 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1779 hr = IDirect3DDevice9_CreateTexture(device, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture2, NULL);
1780 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1781 hr = IDirect3DDevice9_CreatePixelShader(device, double_texbem_code, &pixel_shader);
1782 ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1783
1784 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
1785 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1786 ((signed char *) locked_rect.pBits)[0] = (-1.0 / 8.0) * 127;
1787 ((signed char *) locked_rect.pBits)[1] = ( 1.0 / 8.0) * 127;
1788
1789 hr = IDirect3DTexture9_UnlockRect(texture, 0);
1790 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1791
1792 hr = IDirect3DTexture9_LockRect(texture1, 0, &locked_rect, NULL, 0);
1793 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1794 ((signed char *) locked_rect.pBits)[0] = (-2.0 / 8.0) * 127;
1795 ((signed char *) locked_rect.pBits)[1] = (-4.0 / 8.0) * 127;
1796 hr = IDirect3DTexture9_UnlockRect(texture1, 0);
1797 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1798
1799 {
1800 /* Some data without any meaning, just to have an 8x8 array to see which element is picked */
1801 #define tex 0x00ff0000
1802 #define tex1 0x0000ff00
1803 #define origin 0x000000ff
1804 static const DWORD pixel_data[] = {
1805 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1806 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1807 0x000000ff, tex1 , 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1808 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1809 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, origin, 0x000000ff, tex , 0x000000ff,
1810 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1811 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1812 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1813 };
1814 #undef tex1
1815 #undef tex2
1816 #undef origin
1817
1818 hr = IDirect3DTexture9_LockRect(texture2, 0, &locked_rect, NULL, 0);
1819 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1820 for(i = 0; i < 8; i++) {
1821 memcpy(((char *) locked_rect.pBits) + i * locked_rect.Pitch, pixel_data + 8 * i, 8 * sizeof(DWORD));
1822 }
1823 hr = IDirect3DTexture9_UnlockRect(texture2, 0);
1824 ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1825 }
1826
1827 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
1828 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1829 hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) texture2);
1830 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1831 hr = IDirect3DDevice9_SetTexture(device, 2, (IDirect3DBaseTexture9 *) texture1);
1832 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1833 hr = IDirect3DDevice9_SetTexture(device, 3, (IDirect3DBaseTexture9 *) texture2);
1834 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1835 hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1836 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1837 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX4);
1838 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1839
1840 bumpenvmat[0] =-1.0; bumpenvmat[2] = 2.0;
1841 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.0;
1842 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1843 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1844 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1845 IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1846
1847 bumpenvmat[0] = 1.5; bumpenvmat[2] = 0.0;
1848 bumpenvmat[1] = 0.0; bumpenvmat[3] = 0.5;
1849 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1850 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1851 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1852 IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1853
1854 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1855 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1856 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1857 hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1858 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1859 hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1860 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1861 hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1862
1863 hr = IDirect3DDevice9_BeginScene(device);
1864 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1865 if(SUCCEEDED(hr)) {
1866 static const float double_quad[] = {
1867 -1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1868 1.0, -1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1869 -1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1870 1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.5, 0.5,
1871 };
1872
1873 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, double_quad, sizeof(float) * 11);
1874 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1875 hr = IDirect3DDevice9_EndScene(device);
1876 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1877 }
1878 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1879 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1880 color = getPixelColor(device, 320, 240);
1881 ok(color == 0x00ffff00, "double texbem failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1882
1883 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1884 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1885 hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
1886 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1887 hr = IDirect3DDevice9_SetTexture(device, 2, NULL);
1888 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1889 hr = IDirect3DDevice9_SetTexture(device, 3, NULL);
1890 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1891 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1892 ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1893
1894 IDirect3DPixelShader9_Release(pixel_shader);
1895 IDirect3DTexture9_Release(texture);
1896 IDirect3DTexture9_Release(texture1);
1897 IDirect3DTexture9_Release(texture2);
1898 }
1899
1900 static void z_range_test(IDirect3DDevice9 *device)
1901 {
1902 const struct vertex quad[] =
1903 {
1904 {-1.0f, 0.0f, 1.1f, 0xffff0000},
1905 {-1.0f, 1.0f, 1.1f, 0xffff0000},
1906 { 1.0f, 0.0f, -1.1f, 0xffff0000},
1907 { 1.0f, 1.0f, -1.1f, 0xffff0000},
1908 };
1909 const struct vertex quad2[] =
1910 {
1911 {-1.0f, 0.0f, 1.1f, 0xff0000ff},
1912 {-1.0f, 1.0f, 1.1f, 0xff0000ff},
1913 { 1.0f, 0.0f, -1.1f, 0xff0000ff},
1914 { 1.0f, 1.0f, -1.1f, 0xff0000ff},
1915 };
1916
1917 const struct tvertex quad3[] =
1918 {
1919 { 0, 240, 1.1f, 1.0, 0xffffff00},
1920 { 0, 480, 1.1f, 1.0, 0xffffff00},
1921 { 640, 240, -1.1f, 1.0, 0xffffff00},
1922 { 640, 480, -1.1f, 1.0, 0xffffff00},
1923 };
1924 const struct tvertex quad4[] =
1925 {
1926 { 0, 240, 1.1f, 1.0, 0xff00ff00},
1927 { 0, 480, 1.1f, 1.0, 0xff00ff00},
1928 { 640, 240, -1.1f, 1.0, 0xff00ff00},
1929 { 640, 480, -1.1f, 1.0, 0xff00ff00},
1930 };
1931 HRESULT hr;
1932 DWORD color;
1933 IDirect3DVertexShader9 *shader;
1934 IDirect3DVertexDeclaration9 *decl;
1935 D3DCAPS9 caps;
1936 const DWORD shader_code[] = {
1937 0xfffe0101, /* vs_1_1 */
1938 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
1939 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
1940 0x00000001, 0xd00f0000, 0xa0e40000, /* mov oD0, c0 */
1941 0x0000ffff /* end */
1942 };
1943 static const D3DVERTEXELEMENT9 decl_elements[] = {
1944 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1945 D3DDECL_END()
1946 };
1947 /* Does the Present clear the depth stencil? Clear the depth buffer with some value != 0,
1948 * then call Present. Then clear the color buffer to make sure it has some defined content
1949 * after the Present with D3DSWAPEFFECT_DISCARD. After that draw a plane that is somewhere cut
1950 * by the depth value.
1951 */
1952 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.75, 0);
1953 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
1954 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1955 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1956
1957 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, TRUE);
1958 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1959 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
1960 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1961 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
1962 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1963 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1964 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1965 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
1966 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
1967
1968 hr = IDirect3DDevice9_BeginScene(device);
1969 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1970 if(hr == D3D_OK)
1971 {
1972 /* Test the untransformed vertex path */
1973 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1974 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1975 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1976 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1977 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1978 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1979
1980 /* Test the transformed vertex path */
1981 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
1982 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
1983
1984 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad4, sizeof(quad4[0]));
1985 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1986 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1987 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1988 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad3, sizeof(quad3[0]));
1989 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1990
1991 hr = IDirect3DDevice9_EndScene(device);
1992 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
1993 }
1994
1995 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1996 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1997
1998 /* Do not test the exact corner pixels, but go pretty close to them */
1999
2000 /* Clipped because z > 1.0 */
2001 color = getPixelColor(device, 28, 238);
2002 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2003 color = getPixelColor(device, 28, 241);
2004 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2005
2006 /* Not clipped, > z buffer clear value(0.75) */
2007 color = getPixelColor(device, 31, 238);
2008 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2009 color = getPixelColor(device, 31, 241);
2010 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
2011 color = getPixelColor(device, 100, 238);
2012 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2013 color = getPixelColor(device, 100, 241);
2014 ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
2015
2016 /* Not clipped, < z buffer clear value */
2017 color = getPixelColor(device, 104, 238);
2018 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2019 color = getPixelColor(device, 104, 241);
2020 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
2021 color = getPixelColor(device, 318, 238);
2022 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2023 color = getPixelColor(device, 318, 241);
2024 ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
2025
2026 /* Clipped because z < 0.0 */
2027 color = getPixelColor(device, 321, 238);
2028 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2029 color = getPixelColor(device, 321, 241);
2030 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2031
2032 /* Test the shader path */
2033 IDirect3DDevice9_GetDeviceCaps(device, &caps);
2034 if (caps.VertexShaderVersion < D3DVS_VERSION(1, 1)) {
2035 skip("Vertex shaders not supported\n");
2036 goto out;
2037 }
2038 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
2039 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
2040 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
2041 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
2042
2043 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
2044
2045 IDirect3DDevice9_SetVertexDeclaration(device, decl);
2046 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
2047 IDirect3DDevice9_SetVertexShader(device, shader);
2048 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
2049
2050 hr = IDirect3DDevice9_BeginScene(device);
2051 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2052 if(hr == D3D_OK)
2053 {
2054 float colorf[] = {1.0, 0.0, 0.0, 1.0};
2055 float colorf2[] = {0.0, 0.0, 1.0, 1.0};
2056 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf, 1);
2057 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
2058 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
2059 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
2060 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2061 IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf2, 1);
2062 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
2063 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
2064
2065 hr = IDirect3DDevice9_EndScene(device);
2066 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2067 }
2068
2069 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
2070 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
2071 IDirect3DDevice9_SetVertexShader(device, NULL);
2072 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
2073
2074 IDirect3DVertexDeclaration9_Release(decl);
2075 IDirect3DVertexShader9_Release(shader);
2076
2077 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2078 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2079 /* Z < 1.0 */
2080 color = getPixelColor(device, 28, 238);
2081 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2082
2083 /* 1.0 < z < 0.75 */
2084 color = getPixelColor(device, 31, 238);
2085 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2086 color = getPixelColor(device, 100, 238);
2087 ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2088
2089 /* 0.75 < z < 0.0 */
2090 color = getPixelColor(device, 104, 238);
2091 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2092 color = getPixelColor(device, 318, 238);
2093 ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2094
2095 /* 0.0 < z */
2096 color = getPixelColor(device, 321, 238);
2097 ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2098
2099 out:
2100 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
2101 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2102 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
2103 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2104 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
2105 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2106 }
2107
2108 static void fill_surface(IDirect3DSurface9 *surface, DWORD color)
2109 {
2110 D3DSURFACE_DESC desc;
2111 D3DLOCKED_RECT l;
2112 HRESULT hr;
2113 unsigned int x, y;
2114 DWORD *mem;
2115
2116 memset(&desc, 0, sizeof(desc));
2117 memset(&l, 0, sizeof(l));
2118 hr = IDirect3DSurface9_GetDesc(surface, &desc);
2119 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %08x\n", hr);
2120 hr = IDirect3DSurface9_LockRect(surface, &l, NULL, 0);
2121 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed with %08x\n", hr);
2122 if(FAILED(hr)) return;
2123
2124 for(y = 0; y < desc.Height; y++)
2125 {
2126 mem = (DWORD *) ((BYTE *) l.pBits + y * l.Pitch);
2127 for(x = 0; x < l.Pitch / sizeof(DWORD); x++)
2128 {
2129 mem[x] = color;
2130 }
2131 }
2132 hr = IDirect3DSurface9_UnlockRect(surface);
2133 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed with %08x\n", hr);
2134 }
2135
2136 /* This tests a variety of possible StretchRect() situations */
2137 static void stretchrect_test(IDirect3DDevice9 *device)
2138 {
2139 HRESULT hr;
2140 IDirect3DTexture9 *tex_rt32 = NULL, *tex_rt64 = NULL, *tex_rt_dest64 = NULL;
2141 IDirect3DSurface9 *surf_tex_rt32 = NULL, *surf_tex_rt64 = NULL, *surf_tex_rt_dest64 = NULL;
2142 IDirect3DTexture9 *tex32 = NULL, *tex64 = NULL, *tex_dest64 = NULL;
2143 IDirect3DSurface9 *surf_tex32 = NULL, *surf_tex64 = NULL, *surf_tex_dest64 = NULL;
2144 IDirect3DSurface9 *surf_rt32 = NULL, *surf_rt64 = NULL, *surf_rt_dest64 = NULL;
2145 IDirect3DSurface9 *surf_offscreen32 = NULL, *surf_offscreen64 = NULL, *surf_offscreen_dest64 = NULL;
2146 IDirect3DSurface9 *surf_temp32 = NULL, *surf_temp64 = NULL;
2147 IDirect3DSurface9 *orig_rt = NULL;
2148 DWORD color;
2149
2150 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &orig_rt);
2151 ok(hr == D3D_OK, "Can't get render target, hr = %08x\n", hr);
2152 if(!orig_rt) {
2153 goto out;
2154 }
2155
2156 /* Create our temporary surfaces in system memory */
2157 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp32, NULL);
2158 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2159 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp64, NULL);
2160 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2161
2162 /* Create offscreen plain surfaces in D3DPOOL_DEFAULT */
2163 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen32, NULL);
2164 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2165 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen64, NULL);
2166 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2167 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen_dest64, NULL);
2168 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2169
2170 /* Create render target surfaces */
2171 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt32, NULL );
2172 ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2173 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt64, NULL );
2174 ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2175 hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt_dest64, NULL );
2176 ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2177
2178 /* Create render target textures */
2179 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt32, NULL);
2180 ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2181 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt64, NULL);
2182 ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2183 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt_dest64, NULL);
2184 ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2185 if (tex_rt32) {
2186 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt32, 0, &surf_tex_rt32);
2187 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2188 }
2189 if (tex_rt64) {
2190 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt64, 0, &surf_tex_rt64);
2191 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2192 }
2193 if (tex_rt_dest64) {
2194 hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt_dest64, 0, &surf_tex_rt_dest64);
2195 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2196 }
2197
2198 /* Create regular textures in D3DPOOL_DEFAULT */
2199 hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex32, NULL);
2200 ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2201 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex64, NULL);
2202 ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2203 hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_dest64, NULL);
2204 ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2205 if (tex32) {
2206 hr = IDirect3DTexture9_GetSurfaceLevel(tex32, 0, &surf_tex32);
2207 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2208 }
2209 if (tex64) {
2210 hr = IDirect3DTexture9_GetSurfaceLevel(tex64, 0, &surf_tex64);
2211 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2212 }
2213 if (tex_dest64) {
2214 hr = IDirect3DTexture9_GetSurfaceLevel(tex_dest64, 0, &surf_tex_dest64);
2215 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2216 }
2217
2218 /*********************************************************************
2219 * Tests for when the source parameter is an offscreen plain surface *
2220 *********************************************************************/
2221
2222 /* Fill the offscreen 64x64 surface with green */
2223 if (surf_offscreen64)
2224 fill_surface(surf_offscreen64, 0xff00ff00);
2225
2226 /* offscreenplain ==> offscreenplain, same size */
2227 if(surf_offscreen64 && surf_offscreen_dest64) {
2228 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_offscreen_dest64, NULL, 0);
2229 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2230
2231 if (hr == D3D_OK) {
2232 color = getPixelColorFromSurface(surf_offscreen_dest64, 32, 32);
2233 ok(color == 0xff00ff00, "StretchRect offscreen ==> offscreen same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2234 }
2235 }
2236
2237 /* offscreenplain ==> rendertarget texture, same size */
2238 if(surf_offscreen64 && surf_tex_rt_dest64 && surf_temp64) {
2239 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_rt_dest64, NULL, 0);
2240 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2241
2242 /* We can't lock rendertarget textures, so copy to our temp surface first */
2243 if (hr == D3D_OK) {
2244 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2245 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2246 }
2247
2248 if (hr == D3D_OK) {
2249 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2250 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2251 }
2252 }
2253
2254 /* offscreenplain ==> rendertarget surface, same size */
2255 if(surf_offscreen64 && surf_rt_dest64) {
2256 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_rt_dest64, NULL, 0);
2257 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2258
2259 if (hr == D3D_OK) {
2260 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2261 ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2262 }
2263 }
2264
2265 /* offscreenplain ==> texture, same size (should fail) */
2266 if(surf_offscreen64 && surf_tex_dest64) {
2267 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_dest64, NULL, 0);
2268 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2269 }
2270
2271 /* Fill the smaller offscreen surface with red */
2272 fill_surface(surf_offscreen32, 0xffff0000);
2273
2274 /* offscreenplain ==> offscreenplain, scaling (should fail) */
2275 if(surf_offscreen32 && surf_offscreen64) {
2276 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_offscreen64, NULL, 0);
2277 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2278 }
2279
2280 /* offscreenplain ==> rendertarget texture, scaling */
2281 if(surf_offscreen32 && surf_tex_rt_dest64 && surf_temp64) {
2282 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_rt_dest64, NULL, 0);
2283 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2284
2285 /* We can't lock rendertarget textures, so copy to our temp surface first */
2286 if (hr == D3D_OK) {
2287 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2288 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2289 }
2290
2291 if (hr == D3D_OK) {
2292 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2293 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2294 }
2295 }
2296
2297 /* offscreenplain ==> rendertarget surface, scaling */
2298 if(surf_offscreen32 && surf_rt_dest64) {
2299 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_rt_dest64, NULL, 0);
2300 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2301
2302 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2303 ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2304 }
2305
2306 /* offscreenplain ==> texture, scaling (should fail) */
2307 if(surf_offscreen32 && surf_tex_dest64) {
2308 hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_dest64, NULL, 0);
2309 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2310 }
2311
2312 /************************************************************
2313 * Tests for when the source parameter is a regular texture *
2314 ************************************************************/
2315
2316 /* Fill the surface of the regular texture with blue */
2317 if (surf_tex64 && surf_temp64) {
2318 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2319 fill_surface(surf_temp64, 0xff0000ff);
2320 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex64, NULL);
2321 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2322 }
2323
2324 /* texture ==> offscreenplain, same size */
2325 if(surf_tex64 && surf_offscreen64) {
2326 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_offscreen64, NULL, 0);
2327 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2328 }
2329
2330 /* texture ==> rendertarget texture, same size */
2331 if(surf_tex64 && surf_tex_rt_dest64 && surf_temp64) {
2332 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_rt_dest64, NULL, 0);
2333 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2334
2335 /* We can't lock rendertarget textures, so copy to our temp surface first */
2336 if (hr == D3D_OK) {
2337 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2338 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2339 }
2340
2341 if (hr == D3D_OK) {
2342 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2343 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2344 }
2345 }
2346
2347 /* texture ==> rendertarget surface, same size */
2348 if(surf_tex64 && surf_rt_dest64) {
2349 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_rt_dest64, NULL, 0);
2350 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2351
2352 if (hr == D3D_OK) {
2353 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2354 ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2355 }
2356 }
2357
2358 /* texture ==> texture, same size (should fail) */
2359 if(surf_tex64 && surf_tex_dest64) {
2360 hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_dest64, NULL, 0);
2361 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2362 }
2363
2364 /* Fill the surface of the smaller regular texture with red */
2365 if (surf_tex32 && surf_temp32) {
2366 /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2367 fill_surface(surf_temp32, 0xffff0000);
2368 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex32, NULL);
2369 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2370 }
2371
2372 /* texture ==> offscreenplain, scaling (should fail) */
2373 if(surf_tex32 && surf_offscreen64) {
2374 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_offscreen64, NULL, 0);
2375 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2376 }
2377
2378 /* texture ==> rendertarget texture, scaling */
2379 if(surf_tex32 && surf_tex_rt_dest64 && surf_temp64) {
2380 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_rt_dest64, NULL, 0);
2381 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2382
2383 /* We can't lock rendertarget textures, so copy to our temp surface first */
2384 if (hr == D3D_OK) {
2385 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2386 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2387 }
2388
2389 if (hr == D3D_OK) {
2390 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2391 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2392 }
2393 }
2394
2395 /* texture ==> rendertarget surface, scaling */
2396 if(surf_tex32 && surf_rt_dest64) {
2397 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_rt_dest64, NULL, 0);
2398 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2399
2400 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2401 ok(color == 0xffff0000, "StretchRect texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2402 }
2403
2404 /* texture ==> texture, scaling (should fail) */
2405 if(surf_tex32 && surf_tex_dest64) {
2406 hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_dest64, NULL, 0);
2407 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2408 }
2409
2410 /*****************************************************************
2411 * Tests for when the source parameter is a rendertarget texture *
2412 *****************************************************************/
2413
2414 /* Fill the surface of the rendertarget texture with white */
2415 if (surf_tex_rt64 && surf_temp64) {
2416 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2417 fill_surface(surf_temp64, 0xffffffff);
2418 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex_rt64, NULL);
2419 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2420 }
2421
2422 /* rendertarget texture ==> offscreenplain, same size */
2423 if(surf_tex_rt64 && surf_offscreen64) {
2424 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_offscreen64, NULL, 0);
2425 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2426 }
2427
2428 /* rendertarget texture ==> rendertarget texture, same size */
2429 if(surf_tex_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2430 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2431 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2432
2433 /* We can't lock rendertarget textures, so copy to our temp surface first */
2434 if (hr == D3D_OK) {
2435 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2436 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2437 }
2438
2439 if (hr == D3D_OK) {
2440 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2441 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2442 }
2443 }
2444
2445 /* rendertarget texture ==> rendertarget surface, same size */
2446 if(surf_tex_rt64 && surf_rt_dest64) {
2447 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_rt_dest64, NULL, 0);
2448 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2449
2450 if (hr == D3D_OK) {
2451 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2452 ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2453 }
2454 }
2455
2456 /* rendertarget texture ==> texture, same size (should fail) */
2457 if(surf_tex_rt64 && surf_tex_dest64) {
2458 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_dest64, NULL, 0);
2459 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2460 }
2461
2462 /* Fill the surface of the smaller rendertarget texture with red */
2463 if (surf_tex_rt32 && surf_temp32) {
2464 /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2465 fill_surface(surf_temp32, 0xffff0000);
2466 hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex_rt32, NULL);
2467 ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2468 }
2469
2470 /* rendertarget texture ==> offscreenplain, scaling (should fail) */
2471 if(surf_tex_rt32 && surf_offscreen64) {
2472 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_offscreen64, NULL, 0);
2473 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2474 }
2475
2476 /* rendertarget texture ==> rendertarget texture, scaling */
2477 if(surf_tex_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2478 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2479 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2480
2481 /* We can't lock rendertarget textures, so copy to our temp surface first */
2482 if (hr == D3D_OK) {
2483 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2484 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2485 }
2486
2487 if (hr == D3D_OK) {
2488 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2489 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2490 }
2491 }
2492
2493 /* rendertarget texture ==> rendertarget surface, scaling */
2494 if(surf_tex_rt32 && surf_rt_dest64) {
2495 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_rt_dest64, NULL, 0);
2496 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2497
2498 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2499 ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2500 }
2501
2502 /* rendertarget texture ==> texture, scaling (should fail) */
2503 if(surf_tex_rt32 && surf_tex_dest64) {
2504 hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_dest64, NULL, 0);
2505 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2506 }
2507
2508 /*****************************************************************
2509 * Tests for when the source parameter is a rendertarget surface *
2510 *****************************************************************/
2511
2512 /* Fill the surface of the rendertarget surface with black */
2513 if (surf_rt64)
2514 fill_surface(surf_rt64, 0xff000000);
2515
2516 /* rendertarget texture ==> offscreenplain, same size */
2517 if(surf_rt64 && surf_offscreen64) {
2518 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_offscreen64, NULL, 0);
2519 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2520 }
2521
2522 /* rendertarget surface ==> rendertarget texture, same size */
2523 if(surf_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2524 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2525 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2526
2527 /* We can't lock rendertarget textures, so copy to our temp surface first */
2528 if (hr == D3D_OK) {
2529 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2530 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2531 }
2532
2533 if (hr == D3D_OK) {
2534 color = getPixelColorFromSurface(surf_temp64, 32, 32);
2535 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2536 }
2537 }
2538
2539 /* rendertarget surface ==> rendertarget surface, same size */
2540 if(surf_rt64 && surf_rt_dest64) {
2541 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_rt_dest64, NULL, 0);
2542 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2543
2544 if (hr == D3D_OK) {
2545 color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2546 ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2547 }
2548 }
2549
2550 /* rendertarget surface ==> texture, same size (should fail) */
2551 if(surf_rt64 && surf_tex_dest64) {
2552 hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_dest64, NULL, 0);
2553 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2554 }
2555
2556 /* Fill the surface of the smaller rendertarget texture with red */
2557 if (surf_rt32)
2558 fill_surface(surf_rt32, 0xffff0000);
2559
2560 /* rendertarget surface ==> offscreenplain, scaling (should fail) */
2561 if(surf_rt32 && surf_offscreen64) {
2562 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_offscreen64, NULL, 0);
2563 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2564 }
2565
2566 /* rendertarget surface ==> rendertarget texture, scaling */
2567 if(surf_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2568 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2569 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2570
2571 /* We can't lock rendertarget textures, so copy to our temp surface first */
2572 if (hr == D3D_OK) {
2573 hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2574 ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2575 }
2576
2577 if (hr == D3D_OK) {
2578 color = getPixelColorFromSurface(surf_temp64, 48, 48);
2579 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2580 }
2581 }
2582
2583 /* rendertarget surface ==> rendertarget surface, scaling */
2584 if(surf_rt32 && surf_rt_dest64) {
2585 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_rt_dest64, NULL, 0);
2586 ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2587
2588 color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2589 ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2590 }
2591
2592 /* rendertarget surface ==> texture, scaling (should fail) */
2593 if(surf_rt32 && surf_tex_dest64) {
2594 hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_dest64, NULL, 0);
2595 todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2596 }
2597
2598 /* TODO: Test when source and destination RECT parameters are given... */
2599 /* TODO: Test format conversions */
2600
2601
2602 out:
2603 /* Clean up */
2604 if (surf_rt32)
2605 IDirect3DSurface9_Release(surf_rt32);
2606 if (surf_rt64)
2607 IDirect3DSurface9_Release(surf_rt64);
2608 if (surf_rt_dest64)
2609 IDirect3DSurface9_Release(surf_rt_dest64);
2610 if (surf_temp32)
2611 IDirect3DSurface9_Release(surf_temp32);
2612 if (surf_temp64)
2613 IDirect3DSurface9_Release(surf_temp64);
2614 if (surf_offscreen32)
2615 IDirect3DSurface9_Release(surf_offscreen32);
2616 if (surf_offscreen64)
2617 IDirect3DSurface9_Release(surf_offscreen64);
2618 if (surf_offscreen_dest64)
2619 IDirect3DSurface9_Release(surf_offscreen_dest64);
2620
2621 if (tex_rt32) {
2622 if (surf_tex_rt32)
2623 IDirect3DSurface9_Release(surf_tex_rt32);
2624 IDirect3DTexture9_Release(tex_rt32);
2625 }
2626 if (tex_rt64) {
2627 if (surf_tex_rt64)
2628 IDirect3DSurface9_Release(surf_tex_rt64);
2629 IDirect3DTexture9_Release(tex_rt64);
2630 }
2631 if (tex_rt_dest64) {
2632 if (surf_tex_rt_dest64)
2633 IDirect3DSurface9_Release(surf_tex_rt_dest64);
2634 IDirect3DTexture9_Release(tex_rt_dest64);
2635 }
2636 if (tex32) {
2637 if (surf_tex32)
2638 IDirect3DSurface9_Release(surf_tex32);
2639 IDirect3DTexture9_Release(tex32);
2640 }
2641 if (tex64) {
2642 if (surf_tex64)
2643 IDirect3DSurface9_Release(surf_tex64);
2644 IDirect3DTexture9_Release(tex64);
2645 }
2646 if (tex_dest64) {
2647 if (surf_tex_dest64)
2648 IDirect3DSurface9_Release(surf_tex_dest64);
2649 IDirect3DTexture9_Release(tex_dest64);
2650 }
2651
2652 if (orig_rt) {
2653 hr = IDirect3DDevice9_SetRenderTarget(device, 0, orig_rt);
2654 ok(hr == D3D_OK, "IDirect3DSetRenderTarget failed with %08x\n", hr);
2655 IDirect3DSurface9_Release(orig_rt);
2656 }
2657 }
2658
2659 static void maxmip_test(IDirect3DDevice9 *device)
2660 {
2661 IDirect3DTexture9 *texture = NULL;
2662 IDirect3DSurface9 *surface = NULL;
2663 HRESULT hr;
2664 DWORD color;
2665 const float quads[] = {
2666 -1.0, -1.0, 0.0, 0.0, 0.0,
2667 -1.0, 0.0, 0.0, 0.0, 1.0,
2668 0.0, -1.0, 0.0, 1.0, 0.0,
2669 0.0, 0.0, 0.0, 1.0, 1.0,
2670
2671 0.0, -1.0, 0.0, 0.0, 0.0,
2672 0.0, 0.0, 0.0, 0.0, 1.0,
2673 1.0, -1.0, 0.0, 1.0, 0.0,
2674 1.0, 0.0, 0.0, 1.0, 1.0,
2675
2676 0.0, 0.0, 0.0, 0.0, 0.0,
2677 0.0, 1.0, 0.0, 0.0, 1.0,
2678 1.0, 0.0, 0.0, 1.0, 0.0,
2679 1.0, 1.0, 0.0, 1.0, 1.0,
2680
2681 -1.0, 0.0, 0.0, 0.0, 0.0,
2682 -1.0, 1.0, 0.0, 0.0, 1.0,
2683 0.0, 0.0, 0.0, 1.0, 0.0,
2684 0.0, 1.0, 0.0, 1.0, 1.0,
2685 };
2686
2687 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2688 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
2689
2690 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
2691 &texture, NULL);
2692 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2693 if(!texture)
2694 {
2695 skip("Failed to create test texture\n");
2696 return;
2697 }
2698
2699 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
2700 fill_surface(surface, 0xffff0000);
2701 IDirect3DSurface9_Release(surface);
2702 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 1, &surface);
2703 fill_surface(surface, 0xff00ff00);
2704 IDirect3DSurface9_Release(surface);
2705 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 2, &surface);
2706 fill_surface(surface, 0xff0000ff);
2707 IDirect3DSurface9_Release(surface);
2708
2709 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2710 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2711 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2712 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2713
2714 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2715 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2716
2717 hr = IDirect3DDevice9_BeginScene(device);
2718 if(SUCCEEDED(hr))
2719 {
2720 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2721 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2722 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2723 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2724
2725 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2726 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2727 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2728 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2729
2730 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2731 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2732 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2733 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2734
2735 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2736 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2737 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2738 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2739 hr = IDirect3DDevice9_EndScene(device);
2740 }
2741
2742 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2743 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2744 /* With mipmapping disabled, the max mip level is ignored, only level 0 is used */
2745 color = getPixelColor(device, 160, 360);
2746 ok(color == 0x00FF0000, "MapMip 0, no mipfilter has color %08x\n", color);
2747 color = getPixelColor(device, 160, 120);
2748 ok(color == 0x00FF0000, "MapMip 3, no mipfilter has color %08x\n", color);
2749 color = getPixelColor(device, 480, 120);
2750 ok(color == 0x00FF0000, "MapMip 2, no mipfilter has color %08x\n", color);
2751 color = getPixelColor(device, 480, 360);
2752 ok(color == 0x00FF0000, "MapMip 1, no mipfilter has color %08x\n", color);
2753
2754 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2755 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
2756
2757 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
2758 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2759
2760 hr = IDirect3DDevice9_BeginScene(device);
2761 if(SUCCEEDED(hr))
2762 {
2763 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2764 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2765 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2766 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2767
2768 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2769 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2770 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2771 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2772
2773 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2774 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2775 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2776 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2777
2778 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2779 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2780 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2781 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2782 hr = IDirect3DDevice9_EndScene(device);
2783 }
2784
2785 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2786 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2787 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2788 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2789
2790 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2791 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2792 /* Max Mip level 0-2 sample from the specified texture level, Max Mip level 3(> levels in texture)
2793 * samples from the highest level in the texture(level 2)
2794 */
2795 color = getPixelColor(device, 160, 360);
2796 ok(color == 0x00FF0000, "MapMip 0, point mipfilter has color %08x\n", color);
2797 color = getPixelColor(device, 160, 120);
2798 ok(color == 0x000000FF, "MapMip 3, point mipfilter has color %08x\n", color);
2799 color = getPixelColor(device, 480, 120);
2800 ok(color == 0x000000FF, "MapMip 2, point mipfilter has color %08x\n", color);
2801 color = getPixelColor(device, 480, 360);
2802 ok(color == 0x0000FF00, "MapMip 1, point mipfilter has color %08x\n", color);
2803
2804 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2805 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2806 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2807 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2808 IDirect3DTexture9_Release(texture);
2809 }
2810
2811 static void release_buffer_test(IDirect3DDevice9 *device)
2812 {
2813 IDirect3DVertexBuffer9 *vb = NULL;
2814 IDirect3DIndexBuffer9 *ib = NULL;
2815 HRESULT hr;
2816 BYTE *data;
2817 long ref;
2818
2819 static const struct vertex quad[] = {
2820 {-1.0, -1.0, 0.1, 0xffff0000},
2821 {-1.0, 1.0, 0.1, 0xffff0000},
2822 { 1.0, 1.0, 0.1, 0xffff0000},
2823
2824 {-1.0, -1.0, 0.1, 0xff00ff00},
2825 {-1.0, 1.0, 0.1, 0xff00ff00},
2826 { 1.0, 1.0, 0.1, 0xff00ff00}
2827 };
2828 short indices[] = {3, 4, 5};
2829
2830 /* Index and vertex buffers should always be creatable */
2831 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE,
2832 D3DPOOL_MANAGED, &vb, NULL);
2833 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
2834 if(!vb) {
2835 skip("Failed to create a vertex buffer\n");
2836 return;
2837 }
2838 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
2839 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %08x\n", hr);
2840 if(!ib) {
2841 skip("Failed to create an index buffer\n");
2842 return;
2843 }
2844
2845 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
2846 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
2847 memcpy(data, quad, sizeof(quad));
2848 hr = IDirect3DVertexBuffer9_Unlock(vb);
2849 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
2850
2851 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
2852 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %08x\n", hr);
2853 memcpy(data, indices, sizeof(indices));
2854 hr = IDirect3DIndexBuffer9_Unlock(ib);
2855 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2856
2857 hr = IDirect3DDevice9_SetIndices(device, ib);
2858 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
2859 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad[0]));
2860 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
2861 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
2862 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2863
2864 /* Now destroy the bound index buffer and draw again */
2865 ref = IDirect3DIndexBuffer9_Release(ib);
2866 ok(ref == 0, "Index Buffer reference count is %08ld\n", ref);
2867
2868 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
2869 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
2870
2871 hr = IDirect3DDevice9_BeginScene(device);
2872 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2873 if(SUCCEEDED(hr))
2874 {
2875 /* Deliberately using minvertexindex = 0 and numVertices = 6 to prevent d3d from
2876 * making assumptions about the indices or vertices
2877 */
2878 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 3, 3, 0, 1);
2879 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x\n", hr);
2880 hr = IDirect3DDevice9_EndScene(device);
2881 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2882 }
2883
2884 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2885 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2886
2887 hr = IDirect3DDevice9_SetIndices(device, NULL);
2888 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2889 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2890 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2891
2892 /* Index buffer was already destroyed as part of the test */
2893 IDirect3DVertexBuffer9_Release(vb);
2894 }
2895
2896 static void float_texture_test(IDirect3DDevice9 *device)
2897 {
2898 IDirect3D9 *d3d = NULL;
2899 HRESULT hr;
2900 IDirect3DTexture9 *texture = NULL;
2901 D3DLOCKED_RECT lr;
2902 float *data;
2903 DWORD color;
2904 float quad[] = {
2905 -1.0, -1.0, 0.1, 0.0, 0.0,
2906 -1.0, 1.0, 0.1, 0.0, 1.0,
2907 1.0, -1.0, 0.1, 1.0, 0.0,
2908 1.0, 1.0, 0.1, 1.0, 1.0,
2909 };
2910
2911 memset(&lr, 0, sizeof(lr));
2912 IDirect3DDevice9_GetDirect3D(device, &d3d);
2913 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2914 D3DRTYPE_TEXTURE, D3DFMT_R32F) != D3D_OK) {
2915 skip("D3DFMT_R32F textures not supported\n");
2916 goto out;
2917 }
2918
2919 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_R32F,
2920 D3DPOOL_MANAGED, &texture, NULL);
2921 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2922 if(!texture) {
2923 skip("Failed to create R32F texture\n");
2924 goto out;
2925 }
2926
2927 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2928 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
2929 data = lr.pBits;
2930 *data = 0.0;
2931 hr = IDirect3DTexture9_UnlockRect(texture, 0);
2932 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
2933
2934 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2935 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2936
2937 hr = IDirect3DDevice9_BeginScene(device);
2938 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2939 if(SUCCEEDED(hr))
2940 {
2941 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2942 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2943
2944 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2945 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2946
2947 hr = IDirect3DDevice9_EndScene(device);
2948 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2949 }
2950 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2951 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2952
2953 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2954 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2955
2956 color = getPixelColor(device, 240, 320);
2957 ok(color == 0x0000FFFF, "R32F with value 0.0 has color %08x, expected 0x0000FFFF\n", color);
2958
2959 out:
2960 if(texture) IDirect3DTexture9_Release(texture);
2961 IDirect3D9_Release(d3d);
2962 }
2963
2964 static void g16r16_texture_test(IDirect3DDevice9 *device)
2965 {
2966 IDirect3D9 *d3d = NULL;
2967 HRESULT hr;
2968 IDirect3DTexture9 *texture = NULL;
2969 D3DLOCKED_RECT lr;
2970 DWORD *data;
2971 DWORD color, red, green, blue;
2972 float quad[] = {
2973 -1.0, -1.0, 0.1, 0.0, 0.0,
2974 -1.0, 1.0, 0.1, 0.0, 1.0,
2975 1.0, -1.0, 0.1, 1.0, 0.0,
2976 1.0, 1.0, 0.1, 1.0, 1.0,
2977 };
2978
2979 memset(&lr, 0, sizeof(lr));
2980 IDirect3DDevice9_GetDirect3D(device, &d3d);
2981 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2982 D3DRTYPE_TEXTURE, D3DFMT_G16R16) != D3D_OK) {
2983 skip("D3DFMT_G16R16 textures not supported\n");
2984 goto out;
2985 }
2986
2987 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_G16R16,
2988 D3DPOOL_MANAGED, &texture, NULL);
2989 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2990 if(!texture) {
2991 skip("Failed to create D3DFMT_G16R16 texture\n");
2992 goto out;
2993 }
2994
2995 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2996 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
2997 data = lr.pBits;
2998 *data = 0x0f00f000;
2999 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3000 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
3001
3002 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3003 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3004
3005 hr = IDirect3DDevice9_BeginScene(device);
3006 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3007 if(SUCCEEDED(hr))
3008 {
3009 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3010 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3011
3012 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
3013 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3014
3015 hr = IDirect3DDevice9_EndScene(device);
3016 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3017 }
3018 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3019 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3020
3021 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3022 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3023
3024 color = getPixelColor(device, 240, 320);
3025 red = (color & 0x00ff0000) >> 16;
3026 green = (color & 0x0000ff00) >> 8;
3027 blue = (color & 0x000000ff) >> 0;
3028 ok(blue == 0xff && red >= 0xef && red <= 0xf1 && green >= 0x0e && green <= 0x10,
3029 "D3DFMT_G16R16 with value 0x00ffff00 has color %08x, expected 0x00F00FFF\n", color);
3030
3031 out:
3032 if(texture) IDirect3DTexture9_Release(texture);
3033 IDirect3D9_Release(d3d);
3034 }
3035
3036 static void texture_transform_flags_test(IDirect3DDevice9 *device)
3037 {
3038 HRESULT hr;
3039 IDirect3D9 *d3d;
3040 D3DFORMAT fmt = D3DFMT_X8R8G8B8;
3041 D3DCAPS9 caps;
3042 IDirect3DTexture9 *texture = NULL;
3043 IDirect3DVolumeTexture9 *volume = NULL;
3044 unsigned int x, y, z;
3045 D3DLOCKED_RECT lr;
3046 D3DLOCKED_BOX lb;
3047 DWORD color;
3048 UINT w, h;
3049 IDirect3DVertexDeclaration9 *decl, *decl2, *decl3;
3050 float identity[16] = {1.0, 0.0, 0.0, 0.0,
3051 0.0, 1.0, 0.0, 0.0,
3052 0.0, 0.0, 1.0, 0.0,
3053 0.0, 0.0, 0.0, 1.0};
3054 static const D3DVERTEXELEMENT9 decl_elements[] = {
3055 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3056 {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3057 D3DDECL_END()
3058 };
3059 static const D3DVERTEXELEMENT9 decl_elements2[] = {
3060 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3061 {0, 12, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3062 D3DDECL_END()
3063 };
3064 static const D3DVERTEXELEMENT9 decl_elements3[] = {
3065 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3066 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3067 D3DDECL_END()
3068 };
3069 static const unsigned char proj_texdata[] = {0x00, 0x00, 0x00, 0x00,
3070 0x00, 0xff, 0x00, 0x00,
3071 0x00, 0x00, 0x00, 0x00,
3072 0x00, 0x00, 0x00, 0x00};
3073
3074 memset(&lr, 0, sizeof(lr));
3075 memset(&lb, 0, sizeof(lb));
3076 IDirect3DDevice9_GetDirect3D(device, &d3d);
3077 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
3078 D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16) == D3D_OK) {
3079 fmt = D3DFMT_A16B16G16R16;
3080 }
3081 IDirect3D9_Release(d3d);
3082
3083 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
3084 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3085 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
3086 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3087 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements3, &decl3);
3088 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3089 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
3090 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_SRGBTEXTURE) returned %08x\n", hr);
3091 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
3092 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MAGFILTER) returned %08x\n", hr);
3093 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
3094 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MINFILTER) returned %08x\n", hr);
3095 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
3096 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MIPFILTER) returned %08x\n", hr);
3097 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
3098 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSU) returned %08x\n", hr);
3099 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
3100 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSV) returned %08x\n", hr);
3101 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
3102 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSW) returned %08x\n", hr);
3103 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
3104 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState(D3DRS_LIGHTING) returned %08x\n", hr);
3105 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3106 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3107
3108 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
3109 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %08x\n", hr);
3110 w = min(1024, caps.MaxTextureWidth);
3111 h = min(1024, caps.MaxTextureHeight);
3112 hr = IDirect3DDevice9_CreateTexture(device, w, h, 1,
3113 0, fmt, D3DPOOL_MANAGED, &texture, NULL);
3114 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
3115 if(!texture) {
3116 skip("Failed to create the test texture\n");
3117 return;
3118 }
3119
3120 /* Unfortunately there is no easy way to set up a texture coordinate passthrough
3121 * in d3d fixed function pipeline, so create a texture that has a gradient from 0.0 to
3122 * 1.0 in red and green for the x and y coords
3123 */
3124 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3125 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %08x\n", hr);
3126 for(y = 0; y < h; y++) {
3127 for(x = 0; x < w; x++) {
3128 double r_f = (double) y / (double) h;
3129 double g_f = (double) x / (double) w;
3130 if(fmt == D3DFMT_A16B16G16R16) {
3131 unsigned short r, g;
3132 unsigned short *dst = (unsigned short *) (((char *) lr.pBits) + y * lr.Pitch + x * 8);
3133 r = (unsigned short) (r_f * 65536.0);
3134 g = (unsigned short) (g_f * 65536.0);
3135 dst[0] = r;
3136 dst[1] = g;
3137 dst[2] = 0;
3138 dst[3] = 65535;
3139 } else {
3140 unsigned char *dst = ((unsigned char *) lr.pBits) + y * lr.Pitch + x * 4;
3141 unsigned char r = (unsigned char) (r_f * 255.0);
3142 unsigned char g = (unsigned char) (g_f * 255.0);
3143 dst[0] = 0;
3144 dst[1] = g;
3145 dst[2] = r;
3146 dst[3] = 255;
3147 }
3148 }
3149 }
3150 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3151 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %08x\n", hr);
3152 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3153 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
3154
3155 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3156 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3157 hr = IDirect3DDevice9_BeginScene(device);
3158 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3159 if(SUCCEEDED(hr))
3160 {
3161 float quad1[] = {
3162 -1.0, -1.0, 0.1, 1.0, 1.0,
3163 -1.0, 0.0, 0.1, 1.0, 1.0,
3164 0.0, -1.0, 0.1, 1.0, 1.0,
3165 0.0, 0.0, 0.1, 1.0, 1.0,
3166 };
3167 float quad2[] = {
3168 -1.0, 0.0, 0.1, 1.0, 1.0,
3169 -1.0, 1.0, 0.1, 1.0, 1.0,
3170 0.0, 0.0, 0.1, 1.0, 1.0,
3171 0.0, 1.0, 0.1, 1.0, 1.0,
3172 };
3173 float quad3[] = {
3174 0.0, 0.0, 0.1, 0.5, 0.5,
3175 0.0, 1.0, 0.1, 0.5, 0.5,
3176 1.0, 0.0, 0.1, 0.5, 0.5,
3177 1.0, 1.0, 0.1, 0.5, 0.5,
3178 };
3179 float quad4[] = {
3180 320, 480, 0.1, 1.0, 0.0, 1.0,
3181 320, 240, 0.1, 1.0, 0.0, 1.0,
3182 640, 480, 0.1, 1.0, 0.0, 1.0,
3183 640, 240, 0.1, 1.0, 0.0, 1.0,
3184 };
3185 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3186 0.0, 0.0, 0.0, 0.0,
3187 0.0, 0.0, 0.0, 0.0,
3188 0.0, 0.0, 0.0, 0.0};
3189
3190 /* What happens with the texture matrix if D3DTSS_TEXTURETRANSFORMFLAGS is disabled? */
3191 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3192 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3193 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3194 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3195
3196 /* What happens with transforms enabled? */
3197 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3198 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3199 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3200 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3201
3202 /* What happens if 4 coords are used, but only 2 given ?*/
3203 mat[8] = 1.0;
3204 mat[13] = 1.0;
3205 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3206 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3207 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3208 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3209 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3210 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3211
3212 /* What happens with transformed geometry? This setup lead to 0/0 coords with untransformed
3213 * geometry. If the same applies to transformed vertices, the quad will be black, otherwise red,
3214 * due to the coords in the vertices. (turns out red, indeed)
3215 */
3216 memset(mat, 0, sizeof(mat));
3217 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3218 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3219 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_TEX1);
3220 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3221 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3222 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3223 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3224 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3225
3226 hr = IDirect3DDevice9_EndScene(device);
3227 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3228 }
3229 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3230 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3231 color = getPixelColor(device, 160, 360);
3232 ok(color == 0x00FFFF00 || color == 0x00FEFE00, "quad 1 has color %08x, expected 0x00FFFF00\n", color);
3233 color = getPixelColor(device, 160, 120);
3234 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3235 color = getPixelColor(device, 480, 120);
3236 ok(color == 0x0000FF00 || color == 0x0000FE00, "quad 3 has color %08x, expected 0x0000FF00\n", color);
3237 color = getPixelColor(device, 480, 360);
3238 ok(color == 0x00FF0000 || 0x00FE0000, "quad 4 has color %08x, expected 0x00FF0000\n", color);
3239
3240 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3241 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3242
3243 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3244 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3245 hr = IDirect3DDevice9_BeginScene(device);
3246 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3247 if(SUCCEEDED(hr))
3248 {
3249 float quad1[] = {
3250 -1.0, -1.0, 0.1, 0.8, 0.2,
3251 -1.0, 0.0, 0.1, 0.8, 0.2,
3252 0.0, -1.0, 0.1, 0.8, 0.2,
3253 0.0, 0.0, 0.1, 0.8, 0.2,
3254 };
3255 float quad2[] = {
3256 -1.0, 0.0, 0.1, 0.5, 1.0,
3257 -1.0, 1.0, 0.1, 0.5, 1.0,
3258 0.0, 0.0, 0.1, 0.5, 1.0,
3259 0.0, 1.0, 0.1, 0.5, 1.0,
3260 };
3261 float quad3[] = {
3262 0.0, 0.0, 0.1, 0.5, 1.0,
3263 0.0, 1.0, 0.1, 0.5, 1.0,
3264 1.0, 0.0, 0.1, 0.5, 1.0,
3265 1.0, 1.0, 0.1, 0.5, 1.0,
3266 };
3267 float quad4[] = {
3268 0.0, -1.0, 0.1, 0.8, 0.2,
3269 0.0, 0.0, 0.1, 0.8, 0.2,
3270 1.0, -1.0, 0.1, 0.8, 0.2,
3271 1.0, 0.0, 0.1, 0.8, 0.2,
3272 };
3273 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3274 0.0, 0.0, 0.0, 0.0,
3275 0.0, 1.0, 0.0, 0.0,
3276 0.0, 0.0, 0.0, 0.0};
3277
3278 /* What happens to the default 1 in the 3rd coordinate if it is disabled?
3279 */
3280 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3281 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3282 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3283 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3284
3285 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3286 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3287
3288 /* D3DTFF_COUNT1 does not work on Nvidia drivers. It behaves like D3DTTFF_DISABLE. On ATI drivers
3289 * it behaves like COUNT2 because normal textures require 2 coords
3290 */
3291 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3292 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3293 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 5 * sizeof(float));
3294 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3295
3296 /* Just to be sure, the same as quad2 above */
3297 memset(mat, 0, sizeof(mat));
3298 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3299 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3300 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3301 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3302 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3303 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3304
3305 /* Now, what happens to the 2nd coordinate(that is disabled in the matrix) if it is not
3306 * used? And what happens to the first?
3307 */
3308 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3309 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3310 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3311 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3312
3313 hr = IDirect3DDevice9_EndScene(device);
3314 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3315 }
3316 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3317 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3318 color = getPixelColor(device, 160, 360);
3319 ok(color == 0x00FF0000 || color == 0x00FE0000, "quad 1 has color %08x, expected 0x00FF0000\n", color);
3320 color = getPixelColor(device, 160, 120);
3321 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3322 color = getPixelColor(device, 480, 120);
3323 ok(color == 0x00ff8000 || color == 0x00fe7f00 || color == 0x00000000,
3324 "quad 3 has color %08x, expected 0x00ff8000\n", color);
3325 color = getPixelColor(device, 480, 360);
3326 ok(color == 0x0033cc00 || color == 0x0032cb00 || color == 0x00FF0000 || color == 0x00FE0000,
3327 "quad 4 has color %08x, expected 0x0033cc00\n", color);
3328
3329 IDirect3DTexture9_Release(texture);
3330
3331 /* Test projected textures, without any fancy matrices */
3332 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3333 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3334 hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 1, 0, D3DFMT_L8, D3DPOOL_MANAGED, &texture, NULL);
3335 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
3336 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3337 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3338 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl3);
3339 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3340
3341 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3342 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
3343 for(x = 0; x < 4; x++) {
3344 memcpy(((BYTE *) lr.pBits) + lr.Pitch * x, proj_texdata + 4 * x, 4 * sizeof(proj_texdata[0]));
3345 }
3346 hr = IDirect3DTexture9_UnlockRect(texture, 0);
3347 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
3348 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3349 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3350
3351 hr = IDirect3DDevice9_BeginScene(device);
3352 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3353 if(SUCCEEDED(hr))
3354 {
3355 const float proj_quads[] = {
3356 -1.0, -1.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3357 1.0, -1.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3358 -1.0, 0.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3359 1.0, 0.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3360 -1.0, 0.0, 0.1, 0.0, 0.0, 4.0, 6.0,
3361 1.0, 0.0, 0.1, 4.0, 0.0, 4.0, 6.0,
3362 -1.0, 1.0, 0.1, 0.0, 4.0, 4.0, 6.0,
3363 1.0, 1.0, 0.1, 4.0, 4.0, 4.0, 6.0,
3364 };
3365
3366 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);
3367 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3368 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[0*7], 7 * sizeof(float));
3369 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3370
3371 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED);
3372 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3373 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[4*7], 7 * sizeof(float));
3374 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3375
3376 hr = IDirect3DDevice9_EndScene(device);
3377 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3378 }
3379
3380 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3381 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3382 IDirect3DTexture9_Release(texture);
3383
3384 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3385 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3386 color = getPixelColor(device, 158, 118);
3387 ok(color == 0x00000000, "proj: Pixel 158/118 has color 0x%08x, expected 0x00000000\n", color);
3388 color = getPixelColor(device, 162, 118);
3389 ok(color == 0x00000000, "proj: Pixel 162/118 has color 0x%08x, expected 0x00000000\n", color);
3390 color = getPixelColor(device, 158, 122);
3391 ok(color == 0x00000000, "proj: Pixel 158/122 has color 0x%08x, expected 0x00000000\n", color);
3392 color = getPixelColor(device, 162, 122);
3393 ok(color == 0x00FFFFFF, "proj: Pixel 162/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3394
3395 color = getPixelColor(device, 158, 178);
3396 ok(color == 0x00000000, "proj: Pixel 158/178 has color 0x%08x, expected 0x00000000\n", color);
3397 color = getPixelColor(device, 162, 178);
3398 ok(color == 0x00FFFFFF, "proj: Pixel 158/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3399 color = getPixelColor(device, 158, 182);
3400 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3401 color = getPixelColor(device, 162, 182);
3402 ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3403
3404 color = getPixelColor(device, 318, 118);
3405 ok(color == 0x00000000, "proj: Pixel 318/118 has color 0x%08x, expected 0x00000000\n", color);
3406 color = getPixelColor(device, 322, 118);
3407 ok(color == 0x00000000, "proj: Pixel 322/118 has color 0x%08x, expected 0x00000000\n", color);
3408 color = getPixelColor(device, 318, 122);
3409 ok(color == 0x00FFFFFF, "proj: Pixel 318/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3410 color = getPixelColor(device, 322, 122);
3411 ok(color == 0x00000000, "proj: Pixel 322/122 has color 0x%08x, expected 0x00000000\n", color);
3412
3413 color = getPixelColor(device, 318, 178);
3414 ok(color == 0x00FFFFFF, "proj: Pixel 318/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3415 color = getPixelColor(device, 322, 178);
3416 ok(color == 0x00000000, "proj: Pixel 322/178 has color 0x%08x, expected 0x00000000\n", color);
3417 color = getPixelColor(device, 318, 182);
3418 ok(color == 0x00000000, "proj: Pixel 318/182 has color 0x%08x, expected 0x00000000\n", color);
3419 color = getPixelColor(device, 322, 182);
3420 ok(color == 0x00000000, "proj: Pixel 322/182 has color 0x%08x, expected 0x00000000\n", color);
3421
3422 color = getPixelColor(device, 238, 298);
3423 ok(color == 0x00000000, "proj: Pixel 238/298 has color 0x%08x, expected 0x00000000\n", color);
3424 color = getPixelColor(device, 242, 298);
3425 ok(color == 0x00000000, "proj: Pixel 242/298 has color 0x%08x, expected 0x00000000\n", color);
3426 color = getPixelColor(device, 238, 302);
3427 ok(color == 0x00000000, "proj: Pixel 238/302 has color 0x%08x, expected 0x00000000\n", color);
3428 color = getPixelColor(device, 242, 302);
3429 ok(color == 0x00FFFFFF, "proj: Pixel 242/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3430
3431 color = getPixelColor(device, 238, 388);
3432 ok(color == 0x00000000, "proj: Pixel 238/388 has color 0x%08x, expected 0x00000000\n", color);
3433 color = getPixelColor(device, 242, 388);
3434 ok(color == 0x00FFFFFF, "proj: Pixel 242/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3435 color = getPixelColor(device, 238, 392);
3436 ok(color == 0x00000000, "proj: Pixel 238/392 has color 0x%08x, expected 0x00000000\n", color);
3437 color = getPixelColor(device, 242, 392);
3438 ok(color == 0x00000000, "proj: Pixel 242/392 has color 0x%08x, expected 0x00000000\n", color);
3439
3440 color = getPixelColor(device, 478, 298);
3441 ok(color == 0x00000000, "proj: Pixel 478/298 has color 0x%08x, expected 0x00000000\n", color);
3442 color = getPixelColor(device, 482, 298);
3443 ok(color == 0x00000000, "proj: Pixel 482/298 has color 0x%08x, expected 0x00000000\n", color);
3444 color = getPixelColor(device, 478, 302);
3445 ok(color == 0x00FFFFFF, "proj: Pixel 478/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3446 color = getPixelColor(device, 482, 302);
3447 ok(color == 0x00000000, "proj: Pixel 482/302 has color 0x%08x, expected 0x00000000\n", color);
3448
3449 color = getPixelColor(device, 478, 388);
3450 ok(color == 0x00FFFFFF, "proj: Pixel 478/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3451 color = getPixelColor(device, 482, 388);
3452 ok(color == 0x00000000, "proj: Pixel 482/388 has color 0x%08x, expected 0x00000000\n", color);
3453 color = getPixelColor(device, 478, 392);
3454 ok(color == 0x00000000, "proj: Pixel 478/392 has color 0x%08x, expected 0x00000000\n", color);
3455 color = getPixelColor(device, 482, 392);
3456 ok(color == 0x00000000, "proj: Pixel 482/392 has color 0x%08x, expected 0x00000000\n", color);
3457
3458 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3459 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3460 /* Use a smaller volume texture than the biggest possible size for memory and performance reasons
3461 * Thus watch out if sampling from texels between 0 and 1.
3462 */
3463 hr = IDirect3DDevice9_CreateVolumeTexture(device, 32, 32, 32, 1, 0, fmt, D3DPOOL_MANAGED, &volume, 0);
3464 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
3465 "IDirect3DDevice9_CreateVolumeTexture failed with %08x\n", hr);
3466 if(!volume) {
3467 skip("Failed to create a volume texture\n");
3468 goto out;
3469 }
3470
3471 hr = IDirect3DVolumeTexture9_LockBox(volume, 0, &lb, NULL, 0);
3472 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_LockBox failed with %08x\n", hr);
3473 for(z = 0; z < 32; z++) {
3474 for(y = 0; y < 32; y++) {
3475 for(x = 0; x < 32; x++) {
3476 char size = (fmt == D3DFMT_A16B16G16R16 ? 8 : 4);
3477 void *mem = ((char *) lb.pBits) + y * lb.RowPitch + z * lb.SlicePitch + x * size;
3478 float r_f = (float) x / 31.0;
3479 float g_f = (float) y / 31.0;
3480 float b_f = (float) z / 31.0;
3481
3482 if(fmt == D3DFMT_A16B16G16R16) {
3483 unsigned short *mem_s = mem;
3484 mem_s[0] = r_f * 65535.0;
3485 mem_s[1] = g_f * 65535.0;
3486 mem_s[2] = b_f * 65535.0;
3487 mem_s[3] = 65535;
3488 } else {
3489 unsigned char *mem_c = mem;
3490 mem_c[0] = b_f * 255.0;
3491 mem_c[1] = g_f * 255.0;
3492 mem_c[2] = r_f * 255.0;
3493 mem_c[3] = 255;
3494 }
3495 }
3496 }
3497 }
3498 hr = IDirect3DVolumeTexture9_UnlockBox(volume, 0);
3499 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %08x\n", hr);
3500
3501 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) volume);
3502 ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %08x\n", hr);
3503
3504 hr = IDirect3DDevice9_BeginScene(device);
3505 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3506 if(SUCCEEDED(hr))
3507 {
3508 float quad1[] = {
3509 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3510 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3511 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3512 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3513 };
3514 float quad2[] = {
3515 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3516 -1.0, 1.0, 0.1, 1.0, 1.0, 1.0,
3517 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3518 0.0, 1.0, 0.1, 1.0, 1.0, 1.0
3519 };
3520 float quad3[] = {
3521 0.0, 0.0, 0.1, 0.0, 0.0,
3522 0.0, 1.0, 0.1, 0.0, 0.0,
3523 1.0, 0.0, 0.1, 0.0, 0.0,
3524 1.0, 1.0, 0.1, 0.0, 0.0
3525 };
3526 float quad4[] = {
3527 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3528 0.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3529 1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3530 1.0, 0.0, 0.1, 1.0, 1.0, 1.0
3531 };
3532 float mat[16] = {1.0, 0.0, 0.0, 0.0,
3533 0.0, 0.0, 1.0, 0.0,
3534 0.0, 1.0, 0.0, 0.0,
3535 0.0, 0.0, 0.0, 1.0};
3536 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3537 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3538
3539 /* Draw a quad with all 3 coords enabled. Nothing fancy. v and w are swapped, but have the same
3540 * values
3541 */
3542 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3543 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3544 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3);
3545 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3546 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3547 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3548
3549 /* Now disable the w coordinate. Does that change the input, or the output. The coordinates
3550 * are swapped by the matrix. If it changes the input, the v coord will be missing(green),
3551 * otherwise the w will be missing(blue).
3552 * turns out that on nvidia cards the blue color is missing, so it is an output modification.
3553 * On ATI cards the COUNT2 is ignored, and it behaves in the same way as COUNT3.
3554 */
3555 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3556 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3557 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
3558 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3559
3560 /* default values? Set up the identity matrix, pass in 2 vertex coords, and enable 4 */
3561 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3562 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3563 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3564 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3565 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3566 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3567 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3568 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3569
3570 /* D3DTTFF_COUNT1. Set a NULL matrix, and count1, pass in all values as 1.0. Nvidia has count1 ==
3571 * disable. ATI extends it up to the amount of values needed for the volume texture
3572 */
3573 memset(mat, 0, sizeof(mat));
3574 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3575 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3576 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3577 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3578 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3579 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3580 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3581 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3582
3583 hr = IDirect3DDevice9_EndScene(device);
3584 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3585 }
3586 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3587 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3588
3589 color = getPixelColor(device, 160, 360);
3590 ok(color == 0x00ffffff, "quad 1 has color %08x, expected 0x00ffffff\n", color);
3591 color = getPixelColor(device, 160, 120);
3592 ok(color == 0x00ffff00 /* NV*/ || color == 0x00ffffff /* ATI */,
3593 "quad 2 has color %08x, expected 0x00ffff00\n", color);
3594 color = getPixelColor(device, 480, 120);
3595 ok(color == 0x000000ff, "quad 3 has color %08x, expected 0x000000ff\n", color);
3596 color = getPixelColor(device, 480, 360);
3597 ok(color == 0x00ffffff || color == 0x0000ff00, "quad 4 has color %08x, expected 0x00ffffff\n", color);
3598
3599 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff303030, 0.0, 0);
3600 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3601 hr = IDirect3DDevice9_BeginScene(device);
3602 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3603 if(SUCCEEDED(hr))
3604 {
3605 float quad1[] = {
3606 -1.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3607 -1.0, 0.0, 0.1, 1.0, 1.0, 1.0,
3608 0.0, -1.0, 0.1, 1.0, 1.0, 1.0,
3609 0.0, 0.0, 0.1, 1.0, 1.0, 1.0
3610 };
3611 float quad2[] = {
3612 -1.0, 0.0, 0.1,
3613 -1.0, 1.0, 0.1,
3614 0.0, 0.0, 0.1,
3615 0.0, 1.0, 0.1,
3616 };
3617 float quad3[] = {
3618 0.0, 0.0, 0.1, 1.0,
3619 0.0, 1.0, 0.1, 1.0,
3620 1.0, 0.0, 0.1, 1.0,
3621 1.0, 1.0, 0.1, 1.0
3622 };
3623 float mat[16] = {0.0, 0.0, 0.0, 0.0,
3624 0.0, 0.0, 0.0, 0.0,
3625 0.0, 0.0, 0.0, 0.0,
3626 0.0, 1.0, 0.0, 0.0};
3627 float mat2[16] = {0.0, 0.0, 0.0, 1.0,
3628 1.0, 0.0, 0.0, 0.0,
3629 0.0, 1.0, 0.0, 0.0,
3630 0.0, 0.0, 1.0, 0.0};
3631 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3632 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3633
3634 /* Default values? 4 coords used, 3 passed. What happens to the 4th?
3635 */
3636 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3637 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3638 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3639 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3640 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3641 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3642
3643 /* None passed */
3644 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3645 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3646 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3647 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3648 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
3649 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3650
3651 /* 4 used, 1 passed */
3652 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
3653 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3654 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat2);
3655 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3656 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 4 * sizeof(float));
3657 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3658
3659 hr = IDirect3DDevice9_EndScene(device);
3660 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3661 }
3662 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3663 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3664 color = getPixelColor(device, 160, 360);
3665 ok(color == 0x0000ff00, "quad 1 has color %08x, expected 0x0000ff00\n", color);
3666 color = getPixelColor(device, 160, 120);
3667 ok(color == 0x00000000, "quad 2 has color %08x, expected 0x00000000\n", color);
3668 color = getPixelColor(device, 480, 120);
3669 ok(color == 0x00ff0000, "quad 3 has color %08x, expected 0x00ff0000\n", color);
3670 /* Quad4: unused */
3671
3672 IDirect3DVolumeTexture9_Release(volume);
3673
3674 out:
3675 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
3676 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3677 IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
3678 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3679 hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3680 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3681 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3682 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
3683 IDirect3DVertexDeclaration9_Release(decl);
3684 IDirect3DVertexDeclaration9_Release(decl2);
3685 IDirect3DVertexDeclaration9_Release(decl3);
3686 }
3687
3688 static void texdepth_test(IDirect3DDevice9 *device)
3689 {
3690 IDirect3DPixelShader9 *shader;
3691 HRESULT hr;
3692 const float texdepth_test_data1[] = { 0.25, 2.0, 0.0, 0.0};
3693 const float texdepth_test_data2[] = { 0.25, 0.5, 0.0, 0.0};
3694 const float texdepth_test_data3[] = {-1.00, 0.1, 0.0, 0.0};
3695 const float texdepth_test_data4[] = {-0.25, -0.5, 0.0, 0.0};
3696 const float texdepth_test_data5[] = { 1.00, -0.1, 0.0, 0.0};
3697 const float texdepth_test_data6[] = { 1.00, 0.5, 0.0, 0.0};
3698 const float texdepth_test_data7[] = { 0.50, 0.0, 0.0, 0.0};
3699 DWORD shader_code[] = {
3700 0xffff0104, /* ps_1_4 */
3701 0x00000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c1, 0, 0, 1, 1 */
3702 0x00000001, 0x800f0005, 0xa0e40000, /* mov r5, c0 */
3703 0x0000fffd, /* phase */
3704 0x00000057, 0x800f0005, /* texdepth r5 */
3705 0x00000001, 0x800f0000, 0xa0e40001, /* mov r0, c1 */
3706 0x0000ffff /* end */
3707 };
3708 DWORD color;
3709 float vertex[] = {
3710 -1.0, -1.0, 0.0,
3711 1.0, -1.0, 1.0,
3712 -1.0, 1.0, 0.0,
3713 1.0, 1.0, 1.0
3714 };
3715
3716 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
3717 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3718
3719 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffff00, 0.0, 0);
3720 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3721 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
3722 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3723 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3724 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3725 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_ALWAYS);
3726 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3727 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3728
3729 /* Fill the depth buffer with a gradient */
3730 hr = IDirect3DDevice9_BeginScene(device);
3731 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3732 if(SUCCEEDED(hr))
3733 {
3734 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3735 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3736 hr = IDirect3DDevice9_EndScene(device);
3737 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3738 }
3739
3740 /* Now perform the actual tests. Same geometry, but with the shader */
3741 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
3742 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3743 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
3744 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3745 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3746 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3747
3748 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data1, 1);
3749 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3750 hr = IDirect3DDevice9_BeginScene(device);
3751 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3752 if(SUCCEEDED(hr))
3753 {
3754 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3755 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3756
3757 hr = IDirect3DDevice9_EndScene(device);
3758 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3759 }
3760
3761 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3762 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3763 color = getPixelColor(device, 158, 240);
3764 ok(color == 0x000000ff, "Pixel 158(25%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3765 color = getPixelColor(device, 162, 240);
3766 ok(color == 0x00ffffff, "Pixel 158(25%% + 2 pixel) has color %08x, expected 0x00ffffff\n", color);
3767
3768 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3769
3770 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data2, 1);
3771 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3772 hr = IDirect3DDevice9_BeginScene(device);
3773 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3774 if(SUCCEEDED(hr))
3775 {
3776 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3777 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3778
3779 hr = IDirect3DDevice9_EndScene(device);
3780 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3781 }
3782
3783 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3784 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3785 color = getPixelColor(device, 318, 240);
3786 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3787 color = getPixelColor(device, 322, 240);
3788 ok(color == 0x00ffff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3789
3790 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3791
3792 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data3, 1);
3793 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3794 hr = IDirect3DDevice9_BeginScene(device);
3795 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3796 if(SUCCEEDED(hr))
3797 {
3798 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3799 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3800
3801 hr = IDirect3DDevice9_EndScene(device);
3802 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3803 }
3804 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3805 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3806
3807 color = getPixelColor(device, 1, 240);
3808 ok(color == 0x00ff0000, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ff0000\n", color);
3809
3810 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3811
3812 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data4, 1);
3813 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3814 hr = IDirect3DDevice9_BeginScene(device);
3815 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3816 if(SUCCEEDED(hr))
3817 {
3818 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3819 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3820
3821 hr = IDirect3DDevice9_EndScene(device);
3822 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3823 }
3824 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3825 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3826 color = getPixelColor(device, 318, 240);
3827 ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3828 color = getPixelColor(device, 322, 240);
3829 ok(color == 0x0000ff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x0000ff00\n", color);
3830
3831 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3832
3833 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data5, 1);
3834 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3835 hr = IDirect3DDevice9_BeginScene(device);
3836 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3837 if(SUCCEEDED(hr))
3838 {
3839 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3840 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3841
3842 hr = IDirect3DDevice9_EndScene(device);
3843 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3844 }
3845 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3846 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3847
3848 color = getPixelColor(device, 1, 240);
3849 ok(color == 0x00ffff00, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3850
3851 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3852
3853 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data6, 1);
3854 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3855 hr = IDirect3DDevice9_BeginScene(device);
3856 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3857 if(SUCCEEDED(hr))
3858 {
3859 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3860 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3861
3862 hr = IDirect3DDevice9_EndScene(device);
3863 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3864 }
3865 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3866 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3867
3868 color = getPixelColor(device, 638, 240);
3869 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3870
3871 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3872
3873 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data7, 1);
3874 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3875 hr = IDirect3DDevice9_BeginScene(device);
3876 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3877 if(SUCCEEDED(hr))
3878 {
3879 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3880 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3881
3882 hr = IDirect3DDevice9_EndScene(device);
3883 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3884 }
3885 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3886 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3887
3888 color = getPixelColor(device, 638, 240);
3889 ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3890
3891 /* Cleanup */
3892 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3893 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3894 IDirect3DPixelShader9_Release(shader);
3895
3896 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
3897 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3898 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3899 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3900 }
3901
3902 static void texkill_test(IDirect3DDevice9 *device)
3903 {
3904 IDirect3DPixelShader9 *shader;
3905 HRESULT hr;
3906 DWORD color;
3907
3908 const float vertex[] = {
3909 /* bottom top right left */
3910 -1.0, -1.0, 1.0, -0.1, 0.9, 0.9, -0.1,
3911 1.0, -1.0, 0.0, 0.9, -0.1, 0.9, -0.1,
3912 -1.0, 1.0, 1.0, -0.1, 0.9, -0.1, 0.9,
3913 1.0, 1.0, 0.0, 0.9, -0.1, -0.1, 0.9,
3914 };
3915
3916 DWORD shader_code_11[] = {
3917 0xffff0101, /* ps_1_1 */
3918 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
3919 0x00000041, 0xb00f0000, /* texkill t0 */
3920 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
3921 0x0000ffff /* end */
3922 };
3923 DWORD shader_code_20[] = {
3924 0xffff0200, /* ps_2_0 */
3925 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
3926 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c0, 0.0, 0.0, 1.0, 1.0 */
3927 0x01000041, 0xb00f0000, /* texkill t0 */
3928 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
3929 0x0000ffff /* end */
3930 };
3931
3932 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3933 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3934 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader);
3935 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3936
3937 hr = IDirect3DDevice9_SetPixelShader(device, shader);
3938 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
3939 hr = IDirect3DDevice9_BeginScene(device);
3940 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3941 if(SUCCEEDED(hr))
3942 {
3943 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE4(0) | D3DFVF_TEX1);
3944 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
3945 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3946 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3947 hr = IDirect3DDevice9_EndScene(device);
3948 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3949 }
3950 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3951 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3952 color = getPixelColor(device, 63, 46);
3953 ok(color == 0x0000ff00, "Pixel 63/46 has color %08x, expected 0x0000ff00\n", color);
3954 color = getPixelColor(device, 66, 46);
3955 ok(color == 0x0000ff00, "Pixel 66/64 has color %08x, expected 0x0000ff00\n", color);
3956 color = getPixelColor(device, 63, 49);
3957 ok(color == 0x0000ff00, "Pixel 63/49 has color %08x, expected 0x0000ff00\n", color);
3958 color = getPixelColor(device, 66, 49);
3959 ok(color == 0x00ff0000, "Pixel 66/49 has color %08x, expected 0x00ff0000\n", color);
3960
3961 color = getPixelColor(device, 578, 46);
3962 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3963 color = getPixelColor(device, 575, 46);
3964 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3965 color = getPixelColor(device, 578, 49);
3966 ok(color == 0x0000ff00, "Pixel 578/49 has color %08x, expected 0x0000ff00\n", color);
3967 color = getPixelColor(device, 575, 49);
3968 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3969
3970 color = getPixelColor(device, 63, 430);
3971 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3972 color = getPixelColor(device, 63, 433);
3973 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3974 color = getPixelColor(device, 66, 433);
3975 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3976 color = getPixelColor(device, 66, 430);
3977 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3978
3979 color = getPixelColor(device, 578, 430);
3980 ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3981 color = getPixelColor(device, 578, 433);
3982 ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3983 color = getPixelColor(device, 575, 433);
3984 ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3985 color = getPixelColor(device, 575, 430);
3986 ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3987
3988 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3989 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
3990 IDirect3DPixelShader9_Release(shader);
3991
3992 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3993 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3994 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader);
3995 if(FAILED(hr)) {
3996 skip("Failed to create 2.0 test shader, most likely not supported\n");
3997 return;
3998 }
3999
4000 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4001 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4002 hr = IDirect3DDevice9_BeginScene(device);
4003 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4004 if(SUCCEEDED(hr))
4005 {
4006 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
4007 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4008 hr = IDirect3DDevice9_EndScene(device);
4009 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4010 }
4011 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4012
4013 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4014 color = getPixelColor(device, 63, 46);
4015 ok(color == 0x00ffff00, "Pixel 63/46 has color %08x, expected 0x00ffff00\n", color);
4016 color = getPixelColor(device, 66, 46);
4017 ok(color == 0x00ffff00, "Pixel 66/64 has color %08x, expected 0x00ffff00\n", color);
4018 color = getPixelColor(device, 63, 49);
4019 ok(color == 0x00ffff00, "Pixel 63/49 has color %08x, expected 0x00ffff00\n", color);
4020 color = getPixelColor(device, 66, 49);
4021 ok(color == 0x000000ff, "Pixel 66/49 has color %08x, expected 0x000000ff\n", color);
4022
4023 color = getPixelColor(device, 578, 46);
4024 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4025 color = getPixelColor(device, 575, 46);
4026 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4027 color = getPixelColor(device, 578, 49);
4028 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4029 color = getPixelColor(device, 575, 49);
4030 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4031
4032 color = getPixelColor(device, 63, 430);
4033 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4034 color = getPixelColor(device, 63, 433);
4035 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4036 color = getPixelColor(device, 66, 433);
4037 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4038 color = getPixelColor(device, 66, 430);
4039 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4040
4041 color = getPixelColor(device, 578, 430);
4042 ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4043 color = getPixelColor(device, 578, 433);
4044 ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4045 color = getPixelColor(device, 575, 433);
4046 ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4047 color = getPixelColor(device, 575, 430);
4048 ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4049
4050 /* Cleanup */
4051 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4052 ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
4053 IDirect3DPixelShader9_Release(shader);
4054 }
4055
4056 static void x8l8v8u8_test(IDirect3DDevice9 *device)
4057 {
4058 IDirect3D9 *d3d9;
4059 HRESULT hr;
4060 IDirect3DTexture9 *texture;
4061 IDirect3DPixelShader9 *shader;
4062 IDirect3DPixelShader9 *shader2;
4063 D3DLOCKED_RECT lr;
4064 DWORD color;
4065 DWORD shader_code[] = {
4066 0xffff0101, /* ps_1_1 */
4067 0x00000042, 0xb00f0000, /* tex t0 */
4068 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4069 0x0000ffff /* end */
4070 };
4071 DWORD shader_code2[] = {
4072 0xffff0101, /* ps_1_1 */
4073 0x00000042, 0xb00f0000, /* tex t0 */
4074 0x00000001, 0x800f0000, 0xb0ff0000, /* mov r0, t0.w */
4075 0x0000ffff /* end */
4076 };
4077
4078 float quad[] = {
4079 -1.0, -1.0, 0.1, 0.5, 0.5,
4080 1.0, -1.0, 0.1, 0.5, 0.5,
4081 -1.0, 1.0, 0.1, 0.5, 0.5,
4082 1.0, 1.0, 0.1, 0.5, 0.5,
4083 };
4084
4085 memset(&lr, 0, sizeof(lr));
4086 IDirect3DDevice9_GetDirect3D(device, &d3d9);
4087 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4088 0, D3DRTYPE_TEXTURE, D3DFMT_X8L8V8U8);
4089 IDirect3D9_Release(d3d9);
4090 if(FAILED(hr)) {
4091 skip("No D3DFMT_X8L8V8U8 support\n");
4092 };
4093
4094 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
4095 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4096
4097 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8L8V8U8, D3DPOOL_MANAGED, &texture, NULL);
4098 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed (%08x)\n", hr);
4099 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
4100 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed (%08x)\n", hr);
4101 *((DWORD *) lr.pBits) = 0x11ca3141;
4102 hr = IDirect3DTexture9_UnlockRect(texture, 0);
4103 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed (%08x)\n", hr);
4104
4105 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4106 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4107 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code2, &shader2);
4108 ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4109
4110 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4111 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
4112 hr = IDirect3DDevice9_SetPixelShader(device, shader);
4113 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4114 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4115 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4116
4117 hr = IDirect3DDevice9_BeginScene(device);
4118 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4119 if(SUCCEEDED(hr))
4120 {
4121 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4122 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4123
4124 hr = IDirect3DDevice9_EndScene(device);
4125 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4126 }
4127 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4128 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4129 color = getPixelColor(device, 578, 430);
4130 ok(color == 0x008262ca || color == 0x008363ca || color == 0x008362ca,
4131 "D3DFMT_X8L8V8U8 = 0x112131ca returns color %08x, expected 0x008262ca\n", color);
4132
4133 hr = IDirect3DDevice9_SetPixelShader(device, shader2);
4134 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4135 hr = IDirect3DDevice9_BeginScene(device);
4136 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4137 if(SUCCEEDED(hr))
4138 {
4139 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4140 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4141
4142 hr = IDirect3DDevice9_EndScene(device);
4143 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4144 }
4145 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4146 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4147 color = getPixelColor(device, 578, 430);
4148 ok(color == 0x00ffffff, "w component of D3DFMT_X8L8V8U8 = 0x11ca3141 returns color %08x\n", color);
4149
4150 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4151 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4152 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4153 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4154 IDirect3DPixelShader9_Release(shader);
4155 IDirect3DPixelShader9_Release(shader2);
4156 IDirect3DTexture9_Release(texture);
4157 }
4158
4159 static void autogen_mipmap_test(IDirect3DDevice9 *device)
4160 {
4161 HRESULT hr;
4162 IDirect3D9 *d3d;
4163 IDirect3DTexture9 *texture = NULL;
4164 IDirect3DSurface9 *surface;
4165 DWORD color;
4166 const RECT r1 = {256, 256, 512, 512};
4167 const RECT r2 = {512, 256, 768, 512};
4168 const RECT r3 = {256, 512, 512, 768};
4169 const RECT r4 = {512, 512, 768, 768};
4170 unsigned int x, y;
4171 D3DLOCKED_RECT lr;
4172 memset(&lr, 0, sizeof(lr));
4173
4174 IDirect3DDevice9_GetDirect3D(device, &d3d);
4175 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4176 D3DUSAGE_AUTOGENMIPMAP, D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8) != D3D_OK) {
4177 skip("No autogenmipmap support\n");
4178 IDirect3D9_Release(d3d);
4179 return;
4180 }
4181 IDirect3D9_Release(d3d);
4182
4183 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
4184 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4185
4186 /* Make the mipmap big, so that a smaller mipmap is used
4187 */
4188 hr = IDirect3DDevice9_CreateTexture(device, 1024, 1024, 0, D3DUSAGE_AUTOGENMIPMAP,
4189 D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0);
4190 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
4191
4192 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
4193 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel returned %08x\n", hr);
4194 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
4195 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %08x\n", hr);
4196 for(y = 0; y < 1024; y++) {
4197 for(x = 0; x < 1024; x++) {
4198 DWORD *dst = (DWORD *) (((BYTE *) lr.pBits) + y * lr.Pitch + x * 4);
4199 POINT pt;
4200
4201 pt.x = x;
4202 pt.y = y;
4203 if(PtInRect(&r1, pt)) {
4204 *dst = 0xffff0000;
4205 } else if(PtInRect(&r2, pt)) {
4206 *dst = 0xff00ff00;
4207 } else if(PtInRect(&r3, pt)) {
4208 *dst = 0xff0000ff;
4209 } else if(PtInRect(&r4, pt)) {
4210 *dst = 0xff000000;
4211 } else {
4212 *dst = 0xffffffff;
4213 }
4214 }
4215 }
4216 hr = IDirect3DSurface9_UnlockRect(surface);
4217 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned %08x\n", hr);
4218 IDirect3DSurface9_Release(surface);
4219
4220 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4221 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
4222 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
4223 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
4224
4225 hr = IDirect3DDevice9_BeginScene(device);
4226 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4227 if(SUCCEEDED(hr)) {
4228 const float quad[] = {
4229 -0.5, -0.5, 0.1, 0.0, 0.0,
4230 -0.5, 0.5, 0.1, 0.0, 1.0,
4231 0.5, -0.5, 0.1, 1.0, 0.0,
4232 0.5, 0.5, 0.1, 1.0, 1.0
4233 };
4234
4235 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4236 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4237 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4238 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4239 hr = IDirect3DDevice9_EndScene(device);
4240 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4241 }
4242 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4243 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
4244 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
4245 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
4246 IDirect3DTexture9_Release(texture);
4247
4248 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4249 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4250 color = getPixelColor(device, 200, 200);
4251 ok(color == 0x00ffffff, "pixel 200/200 has color %08x, expected 0x00ffffff\n", color);
4252 color = getPixelColor(device, 280, 200);
4253 ok(color == 0x000000ff, "pixel 280/200 has color %08x, expected 0x000000ff\n", color);
4254 color = getPixelColor(device, 360, 200);
4255 ok(color == 0x00000000, "pixel 360/200 has color %08x, expected 0x00000000\n", color);
4256 color = getPixelColor(device, 440, 200);
4257 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4258 color = getPixelColor(device, 200, 270);
4259 ok(color == 0x00ffffff, "pixel 200/270 has color %08x, expected 0x00ffffff\n", color);
4260 color = getPixelColor(device, 280, 270);
4261 ok(color == 0x00ff0000, "pixel 280/270 has color %08x, expected 0x00ff0000\n", color);
4262 color = getPixelColor(device, 360, 270);
4263 ok(color == 0x0000ff00, "pixel 360/270 has color %08x, expected 0x0000ff00\n", color);
4264 color = getPixelColor(device, 440, 270);
4265 ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4266 }
4267
4268 static void test_constant_clamp_vs(IDirect3DDevice9 *device)
4269 {
4270 IDirect3DVertexShader9 *shader_11, *shader_11_2, *shader_20, *shader_20_2;
4271 IDirect3DVertexDeclaration9 *decl;
4272 HRESULT hr;
4273 DWORD color;
4274 DWORD shader_code_11[] = {
4275 0xfffe0101, /* vs_1_1 */
4276 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4277 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4278 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4279 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4280 0x0000ffff /* end */
4281 };
4282 DWORD shader_code_11_2[] = {
4283 0xfffe0101, /* vs_1_1 */
4284 0x00000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000, /* dcl ... */
4285 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* dcl ... */
4286 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4287 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4288 0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4289 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4290 0x0000ffff /* end */
4291 };
4292 DWORD shader_code_20[] = {
4293 0xfffe0200, /* vs_2_0 */
4294 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4295 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4296 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4297 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4298 0x0000ffff /* end */
4299 };
4300 DWORD shader_code_20_2[] = {
4301 0xfffe0200, /* vs_2_0 */
4302 0x05000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000,
4303 0x05000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000,
4304 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
4305 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4306 0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002, /* add oD0, r1, c2 */
4307 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
4308 0x0000ffff /* end */
4309 };
4310 static const D3DVERTEXELEMENT9 decl_elements[] = {
4311 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4312 D3DDECL_END()
4313 };
4314 float quad1[] = {
4315 -1.0, -1.0, 0.1,
4316 0.0, -1.0, 0.1,
4317 -1.0, 0.0, 0.1,
4318 0.0, 0.0, 0.1
4319 };
4320 float quad2[] = {
4321 0.0, -1.0, 0.1,
4322 1.0, -1.0, 0.1,
4323 0.0, 0.0, 0.1,
4324 1.0, 0.0, 0.1
4325 };
4326 float quad3[] = {
4327 0.0, 0.0, 0.1,
4328 1.0, 0.0, 0.1,
4329 0.0, 1.0, 0.1,
4330 1.0, 1.0, 0.1
4331 };
4332 float quad4[] = {
4333 -1.0, 0.0, 0.1,
4334 0.0, 0.0, 0.1,
4335 -1.0, 1.0, 0.1,
4336 0.0, 1.0, 0.1
4337 };
4338 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4339 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4340
4341 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4342 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4343
4344 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11, &shader_11);
4345 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
4346 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11_2, &shader_11_2);
4347 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
4348 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20, &shader_20);
4349 if(FAILED(hr)) shader_20 = NULL;
4350 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20_2, &shader_20_2);
4351 if(FAILED(hr)) shader_20_2 = NULL;
4352 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
4353 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
4354
4355 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, test_data_c1, 1);
4356 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %08x\n", hr);
4357 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 2, test_data_c2, 1);
4358 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %08x\n", hr);
4359 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
4360 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
4361
4362 hr = IDirect3DDevice9_BeginScene(device);
4363 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4364 if(SUCCEEDED(hr))
4365 {
4366 hr = IDirect3DDevice9_SetVertexShader(device, shader_11);
4367 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4368 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4369 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4370
4371 hr = IDirect3DDevice9_SetVertexShader(device, shader_11_2);
4372 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4373 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4374 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4375
4376 if(shader_20) {
4377 hr = IDirect3DDevice9_SetVertexShader(device, shader_20);
4378 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4379 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4380 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4381 }
4382
4383 if(shader_20_2) {
4384 hr = IDirect3DDevice9_SetVertexShader(device, shader_20_2);
4385 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4386 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4387 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4388 }
4389
4390 hr = IDirect3DDevice9_EndScene(device);
4391 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4392 }
4393 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4394 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4395
4396 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
4397 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4398 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
4399 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
4400
4401 color = getPixelColor(device, 160, 360);
4402 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4403 "quad 1 has color %08x, expected 0x00bfbf80\n", color);
4404 color = getPixelColor(device, 480, 360);
4405 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4406 "quad 2 has color %08x, expected 0x00bfbf80\n", color);
4407 if(shader_20) {
4408 color = getPixelColor(device, 160, 120);
4409 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4410 "quad 3 has color %08x, expected 0x00bfbf80\n", color);
4411 }
4412 if(shader_20_2) {
4413 color = getPixelColor(device, 480, 120);
4414 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4415 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4416 }
4417
4418 IDirect3DVertexDeclaration9_Release(decl);
4419 if(shader_20_2) IDirect3DVertexShader9_Release(shader_20_2);
4420 if(shader_20) IDirect3DVertexShader9_Release(shader_20);
4421 IDirect3DVertexShader9_Release(shader_11_2);
4422 IDirect3DVertexShader9_Release(shader_11);
4423 }
4424
4425 static void constant_clamp_ps_test(IDirect3DDevice9 *device)
4426 {
4427 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_14, *shader_20;
4428 HRESULT hr;
4429 DWORD color;
4430 DWORD shader_code_11[] = {
4431 0xffff0101, /* ps_1_1 */
4432 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4433 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4434 0x0000ffff /* end */
4435 };
4436 DWORD shader_code_12[] = {
4437 0xffff0102, /* ps_1_2 */
4438 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4439 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4440 0x0000ffff /* end */
4441 };
4442 /* Skip 1.3 shaders because we have only 4 quads(ok, could make them smaller if needed).
4443 * 1.2 and 1.4 shaders behave the same, so it's unlikely that 1.3 shaders are different.
4444 * During development of this test, 1.3 shaders were verified too
4445 */
4446 DWORD shader_code_14[] = {
4447 0xffff0104, /* ps_1_4 */
4448 /* Try to make one constant local. It gets clamped too, although the binary contains
4449 * the bigger numbers
4450 */
4451 0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* def c2, -0.5, 1.25, 2, 1 */
4452 0x00000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4453 0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4454 0x0000ffff /* end */
4455 };
4456 DWORD shader_code_20[] = {
4457 0xffff0200, /* ps_2_0 */
4458 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
4459 0x03000002, 0x800f0000, 0x80e40001, 0xa0e40002, /* add r0, r1, c2 */
4460 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4461 0x0000ffff /* end */
4462 };
4463 float quad1[] = {
4464 -1.0, -1.0, 0.1,
4465 0.0, -1.0, 0.1,
4466 -1.0, 0.0, 0.1,
4467 0.0, 0.0, 0.1
4468 };
4469 float quad2[] = {
4470 0.0, -1.0, 0.1,
4471 1.0, -1.0, 0.1,
4472 0.0, 0.0, 0.1,
4473 1.0, 0.0, 0.1
4474 };
4475 float quad3[] = {
4476 0.0, 0.0, 0.1,
4477 1.0, 0.0, 0.1,
4478 0.0, 1.0, 0.1,
4479 1.0, 1.0, 0.1
4480 };
4481 float quad4[] = {
4482 -1.0, 0.0, 0.1,
4483 0.0, 0.0, 0.1,
4484 -1.0, 1.0, 0.1,
4485 0.0, 1.0, 0.1
4486 };
4487 float test_data_c1[4] = { 1.25, -0.50, -1.50, 1.0};
4488 float test_data_c2[4] = { -0.50, 1.25, 2.00, 1.0};
4489
4490 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4491 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4492
4493 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4494 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4495 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4496 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4497 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4498 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4499 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader_20);
4500 if(FAILED(hr)) shader_20 = NULL;
4501
4502 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4503 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4504 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4505 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4506 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4507 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4508
4509 hr = IDirect3DDevice9_BeginScene(device);
4510 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4511 if(SUCCEEDED(hr))
4512 {
4513 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4514 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4515 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4516 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4517
4518 hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4519 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4520 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4521 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4522
4523 hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4524 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4525 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4526 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4527
4528 if(shader_20) {
4529 hr = IDirect3DDevice9_SetPixelShader(device, shader_20);
4530 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4531 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4532 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4533 }
4534
4535 hr = IDirect3DDevice9_EndScene(device);
4536 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4537 }
4538 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4539 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4540
4541 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4542 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4543
4544 color = getPixelColor(device, 160, 360);
4545 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4546 "quad 1 has color %08x, expected 0x00808000\n", color);
4547 color = getPixelColor(device, 480, 360);
4548 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4549 "quad 2 has color %08x, expected 0x00808000\n", color);
4550 color = getPixelColor(device, 480, 120);
4551 ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4552 "quad 3 has color %08x, expected 0x00808000\n", color);
4553 if(shader_20) {
4554 color = getPixelColor(device, 160, 120);
4555 ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4556 "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4557 }
4558
4559 if(shader_20) IDirect3DPixelShader9_Release(shader_20);
4560 IDirect3DPixelShader9_Release(shader_14);
4561 IDirect3DPixelShader9_Release(shader_12);
4562 IDirect3DPixelShader9_Release(shader_11);
4563 }
4564
4565 static void dp2add_ps_test(IDirect3DDevice9 *device)
4566 {
4567 IDirect3DPixelShader9 *shader_dp2add = NULL;
4568 IDirect3DPixelShader9 *shader_dp2add_sat = NULL;
4569 HRESULT hr;
4570 DWORD color;
4571
4572 /* DP2ADD is defined as: (src0.r * src1.r) + (src0.g * src1.g) + src2.
4573 * One D3D restriction of all shader instructions except SINCOS is that no more than 2
4574 * source tokens can be constants. So, for this exercise, we move contents of c0 to
4575 * r0 first.
4576 * The result here for the r,g,b components should be roughly 0.5:
4577 * (0.5 * 0.5) + (0.5 * 0.5) + 0.0 = 0.5 */
4578 static const DWORD shader_code_dp2add[] = {
4579 0xffff0200, /* ps_2_0 */
4580 0x05000051, 0xa00f0000, 0x3f000000, 0x3f000000, 0x3f800000, 0x00000000, /* def c0, 0.5, 0.5, 1.0, 0 */
4581
4582 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4583 0x0400005a, 0x80070000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add r0.rgb, r0, r0, r0.a */
4584
4585 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4586 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4587 0x0000ffff /* end */
4588 };
4589
4590 /* Test the _sat modifier, too. Result here should be:
4591 * DP2: (-0.5 * -0.5) + (-0.5 * -0.5) + 2.0 = 2.5
4592 * _SAT: ==> 1.0
4593 * ADD: (1.0 + -0.5) = 0.5
4594 */
4595 static const DWORD shader_code_dp2add_sat[] = {
4596 0xffff0200, /* ps_2_0 */
4597 0x05000051, 0xa00f0000, 0xbf000000, 0xbf000000, 0x3f800000, 0x40000000, /* def c0, -0.5, -0.5, 1.0, 2.0 */
4598
4599 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
4600 0x0400005a, 0x80170000, 0x80000000, 0x80000000, 0x80ff0000, /* dp2add_sat r0.rgb, r0, r0, r0.a */
4601 0x03000002, 0x80070000, 0x80e40000, 0xa0000000, /* add r0.rgb, r0, c0.r */
4602
4603 0x02000001, 0x80080000, 0xa0aa0000, /* mov r0.a, c0.b */
4604 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
4605 0x0000ffff /* end */
4606 };
4607
4608 const float quad[] = {
4609 -1.0, -1.0, 0.1,
4610 1.0, -1.0, 0.1,
4611 -1.0, 1.0, 0.1,
4612 1.0, 1.0, 0.1
4613 };
4614
4615
4616 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
4617 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4618
4619 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add, &shader_dp2add);
4620 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4621
4622 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add_sat, &shader_dp2add_sat);
4623 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4624
4625 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4626 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4627
4628 if (shader_dp2add) {
4629
4630 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add);
4631 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4632
4633 hr = IDirect3DDevice9_BeginScene(device);
4634 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4635 if(SUCCEEDED(hr))
4636 {
4637 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4638 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4639
4640 hr = IDirect3DDevice9_EndScene(device);
4641 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4642 }
4643 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4644 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4645
4646 color = getPixelColor(device, 360, 240);
4647 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4648
4649 IDirect3DPixelShader9_Release(shader_dp2add);
4650 } else {
4651 skip("dp2add shader creation failed\n");
4652 }
4653
4654 if (shader_dp2add_sat) {
4655
4656 hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add_sat);
4657 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4658
4659 hr = IDirect3DDevice9_BeginScene(device);
4660 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4661 if(SUCCEEDED(hr))
4662 {
4663 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4664 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4665
4666 hr = IDirect3DDevice9_EndScene(device);
4667 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4668 }
4669 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4670 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4671
4672 color = getPixelColor(device, 360, 240);
4673 ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4674
4675 IDirect3DPixelShader9_Release(shader_dp2add_sat);
4676 } else {
4677 skip("dp2add shader creation failed\n");
4678 }
4679
4680 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4681 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4682 }
4683
4684 static void cnd_test(IDirect3DDevice9 *device)
4685 {
4686 IDirect3DPixelShader9 *shader_11, *shader_12, *shader_13, *shader_14;
4687 IDirect3DPixelShader9 *shader_11_coissue, *shader_12_coissue, *shader_13_coissue, *shader_14_coissue;
4688 HRESULT hr;
4689 DWORD color;
4690 /* ps 1.x shaders are rather picky with writemasks and source swizzles. The dp3 is
4691 * used to copy r0.r to all components of r1, then copy r1.a to c0.a. Essentially it
4692 * does a mov r0.a, r0.r, which isn't allowed as-is in 1.x pixel shaders.
4693 */
4694 DWORD shader_code_11[] = {
4695 0xffff0101, /* ps_1_1 */
4696 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4697 0x00000040, 0xb00f0000, /* texcoord t0 */
4698 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, ???(t0) */
4699 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4700 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4701 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4702 0x0000ffff /* end */
4703 };
4704 DWORD shader_code_12[] = {
4705 0xffff0102, /* ps_1_2 */
4706 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4707 0x00000040, 0xb00f0000, /* texcoord t0 */
4708 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4709 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3 r1, r0, c0 */
4710 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4711 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4712 0x0000ffff /* end */
4713 };
4714 DWORD shader_code_13[] = {
4715 0xffff0103, /* ps_1_3 */
4716 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4717 0x00000040, 0xb00f0000, /* texcoord t0 */
4718 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4719 0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000, /* dp3, r1, r0, c0 */
4720 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4721 0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0.a, c1, c2 */
4722 0x0000ffff /* end */
4723 };
4724 DWORD shader_code_14[] = {
4725 0xffff0104, /* ps_1_3 */
4726 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4727 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4728 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4729 0x00000050, 0x800f0000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0, r0, c1, c2 */
4730 0x0000ffff /* end */
4731 };
4732
4733 /* Special fun: The coissue flag on cnd: Apparently cnd always selects the 2nd source,
4734 * as if the src0 comparison against 0.5 always evaluates to true. The coissue flag isn't
4735 * set by the compiler, it was added manually after compilation. It isn't always allowed,
4736 * only if there's a mov r0.a, XXXX, and the cnd instruction writes to r0.xyz, otherwise
4737 * native CreatePixelShader returns an error.
4738 *
4739 * The shader attempts to test the range [-1;1] against coissued cnd, which is a bit tricky.
4740 * The input from t0 is [0;1]. 0.5 is substracted, then we have to multiply with 2. Since
4741 * constants are clamped to [-1;1], a 2.0 is constructed by adding c0.r(=1.0) to c0.r into r1.r,
4742 * then r1(2.0, 0.0, 0.0, 0.0) is passed to dp3(explained above).
4743 */
4744 DWORD shader_code_11_coissue[] = {
4745 0xffff0101, /* ps_1_1 */
4746 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4747 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4748 0x00000040, 0xb00f0000, /* texcoord t0 */
4749 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4750 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4751 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4752 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4753 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4754 /* 0x40000000 = D3DSI_COISSUE */
4755 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4756 0x0000ffff /* end */
4757 };
4758 DWORD shader_code_12_coissue[] = {
4759 0xffff0102, /* ps_1_2 */
4760 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4761 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4762 0x00000040, 0xb00f0000, /* texcoord t0 */
4763 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4764 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4765 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4766 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4767 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4768 /* 0x40000000 = D3DSI_COISSUE */
4769 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4770 0x0000ffff /* end */
4771 };
4772 DWORD shader_code_13_coissue[] = {
4773 0xffff0103, /* ps_1_3 */
4774 0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0 */
4775 0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4776 0x00000040, 0xb00f0000, /* texcoord t0 */
4777 0x00000001, 0x800f0000, 0xb0e40000, /* mov r0, t0 */
4778 0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003, /* sub r0, r0, c3 */
4779 0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000, /* add r1, c0, c0 */
4780 0x00000008, 0x800f0001, 0x80e40000, 0x80e40001, /* dp3, r1, r0, r1 */
4781 0x00000001, 0x80080000, 0x80ff0001, /* mov r0.a, r1.a */
4782 /* 0x40000000 = D3DSI_COISSUE */
4783 0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0.a, c1, c2 */
4784 0x0000ffff /* end */
4785 };
4786 /* ps_1_4 does not have a different cnd behavior, just pass the [0;1] texcrd result to cnd, it will
4787 * compare against 0.5
4788 */
4789 DWORD shader_code_14_coissue[] = {
4790 0xffff0104, /* ps_1_4 */
4791 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
4792 0x00000040, 0x80070000, 0xb0e40000, /* texcrd r0, t0 */
4793 0x00000001, 0x80080000, 0xa0ff0000, /* mov r0.a, c0.a */
4794 /* 0x40000000 = D3DSI_COISSUE */
4795 0x40000050, 0x80070000, 0x80e40000, 0xa0e40001, 0xa0e40002, /* cnd r0.xyz, r0, c1, c2 */
4796 0x0000ffff /* end */
4797 };
4798 float quad1[] = {
4799 -1.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4800 0.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4801 -1.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4802 0.0, 0.0, 0.1, 1.0, 1.0, 0.0
4803 };
4804 float quad2[] = {
4805 0.0, -1.0, 0.1, 0.0, 0.0, 1.0,
4806 1.0, -1.0, 0.1, 1.0, 0.0, 1.0,
4807 0.0, 0.0, 0.1, 0.0, 1.0, 0.0,
4808 1.0, 0.0, 0.1, 1.0, 1.0, 0.0
4809 };
4810 float quad3[] = {
4811 0.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4812 1.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4813 0.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4814 1.0, 1.0, 0.1, 1.0, 1.0, 0.0
4815 };
4816 float quad4[] = {
4817 -1.0, 0.0, 0.1, 0.0, 0.0, 1.0,
4818 0.0, 0.0, 0.1, 1.0, 0.0, 1.0,
4819 -1.0, 1.0, 0.1, 0.0, 1.0, 0.0,
4820 0.0, 1.0, 0.1, 1.0, 1.0, 0.0
4821 };
4822 float test_data_c1[4] = { 0.0, 0.0, 0.0, 0.0};
4823 float test_data_c2[4] = { 1.0, 1.0, 1.0, 1.0};
4824 float test_data_c1_coi[4] = { 0.0, 1.0, 0.0, 0.0};
4825 float test_data_c2_coi[4] = { 1.0, 0.0, 1.0, 1.0};
4826
4827 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4828 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4829
4830 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4831 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4832 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4833 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4834 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13, &shader_13);
4835 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4836 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4837 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4838 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11_coissue, &shader_11_coissue);
4839 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4840 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12_coissue, &shader_12_coissue);
4841 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4842 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13_coissue, &shader_13_coissue);
4843 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4844 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14_coissue, &shader_14_coissue);
4845 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4846
4847 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4848 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4849 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4850 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4851 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4852 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4853
4854 hr = IDirect3DDevice9_BeginScene(device);
4855 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4856 if(SUCCEEDED(hr))
4857 {
4858 hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4859 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", 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);
4864 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", 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);
4869 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", 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);
4874 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", 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 %08x\n", hr);
4880 }
4881 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4882 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4883
4884 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4885 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4886
4887 /* This is the 1.4 test. Each component(r, g, b) is tested separately against 0.5 */
4888 color = getPixelColor(device, 158, 118);
4889 ok(color == 0x00ff00ff, "pixel 158, 118 has color %08x, expected 0x00ff00ff\n", color);
4890 color = getPixelColor(device, 162, 118);
4891 ok(color == 0x000000ff, "pixel 162, 118 has color %08x, expected 0x000000ff\n", color);
4892 color = getPixelColor(device, 158, 122);
4893 ok(color == 0x00ffffff, "pixel 162, 122 has color %08x, expected 0x00ffffff\n", color);
4894 color = getPixelColor(device, 162, 122);
4895 ok(color == 0x0000ffff, "pixel 162, 122 has color %08x, expected 0x0000ffff\n", color);
4896
4897 /* 1.1 shader. All 3 components get set, based on the .w comparison */
4898 color = getPixelColor(device, 158, 358);
4899 ok(color == 0x00ffffff, "pixel 158, 358 has color %08x, expected 0x00ffffff\n", color);
4900 color = getPixelColor(device, 162, 358);
4901 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4902 "pixel 162, 358 has color %08x, expected 0x00000000\n", color);
4903 color = getPixelColor(device, 158, 362);
4904 ok(color == 0x00ffffff, "pixel 158, 362 has color %08x, expected 0x00ffffff\n", color);
4905 color = getPixelColor(device, 162, 362);
4906 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4907 "pixel 162, 362 has color %08x, expected 0x00000000\n", color);
4908
4909 /* 1.2 shader */
4910 color = getPixelColor(device, 478, 358);
4911 ok(color == 0x00ffffff, "pixel 478, 358 has color %08x, expected 0x00ffffff\n", color);
4912 color = getPixelColor(device, 482, 358);
4913 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4914 "pixel 482, 358 has color %08x, expected 0x00000000\n", color);
4915 color = getPixelColor(device, 478, 362);
4916 ok(color == 0x00ffffff, "pixel 478, 362 has color %08x, expected 0x00ffffff\n", color);
4917 color = getPixelColor(device, 482, 362);
4918 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4919 "pixel 482, 362 has color %08x, expected 0x00000000\n", color);
4920
4921 /* 1.3 shader */
4922 color = getPixelColor(device, 478, 118);
4923 ok(color == 0x00ffffff, "pixel 478, 118 has color %08x, expected 0x00ffffff\n", color);
4924 color = getPixelColor(device, 482, 118);
4925 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4926 "pixel 482, 118 has color %08x, expected 0x00000000\n", color);
4927 color = getPixelColor(device, 478, 122);
4928 ok(color == 0x00ffffff, "pixel 478, 122 has color %08x, expected 0x00ffffff\n", color);
4929 color = getPixelColor(device, 482, 122);
4930 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4931 "pixel 482, 122 has color %08x, expected 0x00000000\n", color);
4932
4933 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4934 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4935 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1_coi, 1);
4936 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4937 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2_coi, 1);
4938 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4939
4940 hr = IDirect3DDevice9_BeginScene(device);
4941 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4942 if(SUCCEEDED(hr))
4943 {
4944 hr = IDirect3DDevice9_SetPixelShader(device, shader_11_coissue);
4945 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4946 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4947 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4948
4949 hr = IDirect3DDevice9_SetPixelShader(device, shader_12_coissue);
4950 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4951 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4952 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4953
4954 hr = IDirect3DDevice9_SetPixelShader(device, shader_13_coissue);
4955 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4956 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4957 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4958
4959 hr = IDirect3DDevice9_SetPixelShader(device, shader_14_coissue);
4960 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4961 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4962 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4963
4964 hr = IDirect3DDevice9_EndScene(device);
4965 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4966 }
4967 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4968 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4969
4970 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4971 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4972
4973 /* This is the 1.4 test. The coissue doesn't change the behavior here, but keep in mind
4974 * that we swapped the values in c1 and c2 to make the other tests return some color
4975 */
4976 color = getPixelColor(device, 158, 118);
4977 ok(color == 0x00ffffff, "pixel 158, 118 has color %08x, expected 0x00ffffff\n", color);
4978 color = getPixelColor(device, 162, 118);
4979 ok(color == 0x0000ffff, "pixel 162, 118 has color %08x, expected 0x0000ffff\n", color);
4980 color = getPixelColor(device, 158, 122);
4981 ok(color == 0x00ff00ff, "pixel 162, 122 has color %08x, expected 0x00ff00ff\n", color);
4982 color = getPixelColor(device, 162, 122);
4983 ok(color == 0x000000ff, "pixel 162, 122 has color %08x, expected 0x000000ff\n", color);
4984
4985 /* 1.1 shader. coissue flag changed the semantic of cnd, c1 is always selected */
4986 color = getPixelColor(device, 158, 358);
4987 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4988 "pixel 158, 358 has color %08x, expected 0x0000ff00\n", color);
4989 color = getPixelColor(device, 162, 358);
4990 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4991 "pixel 162, 358 has color %08x, expected 0x0000ff00\n", color);
4992 color = getPixelColor(device, 158, 362);
4993 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4994 "pixel 158, 362 has color %08x, expected 0x0000ff00\n", color);
4995 color = getPixelColor(device, 162, 362);
4996 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4997 "pixel 162, 362 has color %08x, expected 0x0000ff00\n", color);
4998
4999 /* 1.2 shader */
5000 color = getPixelColor(device, 478, 358);
5001 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5002 "pixel 478, 358 has color %08x, expected 0x0000ff00\n", color);
5003 color = getPixelColor(device, 482, 358);
5004 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5005 "pixel 482, 358 has color %08x, expected 0x0000ff00\n", color);
5006 color = getPixelColor(device, 478, 362);
5007 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5008 "pixel 478, 362 has color %08x, expected 0x0000ff00\n", color);
5009 color = getPixelColor(device, 482, 362);
5010 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5011 "pixel 482, 362 has color %08x, expected 0x0000ff00\n", color);
5012
5013 /* 1.3 shader */
5014 color = getPixelColor(device, 478, 118);
5015 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5016 "pixel 478, 118 has color %08x, expected 0x0000ff00\n", color);
5017 color = getPixelColor(device, 482, 118);
5018 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5019 "pixel 482, 118 has color %08x, expected 0x0000ff00\n", color);
5020 color = getPixelColor(device, 478, 122);
5021 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5022 "pixel 478, 122 has color %08x, expected 0x0000ff00\n", color);
5023 color = getPixelColor(device, 482, 122);
5024 ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5025 "pixel 482, 122 has color %08x, expected 0x0000ff00\n", color);
5026
5027 IDirect3DPixelShader9_Release(shader_14_coissue);
5028 IDirect3DPixelShader9_Release(shader_13_coissue);
5029 IDirect3DPixelShader9_Release(shader_12_coissue);
5030 IDirect3DPixelShader9_Release(shader_11_coissue);
5031 IDirect3DPixelShader9_Release(shader_14);
5032 IDirect3DPixelShader9_Release(shader_13);
5033 IDirect3DPixelShader9_Release(shader_12);
5034 IDirect3DPixelShader9_Release(shader_11);
5035 }
5036
5037 static void nested_loop_test(IDirect3DDevice9 *device) {
5038 const DWORD shader_code[] = {
5039 0xffff0300, /* ps_3_0 */
5040 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1 */
5041 0x05000051, 0xa00f0001, 0x3d000000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1/32, 0, 0, 0*/
5042 0x05000030, 0xf00f0000, 0x00000004, 0x00000000, 0x00000002, 0x00000000, /* defi i0, 4, 0, 2, 0 */
5043 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5044 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
5045 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
5046 0x03000002, 0x800f0000, 0x80e40000, 0xa0e40001, /* add r0, r0, c1 */
5047 0x0000001d, /* endloop */
5048 0x0000001d, /* endloop */
5049 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5050 0x0000ffff /* end */
5051 };
5052 IDirect3DPixelShader9 *shader;
5053 HRESULT hr;
5054 DWORD color;
5055 const float quad[] = {
5056 -1.0, -1.0, 0.1,
5057 1.0, -1.0, 0.1,
5058 -1.0, 1.0, 0.1,
5059 1.0, 1.0, 0.1
5060 };
5061
5062 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
5063 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed with %08x\n", hr);
5064 hr = IDirect3DDevice9_SetPixelShader(device, shader);
5065 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %08x\n", hr);
5066 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5067 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
5068 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x0000ff00, 0.0, 0);
5069 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5070
5071 hr = IDirect3DDevice9_BeginScene(device);
5072 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5073 if(SUCCEEDED(hr))
5074 {
5075 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
5076 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5077 hr = IDirect3DDevice9_EndScene(device);
5078 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5079 }
5080 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5081 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5082
5083 color = getPixelColor(device, 360, 240);
5084 ok(color == 0x007f0000 || color == 0x00800000 || color == 0x00810000,
5085 "Nested loop test returned color 0x%08x, expected 0x00800000\n", color);
5086
5087 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5088 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %08x\n", hr);
5089 IDirect3DPixelShader9_Release(shader);
5090 }
5091
5092 struct varying_test_struct
5093 {
5094 const DWORD *shader_code;
5095 IDirect3DPixelShader9 *shader;
5096 DWORD color, color_rhw;
5097 const char *name;
5098 BOOL todo, todo_rhw;
5099 };
5100
5101 struct hugeVertex
5102 {
5103 float pos_x, pos_y, pos_z, rhw;
5104 float weight_1, weight_2, weight_3, weight_4;
5105 float index_1, index_2, index_3, index_4;
5106 float normal_1, normal_2, normal_3, normal_4;
5107 float fog_1, fog_2, fog_3, fog_4;
5108 float texcoord_1, texcoord_2, texcoord_3, texcoord_4;
5109 float tangent_1, tangent_2, tangent_3, tangent_4;
5110 float binormal_1, binormal_2, binormal_3, binormal_4;
5111 float depth_1, depth_2, depth_3, depth_4;
5112 DWORD diffuse, specular;
5113 };
5114
5115 static void fixed_function_varying_test(IDirect3DDevice9 *device) {
5116 /* dcl_position: fails to compile */
5117 const DWORD blendweight_code[] = {
5118 0xffff0300, /* ps_3_0 */
5119 0x0200001f, 0x80000001, 0x900f0000, /* dcl_blendweight, v0 */
5120 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5121 0x0000ffff /* end */
5122 };
5123 const DWORD blendindices_code[] = {
5124 0xffff0300, /* ps_3_0 */
5125 0x0200001f, 0x80000002, 0x900f0000, /* dcl_blendindices, v0 */
5126 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5127 0x0000ffff /* end */
5128 };
5129 const DWORD normal_code[] = {
5130 0xffff0300, /* ps_3_0 */
5131 0x0200001f, 0x80000003, 0x900f0000, /* dcl_normal, v0 */
5132 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5133 0x0000ffff /* end */
5134 };
5135 /* psize: fails? */
5136 const DWORD texcoord0_code[] = {
5137 0xffff0300, /* ps_3_0 */
5138 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0, v0 */
5139 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5140 0x0000ffff /* end */
5141 };
5142 const DWORD tangent_code[] = {
5143 0xffff0300, /* ps_3_0 */
5144 0x0200001f, 0x80000006, 0x900f0000, /* dcl_tangent, v0 */
5145 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5146 0x0000ffff /* end */
5147 };
5148 const DWORD binormal_code[] = {
5149 0xffff0300, /* ps_3_0 */
5150 0x0200001f, 0x80000007, 0x900f0000, /* dcl_binormal, v0 */
5151 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5152 0x0000ffff /* end */
5153 };
5154 /* tessfactor: fails */
5155 /* positiont: fails */
5156 const DWORD color_code[] = {
5157 0xffff0300, /* ps_3_0 */
5158 0x0200001f, 0x8000000a, 0x900f0000, /* dcl_color0, v0 */
5159 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5160 0x0000ffff /* end */
5161 };
5162 const DWORD fog_code[] = {
5163 0xffff0300, /* ps_3_0 */
5164 0x0200001f, 0x8000000b, 0x900f0000, /* dcl_fog, v0 */
5165 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5166 0x0000ffff /* end */
5167 };
5168 const DWORD depth_code[] = {
5169 0xffff0300, /* ps_3_0 */
5170 0x0200001f, 0x8000000c, 0x900f0000, /* dcl_depth, v0 */
5171 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5172 0x0000ffff /* end */
5173 };
5174 const DWORD specular_code[] = {
5175 0xffff0300, /* ps_3_0 */
5176 0x0200001f, 0x8001000a, 0x900f0000, /* dcl_color1, v0 */
5177 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */
5178 0x0000ffff /* end */
5179 };
5180 /* sample: fails */
5181
5182 struct varying_test_struct tests[] = {
5183 {blendweight_code, NULL, 0x00000000, 0x00191919, "blendweight" , FALSE, TRUE },
5184 {blendindices_code, NULL, 0x00000000, 0x00000000, "blendindices" , FALSE, FALSE },
5185 {normal_code, NULL, 0x00000000, 0x004c4c4c, "normal" , FALSE, TRUE },
5186 /* Why does dx not forward the texcoord? */
5187 {texcoord0_code, NULL, 0x00000000, 0x00808c8c, "texcoord0" , FALSE, FALSE },
5188 {tangent_code, NULL, 0x00000000, 0x00999999, "tangent" , FALSE, TRUE },
5189 {binormal_code, NULL, 0x00000000, 0x00b2b2b2, "binormal" , FALSE, TRUE },
5190 {color_code, NULL, 0x00e6e6e6, 0x00e6e6e6, "color" , FALSE, FALSE },
5191 {fog_code, NULL, 0x00000000, 0x00666666, "fog" , FALSE, TRUE },
5192 {depth_code, NULL, 0x00000000, 0x00cccccc, "depth" , FALSE, TRUE },
5193 {specular_code, NULL, 0x004488ff, 0x004488ff, "specular" , FALSE, FALSE }
5194 };
5195 /* Declare a monster vertex type :-) */
5196 static const D3DVERTEXELEMENT9 decl_elements[] = {
5197 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
5198 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5199 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5200 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5201 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5202 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5203 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5204 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5205 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5206 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5207 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5208 D3DDECL_END()
5209 };
5210 static const D3DVERTEXELEMENT9 decl_elements2[] = {
5211 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
5212 {0, 16, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0},
5213 {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES, 0},
5214 {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
5215 {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG, 0},
5216 {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
5217 {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT, 0},
5218 {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL, 0},
5219 {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH, 0},
5220 {0, 144, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
5221 {0, 148, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1},
5222 D3DDECL_END()
5223 };
5224 struct hugeVertex data[4] = {
5225 {
5226 -1.0, -1.0, 0.1, 1.0,
5227 0.1, 0.1, 0.1, 0.1,
5228 0.2, 0.2, 0.2, 0.2,
5229 0.3, 0.3, 0.3, 0.3,
5230 0.4, 0.4, 0.4, 0.4,
5231 0.50, 0.55, 0.55, 0.55,
5232 0.6, 0.6, 0.6, 0.7,
5233 0.7, 0.7, 0.7, 0.6,
5234 0.8, 0.8, 0.8, 0.8,
5235 0xe6e6e6e6, /* 0.9 * 256 */
5236 0x224488ff /* Nothing special */
5237 },
5238 {
5239 1.0, -1.0, 0.1, 1.0,
5240 0.1, 0.1, 0.1, 0.1,
5241 0.2, 0.2, 0.2, 0.2,
5242 0.3, 0.3, 0.3, 0.3,
5243 0.4, 0.4, 0.4, 0.4,
5244 0.50, 0.55, 0.55, 0.55,
5245 0.6, 0.6, 0.6, 0.7,
5246 0.7, 0.7, 0.7, 0.6,
5247 0.8, 0.8, 0.8, 0.8,
5248 0xe6e6e6e6, /* 0.9 * 256 */
5249 0x224488ff /* Nothing special */
5250 },
5251 {
5252 -1.0, 1.0, 0.1, 1.0,
5253 0.1, 0.1, 0.1, 0.1,
5254 0.2, 0.2, 0.2, 0.2,
5255 0.3, 0.3, 0.3, 0.3,
5256 0.4, 0.4, 0.4, 0.4,
5257 0.50, 0.55, 0.55, 0.55,
5258 0.6, 0.6, 0.6, 0.7,
5259 0.7, 0.7, 0.7, 0.6,
5260 0.8, 0.8, 0.8, 0.8,
5261 0xe6e6e6e6, /* 0.9 * 256 */
5262 0x224488ff /* Nothing special */
5263 },
5264 {
5265 1.0, 1.0, 0.1, 1.0,
5266 0.1, 0.1, 0.1, 0.1,
5267 0.2, 0.2, 0.2, 0.2,
5268 0.3, 0.3, 0.3, 0.3,
5269 0.4, 0.4, 0.4, 0.4,
5270 0.50, 0.55, 0.55, 0.55,
5271 0.6, 0.6, 0.6, 0.7,
5272 0.7, 0.7, 0.7, 0.6,
5273 0.8, 0.8, 0.8, 0.8,
5274 0xe6e6e6e6, /* 0.9 * 256 */
5275 0x224488ff /* Nothing special */
5276 },
5277 };
5278 struct hugeVertex data2[4];
5279 IDirect3DVertexDeclaration9 *decl;
5280 IDirect3DVertexDeclaration9 *decl2;
5281 HRESULT hr;
5282 unsigned int i;
5283 DWORD color, r, g, b, r_e, g_e, b_e;
5284 BOOL drawok;
5285
5286 memcpy(data2, data, sizeof(data2));
5287 data2[0].pos_x = 0; data2[0].pos_y = 0;
5288 data2[1].pos_x = 640; data2[1].pos_y = 0;
5289 data2[2].pos_x = 0; data2[2].pos_y = 480;
5290 data2[3].pos_x = 640; data2[3].pos_y = 480;
5291
5292 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
5293 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
5294 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
5295 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
5296 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
5297 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
5298
5299 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5300 {
5301 hr = IDirect3DDevice9_CreatePixelShader(device, tests[i].shader_code, &tests[i].shader);
5302 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed for shader %s, hr = %08x\n",
5303 tests[i].name, hr);
5304 }
5305
5306 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5307 {
5308 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5309 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5310
5311 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5312 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5313
5314 hr = IDirect3DDevice9_BeginScene(device);
5315 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5316 drawok = FALSE;
5317 if(SUCCEEDED(hr))
5318 {
5319 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data, sizeof(data[0]));
5320 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed (%08x)\n", hr);
5321 drawok = SUCCEEDED(hr);
5322 hr = IDirect3DDevice9_EndScene(device);
5323 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5324 }
5325 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5326 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5327
5328 /* Some drivers reject the combination of ps_3_0 and fixed function vertex processing. Accept
5329 * the failure and do not check the color if it failed
5330 */
5331 if(!drawok) {
5332 continue;
5333 }
5334
5335 color = getPixelColor(device, 360, 240);
5336 r = color & 0x00ff0000 >> 16;
5337 g = color & 0x0000ff00 >> 8;
5338 b = color & 0x000000ff;
5339 r_e = tests[i].color & 0x00ff0000 >> 16;
5340 g_e = tests[i].color & 0x0000ff00 >> 8;
5341 b_e = tests[i].color & 0x000000ff;
5342
5343 if(tests[i].todo) {
5344 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5345 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5346 tests[i].name, color, tests[i].color);
5347 } else {
5348 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5349 "Test %s returned color 0x%08x, expected 0x%08x\n",
5350 tests[i].name, color, tests[i].color);
5351 }
5352 }
5353
5354 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
5355 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
5356 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5357 {
5358 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5359 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5360
5361 IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5362 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5363
5364 hr = IDirect3DDevice9_BeginScene(device);
5365 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5366 if(SUCCEEDED(hr))
5367 {
5368 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data2, sizeof(data2[0]));
5369 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5370 hr = IDirect3DDevice9_EndScene(device);
5371 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5372 }
5373 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5374 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5375
5376 color = getPixelColor(device, 360, 240);
5377 r = color & 0x00ff0000 >> 16;
5378 g = color & 0x0000ff00 >> 8;
5379 b = color & 0x000000ff;
5380 r_e = tests[i].color_rhw & 0x00ff0000 >> 16;
5381 g_e = tests[i].color_rhw & 0x0000ff00 >> 8;
5382 b_e = tests[i].color_rhw & 0x000000ff;
5383
5384 if(tests[i].todo_rhw) {
5385 /* This isn't a weekend's job to fix, ignore the problem for now. Needs a replacement
5386 * pipeline
5387 */
5388 todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5389 "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5390 tests[i].name, color, tests[i].color_rhw);
5391 } else {
5392 ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5393 "Test %s returned color 0x%08x, expected 0x%08x\n",
5394 tests[i].name, color, tests[i].color_rhw);
5395 }
5396 }
5397
5398 for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5399 {
5400 IDirect3DPixelShader9_Release(tests[i].shader);
5401 }
5402
5403 IDirect3DVertexDeclaration9_Release(decl2);
5404 IDirect3DVertexDeclaration9_Release(decl);
5405 }
5406
5407 static void vshader_version_varying_test(IDirect3DDevice9 *device) {
5408 static const DWORD ps_code[] = {
5409 0xffff0300, /* ps_3_0 */
5410 0x05000030, 0xf00f0000, 0x00000003, 0x00000003, 0x00000001, 0x00000000, /* defi i0, 3, 3, 1, 0 */
5411 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5412 0x0200001f, 0x8001000a, 0x900f0003, /* dcl_color1 v3 */
5413 0x0200001f, 0x8000000b, 0x900f0004, /* dcl_fog v4 */
5414 0x0200001f, 0x80030005, 0x900f0005, /* dcl_texcoord3 v5 */
5415 0x0200001f, 0x80000003, 0x900f0006, /* dcl_normal v6 */
5416 0x0200001f, 0x80000006, 0x900f0007, /* dcl_tangent v7 */
5417 0x0200001f, 0x80000001, 0x900f0008, /* dcl_blendweight v8 */
5418 0x0200001f, 0x8000000c, 0x900f0009, /* dcl_depth v9 */
5419
5420 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5421 0x0200001b, 0xf0e40800, 0xf0e40000, /* loop aL, i0 */
5422 0x04000002, 0x800f0000, 0x80e40000, 0x90e42000, 0xf0e40800, /* add r0, r0, v0[aL] */
5423 0x0000001d, /* endloop */
5424 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5425 0x0000ffff /* end */
5426 };
5427 static const DWORD vs_1_code[] = {
5428 0xfffe0101, /* vs_1_1 */
5429 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5430 0x00000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5431 0x00000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5432 0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5433 0x00000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5434 0x00000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5435 0x00000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5436 0x00000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5437 0x00000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5438 0x00000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5439 0x00000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5440 0x00000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5441 0x00000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5442 0x00000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5443 0x00000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5444 0x00000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5445 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5446 0x0000ffff
5447 };
5448 DWORD vs_2_code[] = {
5449 0xfffe0200, /* vs_2_0 */
5450 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5451 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5452 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5453 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5454 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5455 0x02000001, 0xd00f0000, 0xa0e40002, /* mov oD0, c2 */
5456 0x02000001, 0xd00f0001, 0xa0e40000, /* mov oD1, c0 */
5457 0x02000001, 0xc00f0001, 0xa0550001, /* mov oFog, c1.g */
5458 0x02000001, 0xe00f0000, 0xa0e40003, /* mov oT0, c3 */
5459 0x02000001, 0xe00f0001, 0xa0e40003, /* mov oT1, c3 */
5460 0x02000001, 0xe00f0002, 0xa0e40003, /* mov oT2, c3 */
5461 0x02000001, 0xe00f0003, 0xa0e40002, /* mov oT3, c2 */
5462 0x02000001, 0xe00f0004, 0xa0e40003, /* mov oT4, c3 */
5463 0x02000001, 0xe00f0005, 0xa0e40003, /* mov oT5, c3 */
5464 0x02000001, 0xe00f0006, 0xa0e40003, /* mov oT6, c3 */
5465 0x02000001, 0xe00f0007, 0xa0e40003, /* mov oT7, c3 */
5466 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5467 0x0000ffff /* end */
5468 };
5469 /* TODO: Define normal, tangent, blendweight and depth here */
5470 static const DWORD vs_3_code[] = {
5471 0xfffe0300, /* vs_3_0 */
5472 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5473 0x0200001f, 0x8001000a, 0xe00f0009, /* dcl_color1 o9 */
5474 0x0200001f, 0x8000000b, 0xe00f0002, /* dcl_fog o2 */
5475 0x0200001f, 0x80030005, 0xe00f0005, /* dcl_texcoord3 o5 */
5476 0x0200001f, 0x80000000, 0xe00f000b, /* dcl_position o11 */
5477 0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0 */
5478 0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0 */
5479 0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0 */
5480 0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0 */
5481 0x02000001, 0xe00f0009, 0xa0e40000, /* mov o9, c0 */
5482 0x02000001, 0xe00f0002, 0xa0e40001, /* mov o2, c1 */
5483 0x02000001, 0xe00f0005, 0xa0e40002, /* mov o5, c2 */
5484 0x02000001, 0xe00f000b, 0x90e40000, /* mov o11, v0 */
5485 0x0000ffff /* end */
5486 };
5487 float quad1[] = {
5488 -1.0, -1.0, 0.1,
5489 0.0, -1.0, 0.1,
5490 -1.0, 0.0, 0.1,
5491 0.0, 0.0, 0.1
5492 };
5493 float quad2[] = {
5494 0.0, -1.0, 0.1,
5495 1.0, -1.0, 0.1,
5496 0.0, 0.0, 0.1,
5497 1.0, 0.0, 0.1
5498 };
5499 float quad3[] = {
5500 -1.0, 0.0, 0.1,
5501 0.0, 0.0, 0.1,
5502 -1.0, 1.0, 0.1,
5503 0.0, 1.0, 0.1
5504 };
5505
5506 HRESULT hr;
5507 DWORD color;
5508 IDirect3DPixelShader9 *pixelshader = NULL;
5509 IDirect3DVertexShader9 *vs_1_shader = NULL;
5510 IDirect3DVertexShader9 *vs_2_shader = NULL;
5511 IDirect3DVertexShader9 *vs_3_shader = NULL;
5512
5513 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff110000, 0.0, 0);
5514
5515 hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &pixelshader);
5516 ok(hr == D3D_OK, "IDirect3DDevice_CreatePixelShader returned %08x\n", hr);
5517 hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_code, &vs_1_shader);
5518 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5519 hr = IDirect3DDevice9_CreateVertexShader(device, vs_2_code, &vs_2_shader);
5520 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5521 hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_code, &vs_3_shader);
5522 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5523 hr = IDirect3DDevice9_SetPixelShader(device, pixelshader);
5524 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5525 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5526
5527 hr = IDirect3DDevice9_BeginScene(device);
5528 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5529 if(SUCCEEDED(hr))
5530 {
5531 hr = IDirect3DDevice9_SetVertexShader(device, vs_1_shader);
5532 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5533 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5534 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5535
5536 hr = IDirect3DDevice9_SetVertexShader(device, vs_2_shader);
5537 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5538 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5539 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5540
5541 hr = IDirect3DDevice9_SetVertexShader(device, vs_3_shader);
5542 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5543 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5544 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5545
5546 hr = IDirect3DDevice9_EndScene(device);
5547 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5548 }
5549 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5550 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5551
5552 color = getPixelColor(device, 160, 120);
5553 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x1a, 0x34, 0x67), 1),
5554 "vs_3_0 returned color 0x%08x, expected 0x00193366\n", color);
5555 color = getPixelColor(device, 160, 360);
5556 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x4d, 0x00, 0x67), 1),
5557 "vs_1_1 returned color 0x%08x, expected 0x004c0066\n", color);
5558 color = getPixelColor(device, 480, 360);
5559 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x4d, 0x00, 0x67), 1),
5560 "vs_2_0 returned color 0x%08x, expected 0x004c0066\n", color);
5561
5562 /* cleanup */
5563 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5564 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5565 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5566 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5567 if(pixelshader) IDirect3DPixelShader9_Release(pixelshader);
5568 if(vs_1_shader) IDirect3DVertexShader9_Release(vs_1_shader);
5569 if(vs_2_shader) IDirect3DVertexShader9_Release(vs_2_shader);
5570 if(vs_3_shader) IDirect3DVertexShader9_Release(vs_3_shader);
5571 }
5572
5573 static void pshader_version_varying_test(IDirect3DDevice9 *device) {
5574 static const DWORD vs_code[] = {
5575 0xfffe0300, /* vs_3_0 */
5576 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5577 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5578 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color0 o1 */
5579 0x0200001f, 0x80000005, 0xe00f0002, /* dcl_texcoord0 o2 */
5580 0x0200001f, 0x8000000b, 0xe00f0003, /* dcl_fog o3 */
5581 0x0200001f, 0x80000003, 0xe00f0004, /* dcl_normal o4 */
5582 0x0200001f, 0x8000000c, 0xe00f0005, /* dcl_depth o5 */
5583 0x0200001f, 0x80000006, 0xe00f0006, /* dcl_tangent o6 */
5584 0x0200001f, 0x80000001, 0xe00f0007, /* dcl_blendweight o7 */
5585 0x05000051, 0xa00f0001, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c1, 0.1, 0.0, 0.0, 0.0 */
5586 0x05000051, 0xa00f0002, 0x00000000, 0x3e4ccccd, 0x00000000, 0x3f800000, /* def c2, 0.0, 0.2, 0.0, 1.0 */
5587 0x05000051, 0xa00f0003, 0x3ecccccd, 0x3f59999a, 0x3f666666, 0x00000000, /* def c3, 0.4, 0.85,0.9, 0.0 */
5588 0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c0, 1.0, 1.0, 1.0, 1.0 */
5589
5590 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5591 0x02000001, 0xe00f0001, 0xa0e40001, /* mov o1, c1 */
5592 0x02000001, 0xe00f0002, 0xa0e40002, /* mov o2, c2 */
5593 0x02000001, 0xe00f0003, 0xa0e40003, /* mov o3, c3 */
5594 0x02000001, 0xe00f0004, 0xa0e40000, /* mov o4, c0 */
5595 0x02000001, 0xe00f0005, 0xa0e40000, /* mov o5, c0 */
5596 0x02000001, 0xe00f0006, 0xa0e40000, /* mov o6, c0 */
5597 0x02000001, 0xe00f0007, 0xa0e40000, /* mov o7, c0 */
5598 0x0000ffff /* end */
5599 };
5600 static const DWORD ps_1_code[] = {
5601 0xffff0104, /* ps_1_4 */
5602 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
5603 0x00000040, 0x80070001, 0xb0e40000, /* texcrd r1.xyz, t0 */
5604 0x00000001, 0x80080001, 0xa0ff0000, /* mov r1.a, c0.a */
5605 0x00000002, 0x800f0000, 0x90e40000, 0x80e40001, /* add r0, v0, r1 */
5606 0x0000ffff /* end */
5607 };
5608 static const DWORD ps_2_code[] = {
5609 0xffff0200, /* ps_2_0 */
5610 0x0200001f, 0x80000000, 0xb00f0000, /* dcl t0 */
5611 0x0200001f, 0x80000000, 0x900f0000, /* dcl v0 */
5612 0x0200001f, 0x80000000, 0x900f0001, /* dcl v1 */
5613
5614 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5615 0x03000002, 0x800f0000, 0x80e40000,0xb0e40000, /* add r0, r0, t0 */
5616 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5617 0x0000ffff /* end */
5618 };
5619 static const DWORD ps_3_code[] = {
5620 0xffff0300, /* ps_3_0 */
5621 0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord0 v0 */
5622 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
5623 0x0200001f, 0x8000000b, 0x900f0002, /* dcl_fog v2 */
5624
5625 0x02000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
5626 0x03000002, 0x800f0000, 0x80e40000, 0x90e40001, /* add r0, r0, v1 */
5627 0x03000002, 0x800f0000, 0x80e40000, 0x90e40002, /* mov r0, r0, v2 */
5628 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
5629 0x0000ffff /* end */
5630 };
5631
5632 float quad1[] = {
5633 -1.0, -1.0, 0.1,
5634 0.0, -1.0, 0.1,
5635 -1.0, 0.0, 0.1,
5636 0.0, 0.0, 0.1
5637 };
5638 float quad2[] = {
5639 0.0, -1.0, 0.1,
5640 1.0, -1.0, 0.1,
5641 0.0, 0.0, 0.1,
5642 1.0, 0.0, 0.1
5643 };
5644 float quad3[] = {
5645 -1.0, 0.0, 0.1,
5646 0.0, 0.0, 0.1,
5647 -1.0, 1.0, 0.1,
5648 0.0, 1.0, 0.1
5649 };
5650 float quad4[] = {
5651 0.0, 0.0, 0.1,
5652 1.0, 0.0, 0.1,
5653 0.0, 1.0, 0.1,
5654 1.0, 1.0, 0.1
5655 };
5656
5657 HRESULT hr;
5658 DWORD color;
5659 IDirect3DVertexShader9 *vertexshader = NULL;
5660 IDirect3DPixelShader9 *ps_1_shader = NULL;
5661 IDirect3DPixelShader9 *ps_2_shader = NULL;
5662 IDirect3DPixelShader9 *ps_3_shader = NULL;
5663 IDirect3DTexture9 *texture = NULL;
5664 D3DLOCKED_RECT lr;
5665 unsigned int x, y;
5666
5667 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
5668
5669 hr = IDirect3DDevice9_CreateTexture(device, 512, 512, 1, 0, D3DFMT_A16B16G16R16, D3DPOOL_MANAGED, &texture, NULL);
5670 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
5671 if(FAILED(hr)) {
5672 skip("D3DFMT_A16B16G16R16 textures not supported\n");
5673 return;
5674 }
5675 hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
5676 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %08x\n", hr);
5677 for(y = 0; y < 512; y++) {
5678 for(x = 0; x < 512; x++) {
5679 double r_f = (double) x / (double) 512;
5680 double g_f = (double) y / (double) 512;
5681 unsigned short *dst = (unsigned short *) (((unsigned char *) lr.pBits) + y * lr.Pitch + x * 8);
5682 unsigned short r = (unsigned short) (r_f * 65535.0);
5683 unsigned short g = (unsigned short) (g_f * 65535.0);
5684 dst[0] = r;
5685 dst[1] = g;
5686 dst[2] = 0;
5687 dst[3] = 65535;
5688 }
5689 }
5690 hr = IDirect3DTexture9_UnlockRect(texture, 0);
5691 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %08x\n", hr);
5692
5693 hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vertexshader);
5694 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5695 hr = IDirect3DDevice9_CreatePixelShader(device, ps_1_code, &ps_1_shader);
5696 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5697 hr = IDirect3DDevice9_CreatePixelShader(device, ps_2_code, &ps_2_shader);
5698 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5699 hr = IDirect3DDevice9_CreatePixelShader(device, ps_3_code, &ps_3_shader);
5700 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5701 hr = IDirect3DDevice9_SetVertexShader(device, vertexshader);
5702 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5703 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5704
5705 hr = IDirect3DDevice9_BeginScene(device);
5706 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5707 if(SUCCEEDED(hr))
5708 {
5709 hr = IDirect3DDevice9_SetPixelShader(device, ps_1_shader);
5710 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5711 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5712 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5713
5714 hr = IDirect3DDevice9_SetPixelShader(device, ps_2_shader);
5715 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5716 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5717 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5718
5719 hr = IDirect3DDevice9_SetPixelShader(device, ps_3_shader);
5720 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5721 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5722 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5723
5724 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5725 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5726 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
5727 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
5728 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
5729 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
5730 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
5731 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
5732 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5733 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5734
5735 hr = IDirect3DDevice9_EndScene(device);
5736 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5737 }
5738 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5739 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5740
5741 color = getPixelColor(device, 160, 120);
5742 ok((color & 0x00ff0000) >= 0x00790000 && (color & 0x00ff0000) <= 0x00810000 &&
5743 (color & 0x0000ff00) == 0x0000ff00 &&
5744 (color & 0x000000ff) >= 0x000000e4 && (color & 0x000000ff) <= 0x000000e6,
5745 "ps_3_0 returned color 0x%08x, expected 0x0080ffe5\n", color);
5746 color = getPixelColor(device, 160, 360);
5747 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5748 (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003400 &&
5749 (color & 0x000000ff) == 0x00000000,
5750 "ps_1_4 returned color 0x%08x, expected 0x00203300\n", color);
5751 color = getPixelColor(device, 480, 360);
5752 ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5753 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5754 (color & 0x000000ff) == 0x00000000,
5755 "ps_2_0 returned color 0x%08x, expected 0x00203300\n", color);
5756 color = getPixelColor(device, 480, 160);
5757 ok( color == 0x00ffffff /* Nvidia driver garbage with HW vp */ || (
5758 (color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5759 (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5760 (color & 0x000000ff) == 0x00000000),
5761 "fixed function fragment processing returned color 0x%08x, expected 0x00203300\n", color);
5762
5763 /* cleanup */
5764 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
5765 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
5766 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5767 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5768 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5769 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5770 if(vertexshader) IDirect3DVertexShader9_Release(vertexshader);
5771 if(ps_1_shader) IDirect3DPixelShader9_Release(ps_1_shader);
5772 if(ps_2_shader) IDirect3DPixelShader9_Release(ps_2_shader);
5773 if(ps_3_shader) IDirect3DPixelShader9_Release(ps_3_shader);
5774 if(texture) IDirect3DTexture9_Release(texture);
5775 }
5776
5777 static void test_compare_instructions(IDirect3DDevice9 *device)
5778 {
5779 DWORD shader_sge_vec_code[] = {
5780 0xfffe0101, /* vs_1_1 */
5781 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5782 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5783 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5784 0x0000000d, 0xd00f0000, 0x80e40000, 0xa0e40001, /* sge oD0, r0, c1 */
5785 0x0000ffff /* end */
5786 };
5787 DWORD shader_slt_vec_code[] = {
5788 0xfffe0101, /* vs_1_1 */
5789 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5790 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5791 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5792 0x0000000c, 0xd00f0000, 0x80e40000, 0xa0e40001, /* slt oD0, r0, c1 */
5793 0x0000ffff /* end */
5794 };
5795 DWORD shader_sge_scalar_code[] = {
5796 0xfffe0101, /* vs_1_1 */
5797 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5798 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5799 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5800 0x0000000d, 0xd0010000, 0x80000000, 0xa0550001, /* slt oD0.r, r0.r, c1.b */
5801 0x0000000d, 0xd0020000, 0x80550000, 0xa0aa0001, /* slt oD0.g, r0.g, c1.r */
5802 0x0000000d, 0xd0040000, 0x80aa0000, 0xa0000001, /* slt oD0.b, r0.b, c1.g */
5803 0x0000ffff /* end */
5804 };
5805 DWORD shader_slt_scalar_code[] = {
5806 0xfffe0101, /* vs_1_1 */
5807 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5808 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5809 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
5810 0x0000000c, 0xd0010000, 0x80000000, 0xa0aa0001, /* slt oD0.r, r0.r, c1.b */
5811 0x0000000c, 0xd0020000, 0x80550000, 0xa0000001, /* slt oD0.g, r0.g, c1.r */
5812 0x0000000c, 0xd0040000, 0x80aa0000, 0xa0550001, /* slt oD0.b, r0.b, c1.g */
5813 0x0000ffff /* end */
5814 };
5815 IDirect3DVertexShader9 *shader_sge_vec;
5816 IDirect3DVertexShader9 *shader_slt_vec;
5817 IDirect3DVertexShader9 *shader_sge_scalar;
5818 IDirect3DVertexShader9 *shader_slt_scalar;
5819 HRESULT hr, color;
5820 float quad1[] = {
5821 -1.0, -1.0, 0.1,
5822 0.0, -1.0, 0.1,
5823 -1.0, 0.0, 0.1,
5824 0.0, 0.0, 0.1
5825 };
5826 float quad2[] = {
5827 0.0, -1.0, 0.1,
5828 1.0, -1.0, 0.1,
5829 0.0, 0.0, 0.1,
5830 1.0, 0.0, 0.1
5831 };
5832 float quad3[] = {
5833 -1.0, 0.0, 0.1,
5834 0.0, 0.0, 0.1,
5835 -1.0, 1.0, 0.1,
5836 0.0, 1.0, 0.1
5837 };
5838 float quad4[] = {
5839 0.0, 0.0, 0.1,
5840 1.0, 0.0, 0.1,
5841 0.0, 1.0, 0.1,
5842 1.0, 1.0, 0.1
5843 };
5844 const float const0[4] = {0.8, 0.2, 0.2, 0.2};
5845 const float const1[4] = {0.2, 0.8, 0.2, 0.2};
5846
5847 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5848
5849 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_vec_code, &shader_sge_vec);
5850 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5851 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_vec_code, &shader_slt_vec);
5852 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5853 hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_scalar_code, &shader_sge_scalar);
5854 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5855 hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_scalar_code, &shader_slt_scalar);
5856 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5857 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5858 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5859 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, const1, 1);
5860 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5861 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5862 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
5863
5864 hr = IDirect3DDevice9_BeginScene(device);
5865 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5866 if(SUCCEEDED(hr))
5867 {
5868 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_vec);
5869 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5870 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5871 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5872
5873 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_vec);
5874 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5875 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 3);
5876 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5877
5878 hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_scalar);
5879 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5880 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5881 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5882
5883 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5884 ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5885
5886 hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_scalar);
5887 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5888 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5889 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5890
5891 hr = IDirect3DDevice9_EndScene(device);
5892 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5893 }
5894
5895 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5896 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5897 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5898 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5899
5900 color = getPixelColor(device, 160, 360);
5901 ok(color == 0x00FF00FF, "Compare test: Quad 1(sge vec) returned color 0x%08x, expected 0x00FF00FF\n", color);
5902 color = getPixelColor(device, 480, 360);
5903 ok(color == 0x0000FF00, "Compare test: Quad 2(slt vec) returned color 0x%08x, expected 0x0000FF00\n", color);
5904 color = getPixelColor(device, 160, 120);
5905 ok(color == 0x00FFFFFF, "Compare test: Quad 3(sge scalar) returned color 0x%08x, expected 0x00FFFFFF\n", color);
5906 color = getPixelColor(device, 480, 160);
5907 ok(color == 0x000000ff, "Compare test: Quad 4(slt scalar) returned color 0x%08x, expected 0x000000ff\n", color);
5908
5909 IDirect3DVertexShader9_Release(shader_sge_vec);
5910 IDirect3DVertexShader9_Release(shader_slt_vec);
5911 IDirect3DVertexShader9_Release(shader_sge_scalar);
5912 IDirect3DVertexShader9_Release(shader_slt_scalar);
5913 }
5914
5915 static void test_vshader_input(IDirect3DDevice9 *device)
5916 {
5917 DWORD swapped_shader_code_3[] = {
5918 0xfffe0300, /* vs_3_0 */
5919 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5920 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5921 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5922 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5923 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5924 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5925 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5926 0x03000002, 0xe00f0001, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5927 0x0000ffff /* end */
5928 };
5929 DWORD swapped_shader_code_1[] = {
5930 0xfffe0101, /* vs_1_1 */
5931 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5932 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5933 0x0000001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5934 0x00000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5935 0x00000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5936 0x00000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5937 0x0000ffff /* end */
5938 };
5939 DWORD swapped_shader_code_2[] = {
5940 0xfffe0200, /* vs_2_0 */
5941 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5942 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */
5943 0x0200001f, 0x80010005, 0x900f0002, /* dcl_texcoord1 v2 */
5944 0x02000001, 0xc00f0000, 0x90e40000, /* mov o0, v0 */
5945 0x02000001, 0x800f0001, 0x90e40001, /* mov r1, v1 */
5946 0x03000002, 0xd00f0000, 0x80e40001, 0x91e40002, /* sub o1, r1, v2 */
5947 0x0000ffff /* end */
5948 };
5949 DWORD texcoord_color_shader_code_3[] = {
5950 0xfffe0300, /* vs_3_0 */
5951 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5952 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5953 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5954 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5955 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5956 0x02000001, 0xe00f0001, 0x90e40001, /* mov o1, v1 */
5957 0x0000ffff /* end */
5958 };
5959 DWORD texcoord_color_shader_code_2[] = {
5960 0xfffe0200, /* vs_2_0 */
5961 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5962 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5963 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5964 0x02000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5965 0x0000ffff /* end */
5966 };
5967 DWORD texcoord_color_shader_code_1[] = {
5968 0xfffe0101, /* vs_1_1 */
5969 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5970 0x0000001f, 0x80000005, 0x900f0001, /* dcl_texcoord v1 */
5971 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5972 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
5973 0x0000ffff /* end */
5974 };
5975 DWORD color_color_shader_code_3[] = {
5976 0xfffe0300, /* vs_3_0 */
5977 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */
5978 0x0200001f, 0x8000000a, 0xe00f0001, /* dcl_color o1 */
5979 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5980 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5981 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */
5982 0x03000005, 0xe00f0001, 0xa0e40000, 0x90e40001, /* mul o1, c0, v1 */
5983 0x0000ffff /* end */
5984 };
5985 DWORD color_color_shader_code_2[] = {
5986 0xfffe0200, /* vs_2_0 */
5987 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5988 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5989 0x02000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5990 0x03000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5991 0x0000ffff /* end */
5992 };
5993 DWORD color_color_shader_code_1[] = {
5994 0xfffe0101, /* vs_1_1 */
5995 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
5996 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color v1 */
5997 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
5998 0x00000005, 0xd00f0000, 0xa0e40000, 0x90e40001, /* mul oD0, c0, v1 */
5999 0x0000ffff /* end */
6000 };
6001 IDirect3DVertexShader9 *swapped_shader, *texcoord_color_shader, *color_color_shader;
6002 HRESULT hr;
6003 DWORD color;
6004 float quad1[] = {
6005 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6006 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6007 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6008 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6009 };
6010 float quad2[] = {
6011 0.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6012 1.0, -1.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6013 0.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6014 1.0, 0.0, 0.1, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6015 };
6016 float quad3[] = {
6017 -1.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 0.0,
6018 0.0, 0.0, 0.1, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0,
6019 -1.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 1.0, 0.0,
6020 0.0, 1.0, 0.1, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0,
6021 };
6022 float quad4[] = {
6023 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6024 1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6025 0.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6026 1.0, 1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.5, 0.0,
6027 };
6028 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd[] = {
6029 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6030 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
6031 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
6032 D3DDECL_END()
6033 };
6034 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_rightorder[] = {
6035 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6036 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
6037 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
6038 D3DDECL_END()
6039 };
6040 static const D3DVERTEXELEMENT9 decl_elements_onetexcrd[] = {
6041 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6042 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
6043 D3DDECL_END()
6044 };
6045 static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_wrongidx[] = {
6046 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6047 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
6048 {0, 28, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 2},
6049 D3DDECL_END()
6050 };
6051 static const D3DVERTEXELEMENT9 decl_elements_texcoord_color[] = {
6052 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6053 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
6054 D3DDECL_END()
6055 };
6056 static const D3DVERTEXELEMENT9 decl_elements_color_color[] = {
6057 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6058 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6059 D3DDECL_END()
6060 };
6061 static const D3DVERTEXELEMENT9 decl_elements_color_ubyte[] = {
6062 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6063 {0, 12, D3DDECLTYPE_UBYTE4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6064 D3DDECL_END()
6065 };
6066 static const D3DVERTEXELEMENT9 decl_elements_color_float[] = {
6067 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6068 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6069 D3DDECL_END()
6070 };
6071 IDirect3DVertexDeclaration9 *decl_twotexcrd, *decl_onetexcrd, *decl_twotex_wrongidx, *decl_twotexcrd_rightorder;
6072 IDirect3DVertexDeclaration9 *decl_texcoord_color, *decl_color_color, *decl_color_ubyte, *decl_color_float;
6073 unsigned int i;
6074 float normalize[4] = {1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0};
6075 float no_normalize[4] = {1.0, 1.0, 1.0, 1.0};
6076
6077 struct vertex quad1_color[] = {
6078 {-1.0, -1.0, 0.1, 0x00ff8040},
6079 { 0.0, -1.0, 0.1, 0x00ff8040},
6080 {-1.0, 0.0, 0.1, 0x00ff8040},
6081 { 0.0, 0.0, 0.1, 0x00ff8040}
6082 };
6083 struct vertex quad2_color[] = {
6084 { 0.0, -1.0, 0.1, 0x00ff8040},
6085 { 1.0, -1.0, 0.1, 0x00ff8040},
6086 { 0.0, 0.0, 0.1, 0x00ff8040},
6087 { 1.0, 0.0, 0.1, 0x00ff8040}
6088 };
6089 struct vertex quad3_color[] = {
6090 {-1.0, 0.0, 0.1, 0x00ff8040},
6091 { 0.0, 0.0, 0.1, 0x00ff8040},
6092 {-1.0, 1.0, 0.1, 0x00ff8040},
6093 { 0.0, 1.0, 0.1, 0x00ff8040}
6094 };
6095 float quad4_color[] = {
6096 0.0, 0.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6097 1.0, 0.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6098 0.0, 1.0, 0.1, 1.0, 1.0, 0.0, 0.0,
6099 1.0, 1.0, 0.1, 1.0, 1.0, 0.0, 1.0,
6100 };
6101
6102 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd, &decl_twotexcrd);
6103 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6104 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_onetexcrd, &decl_onetexcrd);
6105 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6106 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_wrongidx, &decl_twotex_wrongidx);
6107 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6108 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_rightorder, &decl_twotexcrd_rightorder);
6109 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6110
6111 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_texcoord_color, &decl_texcoord_color);
6112 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6113 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_color, &decl_color_color);
6114 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6115 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_ubyte, &decl_color_ubyte);
6116 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6117 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_float, &decl_color_float);
6118 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6119
6120 for(i = 1; i <= 3; i++) {
6121 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
6122 if(i == 3) {
6123 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_3, &swapped_shader);
6124 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6125 } else if(i == 2){
6126 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_2, &swapped_shader);
6127 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6128 } else if(i == 1) {
6129 hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_1, &swapped_shader);
6130 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6131 }
6132
6133 hr = IDirect3DDevice9_BeginScene(device);
6134 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6135 if(SUCCEEDED(hr))
6136 {
6137 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6138 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6139
6140 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6141 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6142 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 11);
6143 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6144
6145 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6146 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6147 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 11);
6148 if(i == 3 || i == 2) {
6149 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6150 } else if(i == 1) {
6151 /* Succeeds or fails, depending on SW or HW vertex processing */
6152 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6153 }
6154
6155 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd_rightorder);
6156 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6157 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 11);
6158 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6159
6160 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotex_wrongidx);
6161 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6162 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 11);
6163 if(i == 3 || i == 2) {
6164 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6165 } else if(i == 1) {
6166 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = 1\n", hr);
6167 }
6168
6169 hr = IDirect3DDevice9_EndScene(device);
6170 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6171 }
6172
6173 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6174 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6175
6176 if(i == 3 || i == 2) {
6177 color = getPixelColor(device, 160, 360);
6178 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x80), 1),
6179 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6180
6181 /* The last value of the read but undefined stream is used, it is 0x00. The defined input is vec4(1, 0, 0, 0) */
6182 color = getPixelColor(device, 480, 360);
6183 ok(color == 0x00FFFF00 || color ==0x00FF0000,
6184 "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6185 color = getPixelColor(device, 160, 120);
6186 /* Same as above, accept both the last used value and 0.0 for the undefined streams */
6187 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x80), 1) || color == D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x00),
6188 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6189
6190 color = getPixelColor(device, 480, 160);
6191 ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6192 } else if(i == 1) {
6193 color = getPixelColor(device, 160, 360);
6194 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x80), 1),
6195 "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6196 color = getPixelColor(device, 480, 360);
6197 /* Accept the clear color as well in this case, since SW VP returns an error */
6198 ok(color == 0x00FFFF00 || color == 0x00FF0000, "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6199 color = getPixelColor(device, 160, 120);
6200 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x80), 1) || color == D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x00),
6201 "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6202 color = getPixelColor(device, 480, 160);
6203 ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6204 }
6205
6206 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff808080, 0.0, 0);
6207 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6208
6209 /* Now find out if the whole streams are re-read, or just the last active value for the
6210 * vertices is used.
6211 */
6212 hr = IDirect3DDevice9_BeginScene(device);
6213 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6214 if(SUCCEEDED(hr))
6215 {
6216 float quad1_modified[] = {
6217 -1.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0,
6218 0.0, -1.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, 0.0,
6219 -1.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0,
6220 0.0, 0.0, 0.1, 1.0, 0.0, 1.0, 0.0, -1.0, -1.0, -1.0, 0.0,
6221 };
6222 float quad2_modified[] = {
6223 0.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6224 1.0, -1.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6225 0.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6226 1.0, 0.0, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
6227 };
6228
6229 hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6230 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6231
6232 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6233 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6234 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 3, quad1_modified, sizeof(float) * 11);
6235 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6236
6237 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6238 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6239 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_modified, sizeof(float) * 11);
6240 if(i == 3 || i == 2) {
6241 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6242 } else if(i == 1) {
6243 /* Succeeds or fails, depending on SW or HW vertex processing */
6244 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6245 }
6246
6247 hr = IDirect3DDevice9_EndScene(device);
6248 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6249 }
6250 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6251 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6252
6253 color = getPixelColor(device, 480, 350);
6254 /* vs_1_1 may fail, accept the clear color. Some drivers also set the undefined streams to 0, accept that
6255 * as well.
6256 *
6257 * NOTE: This test fails on the reference rasterizer. In the refrast, the 4 vertices have different colors,
6258 * i.e., the whole old stream is read, and not just the last used attribute. Some games require that this
6259 * does *not* happen, otherwise they can crash because of a read from a bad pointer, so do not accept the
6260 * refrast's result.
6261 *
6262 * A test app for this behavior is Half Life 2 Episode 2 in dxlevel 95, and related games(Portal, TF2).
6263 */
6264 ok(color == 0x000000FF || color == 0x00808080 || color == 0x00000000,
6265 "Input test: Quad 2(different colors) returned color 0x%08x, expected 0x000000FF, 0x00808080 or 0x00000000\n", color);
6266 color = getPixelColor(device, 160, 120);
6267
6268 IDirect3DDevice9_SetVertexShader(device, NULL);
6269 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6270
6271 IDirect3DVertexShader9_Release(swapped_shader);
6272 }
6273
6274 for(i = 1; i <= 3; i++) {
6275 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
6276 if(i == 3) {
6277 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_3, &texcoord_color_shader);
6278 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6279 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_3, &color_color_shader);
6280 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6281 } else if(i == 2){
6282 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_2, &texcoord_color_shader);
6283 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6284 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_2, &color_color_shader);
6285 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6286 } else if(i == 1) {
6287 hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_1, &texcoord_color_shader);
6288 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6289 hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_1, &color_color_shader);
6290 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6291 }
6292
6293 hr = IDirect3DDevice9_BeginScene(device);
6294 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6295 if(SUCCEEDED(hr))
6296 {
6297 hr = IDirect3DDevice9_SetVertexShader(device, texcoord_color_shader);
6298 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6299 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_texcoord_color);
6300 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6301 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1_color, sizeof(quad1_color[0]));
6302 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6303
6304 hr = IDirect3DDevice9_SetVertexShader(device, color_color_shader);
6305 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6306
6307 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, normalize, 1);
6308 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6309 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_ubyte);
6310 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6311 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_color, sizeof(quad2_color[0]));
6312 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6313
6314 hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, no_normalize, 1);
6315 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6316 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_color);
6317 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6318 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3_color, sizeof(quad3_color[0]));
6319 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6320
6321 hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_float);
6322 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6323 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4_color, sizeof(float) * 7);
6324 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6325
6326 hr = IDirect3DDevice9_EndScene(device);
6327 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6328 }
6329 IDirect3DDevice9_SetVertexShader(device, NULL);
6330 IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6331
6332 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6333 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6334
6335 color = getPixelColor(device, 160, 360);
6336 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x80, 0x40), 1),
6337 "Input test: Quad 1(color-texcoord) returned color 0x%08x, expected 0x00ff8040\n", color);
6338 color = getPixelColor(device, 480, 360);
6339 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x40, 0x80, 0xff), 1),
6340 "Input test: Quad 2(color-ubyte) returned color 0x%08x, expected 0x004080ff\n", color);
6341 color = getPixelColor(device, 160, 120);
6342 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x80, 0x40), 1),
6343 "Input test: Quad 3(color-color) returned color 0x%08x, expected 0x00ff8040\n", color);
6344 color = getPixelColor(device, 480, 160);
6345 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x00), 1),
6346 "Input test: Quad 4(color-float) returned color 0x%08x, expected 0x00FFFF00\n", color);
6347
6348 IDirect3DVertexShader9_Release(texcoord_color_shader);
6349 IDirect3DVertexShader9_Release(color_color_shader);
6350 }
6351
6352 IDirect3DVertexDeclaration9_Release(decl_twotexcrd);
6353 IDirect3DVertexDeclaration9_Release(decl_onetexcrd);
6354 IDirect3DVertexDeclaration9_Release(decl_twotex_wrongidx);
6355 IDirect3DVertexDeclaration9_Release(decl_twotexcrd_rightorder);
6356
6357 IDirect3DVertexDeclaration9_Release(decl_texcoord_color);
6358 IDirect3DVertexDeclaration9_Release(decl_color_color);
6359 IDirect3DVertexDeclaration9_Release(decl_color_ubyte);
6360 IDirect3DVertexDeclaration9_Release(decl_color_float);
6361 }
6362
6363 static void srgbtexture_test(IDirect3DDevice9 *device)
6364 {
6365 /* Fill a texture with 0x7f (~ .5), and then turn on the D3DSAMP_SRGBTEXTURE
6366 * texture stage state to render a quad using that texture. The resulting
6367 * color components should be 0x36 (~ 0.21), per this formula:
6368 * linear_color = ((srgb_color + 0.055) / 1.055) ^ 2.4
6369 * This is true where srgb_color > 0.04045.
6370 */
6371 IDirect3D9 *d3d = NULL;
6372 HRESULT hr;
6373 LPDIRECT3DTEXTURE9 texture = NULL;
6374 LPDIRECT3DSURFACE9 surface = NULL;
6375 D3DLOCKED_RECT lr;
6376 DWORD color;
6377 float quad[] = {
6378 -1.0, 1.0, 0.0, 0.0, 0.0,
6379 1.0, 1.0, 0.0, 1.0, 0.0,
6380 -1.0, -1.0, 0.0, 0.0, 1.0,
6381 1.0, -1.0, 0.0, 1.0, 1.0,
6382 };
6383
6384
6385 memset(&lr, 0, sizeof(lr));
6386 IDirect3DDevice9_GetDirect3D(device, &d3d);
6387 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6388 D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_TEXTURE,
6389 D3DFMT_A8R8G8B8) != D3D_OK) {
6390 skip("D3DFMT_A8R8G8B8 textures with SRGBREAD not supported\n");
6391 goto out;
6392 }
6393
6394 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0,
6395 D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
6396 &texture, NULL);
6397 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
6398 if(!texture) {
6399 skip("Failed to create A8R8G8B8 texture with SRGBREAD\n");
6400 goto out;
6401 }
6402 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
6403 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
6404
6405 fill_surface(surface, 0xff7f7f7f);
6406 IDirect3DSurface9_Release(surface);
6407
6408 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6409 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6410 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
6411 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
6412
6413 hr = IDirect3DDevice9_BeginScene(device);
6414 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
6415 if(SUCCEEDED(hr))
6416 {
6417 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, TRUE);
6418 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
6419
6420 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6421 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
6422
6423
6424 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
6425 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with %08x\n", hr);
6426
6427 hr = IDirect3DDevice9_EndScene(device);
6428 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
6429 }
6430
6431 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6432 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
6433 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
6434 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
6435
6436 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6437 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6438
6439 color = getPixelColor(device, 320, 240);
6440 ok(color == 0x00363636 || color == 0x00373737, "srgb quad has color %08x, expected 0x00363636\n", color);
6441
6442 out:
6443 if(texture) IDirect3DTexture9_Release(texture);
6444 IDirect3D9_Release(d3d);
6445 }
6446
6447 static void shademode_test(IDirect3DDevice9 *device)
6448 {
6449 /* Render a quad and try all of the different fixed function shading models. */
6450 HRESULT hr;
6451 DWORD color0, color1;
6452 DWORD color0_gouraud = 0, color1_gouraud = 0;
6453 DWORD shademode = D3DSHADE_FLAT;
6454 DWORD primtype = D3DPT_TRIANGLESTRIP;
6455 LPVOID data = NULL;
6456 LPDIRECT3DVERTEXBUFFER9 vb_strip = NULL;
6457 LPDIRECT3DVERTEXBUFFER9 vb_list = NULL;
6458 UINT i, j;
6459 struct vertex quad_strip[] =
6460 {
6461 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6462 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6463 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6464 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6465 };
6466 struct vertex quad_list[] =
6467 {
6468 {-1.0f, -1.0f, 0.0f, 0xffff0000 },
6469 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6470 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6471
6472 {-1.0f, 1.0f, 0.0f, 0xff00ff00 },
6473 { 1.0f, -1.0f, 0.0f, 0xff0000ff },
6474 { 1.0f, 1.0f, 0.0f, 0xffffffff }
6475 };
6476
6477 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_strip),
6478 0, 0, D3DPOOL_MANAGED, &vb_strip, NULL);
6479 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
6480 if (FAILED(hr)) goto bail;
6481
6482 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_list),
6483 0, 0, D3DPOOL_MANAGED, &vb_list, NULL);
6484 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
6485 if (FAILED(hr)) goto bail;
6486
6487 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6488 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6489
6490 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6491 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
6492
6493 hr = IDirect3DVertexBuffer9_Lock(vb_strip, 0, sizeof(quad_strip), (void **) &data, 0);
6494 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
6495 memcpy(data, quad_strip, sizeof(quad_strip));
6496 hr = IDirect3DVertexBuffer9_Unlock(vb_strip);
6497 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
6498
6499 hr = IDirect3DVertexBuffer9_Lock(vb_list, 0, sizeof(quad_list), (void **) &data, 0);
6500 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
6501 memcpy(data, quad_list, sizeof(quad_list));
6502 hr = IDirect3DVertexBuffer9_Unlock(vb_list);
6503 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
6504
6505 /* Try it first with a TRIANGLESTRIP. Do it with different geometry because
6506 * the color fixups we have to do for FLAT shading will be dependent on that. */
6507 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_strip, 0, sizeof(quad_strip[0]));
6508 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6509
6510 /* First loop uses a TRIANGLESTRIP geometry, 2nd uses a TRIANGLELIST */
6511 for (j=0; j<2; j++) {
6512
6513 /* Inner loop just changes the D3DRS_SHADEMODE */
6514 for (i=0; i<3; i++) {
6515 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6516 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6517
6518 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, shademode);
6519 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6520
6521 hr = IDirect3DDevice9_BeginScene(device);
6522 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
6523 if(SUCCEEDED(hr))
6524 {
6525 hr = IDirect3DDevice9_DrawPrimitive(device, primtype, 0, 2);
6526 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed with %08x\n", hr);
6527
6528 hr = IDirect3DDevice9_EndScene(device);
6529 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
6530 }
6531
6532 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6533 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6534
6535 /* Sample two spots from the output */
6536 color0 = getPixelColor(device, 100, 100); /* Inside first triangle */
6537 color1 = getPixelColor(device, 500, 350); /* Inside second triangle */
6538 switch(shademode) {
6539 case D3DSHADE_FLAT:
6540 /* Should take the color of the first vertex of each triangle */
6541 todo_wine ok(color0 == 0x00ff0000, "FLAT shading has color0 %08x, expected 0x00ff0000 (todo)\n", color0);
6542 todo_wine ok(color1 == 0x0000ff00, "FLAT shading has color1 %08x, expected 0x0000ff00 (todo)\n", color1);
6543 shademode = D3DSHADE_GOURAUD;
6544 break;
6545 case D3DSHADE_GOURAUD:
6546 /* Should be an interpolated blend */
6547
6548 ok(color_match(color0, D3DCOLOR_ARGB(0x00, 0x0d, 0xca, 0x28), 2),
6549 "GOURAUD shading has color0 %08x, expected 0x00dca28\n", color0);
6550 ok(color_match(color1, D3DCOLOR_ARGB(0x00, 0x0d, 0x45, 0xc7), 2),
6551 "GOURAUD shading has color1 %08x, expected 0x000d45c7\n", color1);
6552
6553 color0_gouraud = color0;
6554 color1_gouraud = color1;
6555
6556 shademode = D3DSHADE_PHONG;
6557 break;
6558 case D3DSHADE_PHONG:
6559 /* Should be the same as GOURAUD, since no hardware implements this */
6560 ok(color_match(color0, D3DCOLOR_ARGB(0x00, 0x0d, 0xca, 0x28), 2),
6561 "PHONG shading has color0 %08x, expected 0x000dca28\n", color0);
6562 ok(color_match(color1, D3DCOLOR_ARGB(0x00, 0x0d, 0x45, 0xc7), 2),
6563 "PHONG shading has color1 %08x, expected 0x000d45c7\n", color1);
6564
6565 ok(color0 == color0_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6566 color0_gouraud, color0);
6567 ok(color1 == color1_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6568 color1_gouraud, color1);
6569 break;
6570 }
6571 }
6572 /* Now, do it all over again with a TRIANGLELIST */
6573 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_list, 0, sizeof(quad_list[0]));
6574 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6575 primtype = D3DPT_TRIANGLELIST;
6576 shademode = D3DSHADE_FLAT;
6577 }
6578
6579 bail:
6580 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
6581 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6582 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
6583 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6584
6585 if (vb_strip)
6586 IDirect3DVertexBuffer9_Release(vb_strip);
6587 if (vb_list)
6588 IDirect3DVertexBuffer9_Release(vb_list);
6589 }
6590
6591
6592 static void fog_srgbwrite_test(IDirect3DDevice9 *device)
6593 {
6594 /* Draw a black quad, half fogged with white fog -> grey color. Enable sRGB writing.
6595 * if sRGB writing is applied before fogging, the 0.0 will be multiplied with ~ 12.92, so still
6596 * stay 0.0. After that the fog gives 0.5. If sRGB writing is applied after fogging, the
6597 * 0.5 will run through the alternative path(0^5 ^ 0.41666 * 1.055 - 0.055), resulting in approx.
6598 * 0.73
6599 *
6600 * At the time of this writing, wined3d could not apply sRGB correction to fixed function rendering,
6601 * so use shaders for this task
6602 */
6603 IDirect3DPixelShader9 *pshader;
6604 IDirect3DVertexShader9 *vshader;
6605 IDirect3D9 *d3d;
6606 DWORD vshader_code[] = {
6607 0xfffe0101, /* vs_1_1 */
6608 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
6609 0x00000051, 0xa00f0000, 0x3f000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0 */
6610 0x00000001, 0xc00f0000, 0x90e40000, /* mov oPos, v0 */
6611 0x00000001, 0xc00f0001, 0xa0000000, /* mov oFog, c0.x */
6612 0x0000ffff /* end */
6613 };
6614 DWORD pshader_code[] = {
6615 0xffff0101, /* ps_1_1 */
6616 0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
6617 0x00000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
6618 0x0000ffff /* end */
6619 };
6620 const float quad[] = {
6621 -1.0, -1.0, 0.1,
6622 1.0, -1.0, 0.1,
6623 -1.0, 1.0, 0.1,
6624 1.0, 1.0, 0.1
6625 };
6626 HRESULT hr;
6627 DWORD color;
6628
6629 IDirect3DDevice9_GetDirect3D(device, &d3d);
6630 /* Ask for srgb writing on D3DRTYPE_TEXTURE. Some Windows drivers do not report it on surfaces.
6631 * For some not entirely understood reasons D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE
6632 * passes on surfaces, while asking for SRGBWRITE alone fails. Textures advertize srgb writing
6633 * alone as well, so use that since it is not the point of this test to show how CheckDeviceFormat
6634 * works
6635 */
6636 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6637 D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE,
6638 D3DRTYPE_TEXTURE, D3DFMT_A8R8G8B8) != D3D_OK) {
6639 skip("No SRGBWRITEENABLE support on D3DFMT_X8R8G8B8\n");
6640 IDirect3D9_Release(d3d);
6641 return;
6642 }
6643 IDirect3D9_Release(d3d);
6644
6645 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
6646 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6647
6648 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
6649 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6650 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
6651 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6652 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
6653 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6654 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xffffffff);
6655 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6656 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, TRUE);
6657 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6658
6659 hr = IDirect3DDevice9_CreateVertexShader(device, vshader_code, &vshader);
6660 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6661 hr = IDirect3DDevice9_CreatePixelShader(device, pshader_code, &pshader);
6662 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
6663 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
6664 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
6665 hr = IDirect3DDevice9_SetVertexShader(device, vshader);
6666 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6667 hr = IDirect3DDevice9_SetPixelShader(device, pshader);
6668 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
6669
6670 hr = IDirect3DDevice9_BeginScene(device);
6671 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6672 if(SUCCEEDED(hr)) {
6673 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 3);
6674 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6675
6676 hr = IDirect3DDevice9_EndScene(device);
6677 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6678 }
6679
6680 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
6681 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6682 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
6683 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
6684 IDirect3DPixelShader9_Release(pshader);
6685 IDirect3DVertexShader9_Release(vshader);
6686
6687 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
6688 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6689 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, FALSE);
6690 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6691
6692 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6693 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6694 color = getPixelColor(device, 160, 360);
6695 ok(color == 0x00808080 || color == 0x007f7f7f || color == 0x00818181,
6696 "Fog with D3DRS_SRGBWRITEENABLE returned color 0x%08x, expected 0x00808080\n", color);
6697 }
6698
6699 static void alpha_test(IDirect3DDevice9 *device)
6700 {
6701 HRESULT hr;
6702 IDirect3DTexture9 *offscreenTexture;
6703 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
6704 DWORD color;
6705
6706 struct vertex quad1[] =
6707 {
6708 {-1.0f, -1.0f, 0.1f, 0x4000ff00},
6709 {-1.0f, 0.0f, 0.1f, 0x4000ff00},
6710 { 1.0f, -1.0f, 0.1f, 0x4000ff00},
6711 { 1.0f, 0.0f, 0.1f, 0x4000ff00},
6712 };
6713 struct vertex quad2[] =
6714 {
6715 {-1.0f, 0.0f, 0.1f, 0xc00000ff},
6716 {-1.0f, 1.0f, 0.1f, 0xc00000ff},
6717 { 1.0f, 0.0f, 0.1f, 0xc00000ff},
6718 { 1.0f, 1.0f, 0.1f, 0xc00000ff},
6719 };
6720 static const float composite_quad[][5] = {
6721 { 0.0f, -1.0f, 0.1f, 0.0f, 1.0f},
6722 { 0.0f, 1.0f, 0.1f, 0.0f, 0.0f},
6723 { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f},
6724 { 1.0f, 1.0f, 0.1f, 1.0f, 0.0f},
6725 };
6726
6727 /* Clear the render target with alpha = 0.5 */
6728 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6729 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6730
6731 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
6732 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %#08x\n", hr);
6733
6734 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
6735 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6736 if(!backbuffer) {
6737 goto out;
6738 }
6739
6740 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
6741 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
6742 if(!offscreen) {
6743 goto out;
6744 }
6745
6746 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6747 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6748
6749 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
6750 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
6751 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
6752 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
6753 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
6754 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
6755 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
6756 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
6757 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6758 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6759
6760 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
6761 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6762 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
6763
6764 /* Draw two quads, one with src alpha blending, one with dest alpha blending. */
6765 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6766 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6767 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6768 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6769 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6770 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6771
6772 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6773 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6774 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6775 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6776 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6777 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6778
6779 /* Switch to the offscreen buffer, and redo the testing. The offscreen render target
6780 * doesn't have an alpha channel. DESTALPHA and INVDESTALPHA "don't work" on render
6781 * targets without alpha channel, they give essentially ZERO and ONE blend factors. */
6782 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
6783 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6784 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6785 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6786
6787 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6788 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6789 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6790 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6791 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6792 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6793
6794 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6795 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6796 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6797 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6798 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6799 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6800
6801 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
6802 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6803
6804 /* Render the offscreen texture onto the frame buffer to be able to compare it regularly.
6805 * Disable alpha blending for the final composition
6806 */
6807 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
6808 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6809 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6810 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6811
6812 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
6813 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6814 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, composite_quad, sizeof(float) * 5);
6815 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6816 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6817 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6818
6819 hr = IDirect3DDevice9_EndScene(device);
6820 ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
6821 }
6822
6823 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6824
6825 color = getPixelColor(device, 160, 360);
6826 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xbf, 0x40, 0x00), 1),
6827 "SRCALPHA on frame buffer returned color %08x, expected 0x00bf4000\n", color);
6828
6829 color = getPixelColor(device, 160, 120);
6830 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x7f, 0x00, 0x80), 2),
6831 "DSTALPHA on frame buffer returned color %08x, expected 0x007f0080\n", color);
6832
6833 color = getPixelColor(device, 480, 360);
6834 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xbf, 0x40, 0x00), 1),
6835 "SRCALPHA on texture returned color %08x, expected 0x00bf4000\n", color);
6836
6837 color = getPixelColor(device, 480, 120);
6838 ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x00, 0x00, 0xff), 1),
6839 "DSTALPHA on texture returned color %08x, expected 0x000000ff\n", color);
6840
6841 out:
6842 /* restore things */
6843 if(backbuffer) {
6844 IDirect3DSurface9_Release(backbuffer);
6845 }
6846 if(offscreenTexture) {
6847 IDirect3DTexture9_Release(offscreenTexture);
6848 }
6849 if(offscreen) {
6850 IDirect3DSurface9_Release(offscreen);
6851 }
6852 }
6853
6854 struct vertex_shortcolor {
6855 float x, y, z;
6856 unsigned short r, g, b, a;
6857 };
6858 struct vertex_floatcolor {
6859 float x, y, z;
6860 float r, g, b, a;
6861 };
6862
6863 static void fixed_function_decl_test(IDirect3DDevice9 *device)
6864 {
6865 HRESULT hr;
6866 BOOL s_ok, ub_ok, f_ok;
6867 DWORD color, size, i;
6868 void *data;
6869 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor[] = {
6870 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6871 {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6872 D3DDECL_END()
6873 };
6874 static const D3DVERTEXELEMENT9 decl_elements_d3dcolor_2streams[] = {
6875 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6876 {1, 0, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6877 D3DDECL_END()
6878 };
6879 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n[] = {
6880 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6881 {0, 12, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6882 D3DDECL_END()
6883 };
6884 static const D3DVERTEXELEMENT9 decl_elements_ubyte4n_2streams[] = {
6885 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6886 {1, 0, D3DDECLTYPE_UBYTE4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6887 D3DDECL_END()
6888 };
6889 static const D3DVERTEXELEMENT9 decl_elements_short4[] = {
6890 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6891 {0, 12, D3DDECLTYPE_USHORT4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6892 D3DDECL_END()
6893 };
6894 static const D3DVERTEXELEMENT9 decl_elements_float[] = {
6895 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
6896 {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6897 D3DDECL_END()
6898 };
6899 static const D3DVERTEXELEMENT9 decl_elements_positiont[] = {
6900 {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
6901 {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
6902 D3DDECL_END()
6903 };
6904 IDirect3DVertexDeclaration9 *dcl_float = NULL, *dcl_short = NULL, *dcl_ubyte = NULL, *dcl_color = NULL;
6905 IDirect3DVertexDeclaration9 *dcl_color_2 = NULL, *dcl_ubyte_2 = NULL, *dcl_positiont;
6906 IDirect3DVertexBuffer9 *vb, *vb2;
6907 struct vertex quad1[] = /* D3DCOLOR */
6908 {
6909 {-1.0f, -1.0f, 0.1f, 0x00ffff00},
6910 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6911 { 0.0f, -1.0f, 0.1f, 0x00ffff00},
6912 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6913 };
6914 struct vertex quad2[] = /* UBYTE4N */
6915 {
6916 {-1.0f, 0.0f, 0.1f, 0x00ffff00},
6917 {-1.0f, 1.0f, 0.1f, 0x00ffff00},
6918 { 0.0f, 0.0f, 0.1f, 0x00ffff00},
6919 { 0.0f, 1.0f, 0.1f, 0x00ffff00},
6920 };
6921 struct vertex_shortcolor quad3[] = /* short */
6922 {
6923 { 0.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6924 { 0.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6925 { 1.0f, -1.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6926 { 1.0f, 0.0f, 0.1f, 0x0000, 0x0000, 0xffff, 0xffff},
6927 };
6928 struct vertex_floatcolor quad4[] =
6929 {
6930 { 0.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6931 { 0.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6932 { 1.0f, 0.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6933 { 1.0f, 1.0f, 0.1f, 1.0, 0.0, 0.0, 0.0},
6934 };
6935 DWORD colors[] = {
6936 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6937 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6938 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6939 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6940 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6941 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6942 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6943 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6944 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6945 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6946 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6947 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6948 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6949 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6950 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6951 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00ffffff,
6952 };
6953 float quads[] = {
6954 -1.0, -1.0, 0.1,
6955 -1.0, 0.0, 0.1,
6956 0.0, -1.0, 0.1,
6957 0.0, 0.0, 0.1,
6958
6959 0.0, -1.0, 0.1,
6960 0.0, 0.0, 0.1,
6961 1.0, -1.0, 0.1,
6962 1.0, 0.0, 0.1,
6963
6964 0.0, 0.0, 0.1,
6965 0.0, 1.0, 0.1,
6966 1.0, 0.0, 0.1,
6967 1.0, 1.0, 0.1,
6968
6969 -1.0, 0.0, 0.1,
6970 -1.0, 1.0, 0.1,
6971 0.0, 0.0, 0.1,
6972 0.0, 1.0, 0.1
6973 };
6974 struct tvertex quad_transformed[] = {
6975 { 90, 110, 0.1, 2.0, 0x00ffff00},
6976 { 570, 110, 0.1, 2.0, 0x00ffff00},
6977 { 90, 300, 0.1, 2.0, 0x00ffff00},
6978 { 570, 300, 0.1, 2.0, 0x00ffff00}
6979 };
6980 D3DCAPS9 caps;
6981
6982 memset(&caps, 0, sizeof(caps));
6983 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
6984 ok(hr == D3D_OK, "GetDeviceCaps failed, hr = %08x\n", hr);
6985
6986 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6987 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6988
6989 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor, &dcl_color);
6990 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6991 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_short4, &dcl_short);
6992 ok(SUCCEEDED(hr) || hr == E_FAIL, "CreateVertexDeclaration failed (%08x)\n", hr);
6993 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_float, &dcl_float);
6994 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6995 if(caps.DeclTypes & D3DDTCAPS_UBYTE4N) {
6996 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n_2streams, &dcl_ubyte_2);
6997 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
6998 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n, &dcl_ubyte);
6999 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7000 } else {
7001 trace("D3DDTCAPS_UBYTE4N not supported\n");
7002 dcl_ubyte_2 = NULL;
7003 dcl_ubyte = NULL;
7004 }
7005 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor_2streams, &dcl_color_2);
7006 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7007 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_positiont, &dcl_positiont);
7008 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7009
7010 size = max(sizeof(quad1), max(sizeof(quad2), max(sizeof(quad3), max(sizeof(quad4), sizeof(quads)))));
7011 hr = IDirect3DDevice9_CreateVertexBuffer(device, size,
7012 0, 0, D3DPOOL_MANAGED, &vb, NULL);
7013 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
7014
7015 hr = IDirect3DDevice9_BeginScene(device);
7016 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7017 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7018 if(SUCCEEDED(hr)) {
7019 if(dcl_color) {
7020 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7021 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7022 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
7023 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7024 }
7025
7026 /* Tests with non-standard fixed function types fail on the refrast. The ATI driver partially
7027 * accepts them, the nvidia driver accepts them all. All those differences even though we're
7028 * using software vertex processing. Doh!
7029 */
7030 if(dcl_ubyte) {
7031 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7032 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7033 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
7034 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7035 ub_ok = SUCCEEDED(hr);
7036 }
7037
7038 if(dcl_short) {
7039 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7040 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7041 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(quad3[0]));
7042 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7043 s_ok = SUCCEEDED(hr);
7044 }
7045
7046 if(dcl_float) {
7047 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7048 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7049 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(quad4[0]));
7050 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7051 f_ok = SUCCEEDED(hr);
7052 }
7053
7054 hr = IDirect3DDevice9_EndScene(device);
7055 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7056 }
7057
7058 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7059 if(dcl_short) {
7060 color = getPixelColor(device, 480, 360);
7061 ok(color == 0x000000ff || !s_ok,
7062 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7063 }
7064 if(dcl_ubyte) {
7065 color = getPixelColor(device, 160, 120);
7066 ok(color == 0x0000ffff || !ub_ok,
7067 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7068 }
7069 if(dcl_color) {
7070 color = getPixelColor(device, 160, 360);
7071 ok(color == 0x00ffff00,
7072 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7073 }
7074 if(dcl_float) {
7075 color = getPixelColor(device, 480, 120);
7076 ok(color == 0x00ff0000 || !f_ok,
7077 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7078 }
7079
7080 /* The following test with vertex buffers doesn't serve to find out new information from windows.
7081 * It is a plain regression test because wined3d uses different codepaths for attribute conversion
7082 * with vertex buffers. It makes sure that the vertex buffer one works, while the above tests
7083 * whether the immediate mode code works
7084 */
7085 f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7086 hr = IDirect3DDevice9_BeginScene(device);
7087 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7088 if(SUCCEEDED(hr)) {
7089 if(dcl_color) {
7090 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad1), (void **) &data, 0);
7091 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7092 memcpy(data, quad1, sizeof(quad1));
7093 hr = IDirect3DVertexBuffer9_Unlock(vb);
7094 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7095 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7096 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7097 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad1[0]));
7098 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7099 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7100 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7101 }
7102
7103 if(dcl_ubyte) {
7104 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad2), (void **) &data, 0);
7105 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7106 memcpy(data, quad2, sizeof(quad2));
7107 hr = IDirect3DVertexBuffer9_Unlock(vb);
7108 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7109 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7110 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7111 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad2[0]));
7112 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7113 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7114 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7115 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7116 ub_ok = SUCCEEDED(hr);
7117 }
7118
7119 if(dcl_short) {
7120 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad3), (void **) &data, 0);
7121 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7122 memcpy(data, quad3, sizeof(quad3));
7123 hr = IDirect3DVertexBuffer9_Unlock(vb);
7124 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7125 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7126 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7127 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad3[0]));
7128 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7129 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7130 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7131 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7132 s_ok = SUCCEEDED(hr);
7133 }
7134
7135 if(dcl_float) {
7136 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad4), (void **) &data, 0);
7137 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7138 memcpy(data, quad4, sizeof(quad4));
7139 hr = IDirect3DVertexBuffer9_Unlock(vb);
7140 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7141 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7142 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7143 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad4[0]));
7144 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7145 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7146 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7147 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7148 f_ok = SUCCEEDED(hr);
7149 }
7150
7151 hr = IDirect3DDevice9_EndScene(device);
7152 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7153 }
7154
7155 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7156 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7157 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7158 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7159
7160 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7161 if(dcl_short) {
7162 color = getPixelColor(device, 480, 360);
7163 ok(color == 0x000000ff || !s_ok,
7164 "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7165 }
7166 if(dcl_ubyte) {
7167 color = getPixelColor(device, 160, 120);
7168 ok(color == 0x0000ffff || !ub_ok,
7169 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7170 }
7171 if(dcl_color) {
7172 color = getPixelColor(device, 160, 360);
7173 ok(color == 0x00ffff00,
7174 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7175 }
7176 if(dcl_float) {
7177 color = getPixelColor(device, 480, 120);
7178 ok(color == 0x00ff0000 || !f_ok,
7179 "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7180 }
7181
7182 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7183 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
7184
7185 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad_transformed), (void **) &data, 0);
7186 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7187 memcpy(data, quad_transformed, sizeof(quad_transformed));
7188 hr = IDirect3DVertexBuffer9_Unlock(vb);
7189 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7190
7191 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_positiont);
7192 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7193
7194 hr = IDirect3DDevice9_BeginScene(device);
7195 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7196 if(SUCCEEDED(hr)) {
7197 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad_transformed[0]));
7198 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7199 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7200 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7201
7202 hr = IDirect3DDevice9_EndScene(device);
7203 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7204 }
7205
7206 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7207 color = getPixelColor(device, 88, 108);
7208 ok(color == 0x000000ff,
7209 "pixel 88/108 has color %08x, expected 0x000000ff\n", color);
7210 color = getPixelColor(device, 92, 108);
7211 ok(color == 0x000000ff,
7212 "pixel 92/108 has color %08x, expected 0x000000ff\n", color);
7213 color = getPixelColor(device, 88, 112);
7214 ok(color == 0x000000ff,
7215 "pixel 88/112 has color %08x, expected 0x000000ff\n", color);
7216 color = getPixelColor(device, 92, 112);
7217 ok(color == 0x00ffff00,
7218 "pixel 92/112 has color %08x, expected 0x00ffff00\n", color);
7219
7220 color = getPixelColor(device, 568, 108);
7221 ok(color == 0x000000ff,
7222 "pixel 568/108 has color %08x, expected 0x000000ff\n", color);
7223 color = getPixelColor(device, 572, 108);
7224 ok(color == 0x000000ff,
7225 "pixel 572/108 has color %08x, expected 0x000000ff\n", color);
7226 color = getPixelColor(device, 568, 112);
7227 ok(color == 0x00ffff00,
7228 "pixel 568/112 has color %08x, expected 0x00ffff00\n", color);
7229 color = getPixelColor(device, 572, 112);
7230 ok(color == 0x000000ff,
7231 "pixel 572/112 has color %08x, expected 0x000000ff\n", color);
7232
7233 color = getPixelColor(device, 88, 298);
7234 ok(color == 0x000000ff,
7235 "pixel 88/298 has color %08x, expected 0x000000ff\n", color);
7236 color = getPixelColor(device, 92, 298);
7237 ok(color == 0x00ffff00,
7238 "pixel 92/298 has color %08x, expected 0x00ffff00\n", color);
7239 color = getPixelColor(device, 88, 302);
7240 ok(color == 0x000000ff,
7241 "pixel 88/302 has color %08x, expected 0x000000ff\n", color);
7242 color = getPixelColor(device, 92, 302);
7243 ok(color == 0x000000ff,
7244 "pixel 92/302 has color %08x, expected 0x000000ff\n", color);
7245
7246 color = getPixelColor(device, 568, 298);
7247 ok(color == 0x00ffff00,
7248 "pixel 568/298 has color %08x, expected 0x00ffff00\n", color);
7249 color = getPixelColor(device, 572, 298);
7250 ok(color == 0x000000ff,
7251 "pixel 572/298 has color %08x, expected 0x000000ff\n", color);
7252 color = getPixelColor(device, 568, 302);
7253 ok(color == 0x000000ff,
7254 "pixel 568/302 has color %08x, expected 0x000000ff\n", color);
7255 color = getPixelColor(device, 572, 302);
7256 ok(color == 0x000000ff,
7257 "pixel 572/302 has color %08x, expected 0x000000ff\n", color);
7258
7259 /* This test is pointless without those two declarations: */
7260 if((!dcl_color_2) || (!dcl_ubyte_2)) {
7261 skip("color-ubyte switching test declarations aren't supported\n");
7262 goto out;
7263 }
7264
7265 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quads), (void **) &data, 0);
7266 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7267 memcpy(data, quads, sizeof(quads));
7268 hr = IDirect3DVertexBuffer9_Unlock(vb);
7269 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7270 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(colors),
7271 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
7272 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
7273 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(colors), (void **) &data, 0);
7274 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7275 memcpy(data, colors, sizeof(colors));
7276 hr = IDirect3DVertexBuffer9_Unlock(vb2);
7277 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7278
7279 for(i = 0; i < 2; i++) {
7280 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
7281 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
7282
7283 hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(float) * 3);
7284 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7285 if(i == 0) {
7286 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 0, sizeof(DWORD) * 4);
7287 } else {
7288 hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 8, sizeof(DWORD) * 4);
7289 }
7290 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7291
7292 hr = IDirect3DDevice9_BeginScene(device);
7293 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
7294 ub_ok = FALSE;
7295 if(SUCCEEDED(hr)) {
7296 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7297 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7298 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7299 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7300 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7301 ub_ok = SUCCEEDED(hr);
7302
7303 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color_2);
7304 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7305 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7306 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7307
7308 hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7309 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7310 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7311 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7312 "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7313 ub_ok = (SUCCEEDED(hr) && ub_ok);
7314
7315 hr = IDirect3DDevice9_EndScene(device);
7316 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
7317 }
7318
7319 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7320 if(i == 0) {
7321 color = getPixelColor(device, 480, 360);
7322 ok(color == 0x00ff0000,
7323 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ff0000\n", color);
7324 color = getPixelColor(device, 160, 120);
7325 ok(color == 0x00ffffff,
7326 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7327 color = getPixelColor(device, 160, 360);
7328 ok(color == 0x000000ff || !ub_ok,
7329 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7330 color = getPixelColor(device, 480, 120);
7331 ok(color == 0x000000ff || !ub_ok,
7332 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7333 } else {
7334 color = getPixelColor(device, 480, 360);
7335 ok(color == 0x000000ff,
7336 "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x000000ff\n", color);
7337 color = getPixelColor(device, 160, 120);
7338 ok(color == 0x00ffffff,
7339 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7340 color = getPixelColor(device, 160, 360);
7341 ok(color == 0x00ff0000 || !ub_ok,
7342 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7343 color = getPixelColor(device, 480, 120);
7344 ok(color == 0x00ff0000 || !ub_ok,
7345 "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7346 }
7347 }
7348
7349 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7350 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7351 hr = IDirect3DDevice9_SetStreamSource(device, 1, NULL, 0, 0);
7352 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7353 IDirect3DVertexBuffer9_Release(vb2);
7354
7355 out:
7356 IDirect3DVertexBuffer9_Release(vb);
7357 if(dcl_float) IDirect3DVertexDeclaration9_Release(dcl_float);
7358 if(dcl_short) IDirect3DVertexDeclaration9_Release(dcl_short);
7359 if(dcl_ubyte) IDirect3DVertexDeclaration9_Release(dcl_ubyte);
7360 if(dcl_color) IDirect3DVertexDeclaration9_Release(dcl_color);
7361 if(dcl_color_2) IDirect3DVertexDeclaration9_Release(dcl_color_2);
7362 if(dcl_ubyte_2) IDirect3DVertexDeclaration9_Release(dcl_ubyte_2);
7363 if(dcl_positiont) IDirect3DVertexDeclaration9_Release(dcl_positiont);
7364 }
7365
7366 struct vertex_float16color {
7367 float x, y, z;
7368 DWORD c1, c2;
7369 };
7370
7371 static void test_vshader_float16(IDirect3DDevice9 *device)
7372 {
7373 HRESULT hr;
7374 DWORD color;
7375 void *data;
7376 static const D3DVERTEXELEMENT9 decl_elements[] = {
7377 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7378 {0, 12, D3DDECLTYPE_FLOAT16_4,D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
7379 D3DDECL_END()
7380 };
7381 IDirect3DVertexDeclaration9 *vdecl = NULL;
7382 IDirect3DVertexBuffer9 *buffer = NULL;
7383 IDirect3DVertexShader9 *shader;
7384 DWORD shader_code[] = {
7385 0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000001f, 0x8000000a,
7386 0x900f0001, 0x00000001, 0xc00f0000, 0x90e40000, 0x00000001, 0xd00f0000,
7387 0x90e40001, 0x0000ffff
7388 };
7389 struct vertex_float16color quad[] = {
7390 { -1.0, -1.0, 0.1, 0x3c000000, 0x00000000 }, /* green */
7391 { -1.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7392 { 0.0, -1.0, 0.1, 0x3c000000, 0x00000000 },
7393 { 0.0, 0.0, 0.1, 0x3c000000, 0x00000000 },
7394
7395 { 0.0, -1.0, 0.1, 0x00003c00, 0x00000000 }, /* red */
7396 { 0.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7397 { 1.0, -1.0, 0.1, 0x00003c00, 0x00000000 },
7398 { 1.0, 0.0, 0.1, 0x00003c00, 0x00000000 },
7399
7400 { 0.0, 0.0, 0.1, 0x00000000, 0x00003c00 }, /* blue */
7401 { 0.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7402 { 1.0, 0.0, 0.1, 0x00000000, 0x00003c00 },
7403 { 1.0, 1.0, 0.1, 0x00000000, 0x00003c00 },
7404
7405 { -1.0, 0.0, 0.1, 0x00000000, 0x3c000000 }, /* alpha */
7406 { -1.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7407 { 0.0, 0.0, 0.1, 0x00000000, 0x3c000000 },
7408 { 0.0, 1.0, 0.1, 0x00000000, 0x3c000000 },
7409 };
7410
7411 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7412 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7413
7414 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vdecl);
7415 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%08x\n", hr);
7416 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
7417 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%08x\n", hr);
7418 hr = IDirect3DDevice9_SetVertexShader(device, shader);
7419 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
7420
7421 hr = IDirect3DDevice9_BeginScene(device);
7422 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7423 if(SUCCEEDED(hr)) {
7424 hr = IDirect3DDevice9_SetVertexDeclaration(device, vdecl);
7425 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7426 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 0, sizeof(quad[0]));
7427 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7428 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 4, sizeof(quad[0]));
7429 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7430 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 8, sizeof(quad[0]));
7431 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7432 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 12, sizeof(quad[0]));
7433 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7434
7435 hr = IDirect3DDevice9_EndScene(device);
7436 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
7437 }
7438 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7439 color = getPixelColor(device, 480, 360);
7440 ok(color == 0x00ff0000,
7441 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7442 color = getPixelColor(device, 160, 120);
7443 ok(color == 0x00000000,
7444 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7445 color = getPixelColor(device, 160, 360);
7446 ok(color == 0x0000ff00,
7447 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7448 color = getPixelColor(device, 480, 120);
7449 ok(color == 0x000000ff,
7450 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7451
7452 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7453 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7454
7455 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0,
7456 D3DPOOL_MANAGED, &buffer, NULL);
7457 ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexBuffer failed, hr=%08x\n", hr);
7458 hr = IDirect3DVertexBuffer9_Lock(buffer, 0, sizeof(quad), (void **) &data, 0);
7459 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed, hr=%08x\n", hr);
7460 memcpy(data, quad, sizeof(quad));
7461 hr = IDirect3DVertexBuffer9_Unlock(buffer);
7462 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed, hr=%08x\n", hr);
7463 hr = IDirect3DDevice9_SetStreamSource(device, 0, buffer, 0, sizeof(quad[0]));
7464 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%08x\n", hr);
7465
7466 hr = IDirect3DDevice9_BeginScene(device);
7467 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7468 if(SUCCEEDED(hr)) {
7469 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7470 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7471 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7472 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7473 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7474 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7475 hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 12, 2);
7476 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7477
7478 hr = IDirect3DDevice9_EndScene(device);
7479 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
7480 }
7481
7482 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7483 color = getPixelColor(device, 480, 360);
7484 ok(color == 0x00ff0000,
7485 "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7486 color = getPixelColor(device, 160, 120);
7487 ok(color == 0x00000000,
7488 "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7489 color = getPixelColor(device, 160, 360);
7490 ok(color == 0x0000ff00,
7491 "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7492 color = getPixelColor(device, 480, 120);
7493 ok(color == 0x000000ff,
7494 "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7495
7496 hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7497 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%08x\n", hr);
7498 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7499 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7500 IDirect3DDevice9_SetVertexShader(device, NULL);
7501 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
7502
7503 IDirect3DVertexDeclaration9_Release(vdecl);
7504 IDirect3DVertexShader9_Release(shader);
7505 IDirect3DVertexBuffer9_Release(buffer);
7506 }
7507
7508 static void conditional_np2_repeat_test(IDirect3DDevice9 *device)
7509 {
7510 D3DCAPS9 caps;
7511 IDirect3DTexture9 *texture;
7512 HRESULT hr;
7513 D3DLOCKED_RECT rect;
7514 unsigned int x, y;
7515 DWORD *dst, color;
7516 const float quad[] = {
7517 -1.0, -1.0, 0.1, -0.2, -0.2,
7518 1.0, -1.0, 0.1, 1.2, -0.2,
7519 -1.0, 1.0, 0.1, -0.2, 1.2,
7520 1.0, 1.0, 0.1, 1.2, 1.2
7521 };
7522 memset(&caps, 0, sizeof(caps));
7523
7524 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7525 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
7526 if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7527 /* NP2 conditional requires the POW2 flag. Check that while we're at it */
7528 ok((caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) == 0,
7529 "Card has conditional NP2 support without power of two restriction set\n");
7530 skip("Card has unconditional pow2 support, skipping conditional NP2 tests\n");
7531 return;
7532 } else if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7533 skip("No conditional NP2 support, skipping conditional NP2 tests\n");
7534 return;
7535 }
7536
7537 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
7538 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7539
7540 hr = IDirect3DDevice9_CreateTexture(device, 10, 10, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
7541 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%08x\n", hr);
7542
7543 memset(&rect, 0, sizeof(rect));
7544 hr = IDirect3DTexture9_LockRect(texture, 0, &rect, NULL, 0);
7545 ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed hr=%08x\n", hr);
7546 for(y = 0; y < 10; y++) {
7547 for(x = 0; x < 10; x++) {
7548 dst = (DWORD *) ((BYTE *) rect.pBits + y * rect.Pitch + x * sizeof(DWORD));
7549 if(x == 0 || x == 9 || y == 0 || y == 9) {
7550 *dst = 0x00ff0000;
7551 } else {
7552 *dst = 0x000000ff;
7553 }
7554 }
7555 }
7556 hr = IDirect3DTexture9_UnlockRect(texture, 0);
7557 ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed hr=%08x\n", hr);
7558
7559 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7560 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%08x\n", hr);
7561 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
7562 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%08x\n", hr);
7563 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
7564 ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%08x\n", hr);
7565 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7566 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7567
7568 hr = IDirect3DDevice9_BeginScene(device);
7569 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7570 if(SUCCEEDED(hr)) {
7571 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
7572 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7573
7574 hr = IDirect3DDevice9_EndScene(device);
7575 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
7576 }
7577
7578 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7579
7580 color = getPixelColor(device, 1, 1);
7581 ok(color == 0x00ff0000, "NP2: Pixel 1, 1 has color %08x, expected 0x00ff0000\n", color);
7582 color = getPixelColor(device, 639, 479);
7583 ok(color == 0x00ff0000, "NP2: Pixel 639, 479 has color %08x, expected 0x00ff0000\n", color);
7584
7585 color = getPixelColor(device, 135, 101);
7586 ok(color == 0x00ff0000, "NP2: Pixel 135, 101 has color %08x, expected 0x00ff0000\n", color);
7587 color = getPixelColor(device, 140, 101);
7588 ok(color == 0x00ff0000, "NP2: Pixel 140, 101 has color %08x, expected 0x00ff0000\n", color);
7589 color = getPixelColor(device, 135, 105);
7590 ok(color == 0x00ff0000, "NP2: Pixel 135, 105 has color %08x, expected 0x00ff0000\n", color);
7591 color = getPixelColor(device, 140, 105);
7592 ok(color == 0x000000ff, "NP2: Pixel 140, 105 has color %08x, expected 0x000000ff\n", color);
7593
7594 color = getPixelColor(device, 135, 376);
7595 ok(color == 0x00ff0000, "NP2: Pixel 135, 376 has color %08x, expected 0x00ff0000\n", color);
7596 color = getPixelColor(device, 140, 376);
7597 ok(color == 0x000000ff, "NP2: Pixel 140, 376 has color %08x, expected 0x000000ff\n", color);
7598 color = getPixelColor(device, 135, 379);
7599 ok(color == 0x00ff0000, "NP2: Pixel 135, 379 has color %08x, expected 0x00ff0000\n", color);
7600 color = getPixelColor(device, 140, 379);
7601 ok(color == 0x00ff0000, "NP2: Pixel 140, 379 has color %08x, expected 0x00ff0000\n", color);
7602
7603 color = getPixelColor(device, 500, 101);
7604 ok(color == 0x00ff0000, "NP2: Pixel 500, 101 has color %08x, expected 0x00ff0000\n", color);
7605 color = getPixelColor(device, 504, 101);
7606 ok(color == 0x00ff0000, "NP2: Pixel 504, 101 has color %08x, expected 0x00ff0000\n", color);
7607 color = getPixelColor(device, 500, 105);
7608 ok(color == 0x000000ff, "NP2: Pixel 500, 105 has color %08x, expected 0x000000ff\n", color);
7609 color = getPixelColor(device, 504, 105);
7610 ok(color == 0x00ff0000, "NP2: Pixel 504, 105 has color %08x, expected 0x00ff0000\n", color);
7611
7612 color = getPixelColor(device, 500, 376);
7613 ok(color == 0x000000ff, "NP2: Pixel 500, 376 has color %08x, expected 0x000000ff\n", color);
7614 color = getPixelColor(device, 504, 376);
7615 ok(color == 0x00ff0000, "NP2: Pixel 504, 376 has color %08x, expected 0x00ff0000\n", color);
7616 color = getPixelColor(device, 500, 380);
7617 ok(color == 0x00ff0000, "NP2: Pixel 500, 380 has color %08x, expected 0x00ff0000\n", color);
7618 color = getPixelColor(device, 504, 380);
7619 ok(color == 0x00ff0000, "NP2: Pixel 504, 380 has color %08x, expected 0x00ff0000\n", color);
7620
7621 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7622 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%08x\n", hr);
7623 IDirect3DTexture9_Release(texture);
7624 }
7625
7626 static void vFace_register_test(IDirect3DDevice9 *device)
7627 {
7628 HRESULT hr;
7629 DWORD color;
7630 const DWORD shader_code[] = {
7631 0xffff0300, /* ps_3_0 */
7632 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0.0, 1.0, 0.0, 0.0 */
7633 0x05000051, 0xa00f0001, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1.0, 0.0, 0.0, 0.0 */
7634 0x0200001f, 0x80000000, 0x900f1001, /* dcl vFace */
7635 0x02000001, 0x800f0001, 0xa0e40001, /* mov r1, c1 */
7636 0x04000058, 0x800f0000, 0x90e41001, 0xa0e40000, 0x80e40001, /* cmp r0, vFace, c0, r1 */
7637 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
7638 0x0000ffff /* END */
7639 };
7640 IDirect3DPixelShader9 *shader;
7641 IDirect3DTexture9 *texture;
7642 IDirect3DSurface9 *surface, *backbuffer;
7643 const float quad[] = {
7644 -1.0, -1.0, 0.1,
7645 1.0, -1.0, 0.1,
7646 -1.0, 0.0, 0.1,
7647
7648 1.0, -1.0, 0.1,
7649 1.0, 0.0, 0.1,
7650 -1.0, 0.0, 0.1,
7651
7652 -1.0, 0.0, 0.1,
7653 -1.0, 1.0, 0.1,
7654 1.0, 0.0, 0.1,
7655
7656 1.0, 0.0, 0.1,
7657 -1.0, 1.0, 0.1,
7658 1.0, 1.0, 0.1,
7659 };
7660 const float blit[] = {
7661 0.0, -1.0, 0.1, 0.0, 0.0,
7662 1.0, -1.0, 0.1, 1.0, 0.0,
7663 0.0, 1.0, 0.1, 0.0, 1.0,
7664 1.0, 1.0, 0.1, 1.0, 1.0,
7665 };
7666
7667 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
7668 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
7669 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
7670 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%08x\n", hr);
7671 hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
7672 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed hr=%08x\n", hr);
7673 hr = IDirect3DDevice9_SetPixelShader(device, shader);
7674 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
7675 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7676 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
7677 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
7678 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%08x\n", hr);
7679
7680 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7681 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7682
7683 hr = IDirect3DDevice9_BeginScene(device);
7684 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7685 if(SUCCEEDED(hr)) {
7686 /* First, draw to the texture and the back buffer to test both offscreen and onscreen cases */
7687 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
7688 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
7689 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7690 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7691 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7692 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7693 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
7694 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
7695 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7696 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7697
7698 /* Blit the texture onto the back buffer to make it visible */
7699 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
7700 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
7701 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7702 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
7703 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7704 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%08x\n", hr);
7705 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7706 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%08x\n", hr);
7707 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7708 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
7709
7710 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, blit, sizeof(float) * 5);
7711 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7712
7713 hr = IDirect3DDevice9_EndScene(device);
7714 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
7715 }
7716
7717 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7718 color = getPixelColor(device, 160, 360);
7719 ok(color == 0x00ff0000, "vFace: Onscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7720 color = getPixelColor(device, 160, 120);
7721 ok(color == 0x0000ff00, "vFace: Onscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7722 color = getPixelColor(device, 480, 360);
7723 ok(color == 0x0000ff00, "vFace: Offscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7724 color = getPixelColor(device, 480, 120);
7725 ok(color == 0x00ff0000, "vFace: Offscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7726
7727 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
7728 IDirect3DDevice9_SetTexture(device, 0, NULL);
7729 IDirect3DPixelShader9_Release(shader);
7730 IDirect3DSurface9_Release(surface);
7731 IDirect3DSurface9_Release(backbuffer);
7732 IDirect3DTexture9_Release(texture);
7733 }
7734
7735 static void fixed_function_bumpmap_test(IDirect3DDevice9 *device)
7736 {
7737 HRESULT hr;
7738 DWORD color;
7739 int i;
7740 D3DCAPS9 caps;
7741 BOOL L6V5U5_supported = FALSE;
7742 IDirect3DTexture9 *tex1, *tex2;
7743 D3DLOCKED_RECT locked_rect;
7744
7745 static const float quad[][7] = {
7746 {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
7747 {-128.0f/640.0f, 128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
7748 { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
7749 { 128.0f/640.0f, 128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
7750 };
7751
7752 static const D3DVERTEXELEMENT9 decl_elements[] = {
7753 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7754 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
7755 {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
7756 D3DDECL_END()
7757 };
7758
7759 /* use asymmetric matrix to test loading */
7760 float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
7761 float scale, offset;
7762
7763 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
7764 IDirect3DTexture9 *texture = NULL;
7765
7766 memset(&caps, 0, sizeof(caps));
7767 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7768 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
7769 if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)) {
7770 skip("D3DTEXOPCAPS_BUMPENVMAP not set, skipping bumpmap tests\n");
7771 return;
7772 } else {
7773 /* This check is disabled, some Windows drivers do not handle D3DUSAGE_QUERY_LEGACYBUMPMAP properly.
7774 * They report that it is not supported, but after that bump mapping works properly. So just test
7775 * if the format is generally supported, and check the BUMPENVMAP flag
7776 */
7777 IDirect3D9 *d3d9;
7778
7779 IDirect3DDevice9_GetDirect3D(device, &d3d9);
7780 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7781 D3DRTYPE_TEXTURE, D3DFMT_L6V5U5);
7782 L6V5U5_supported = SUCCEEDED(hr);
7783 hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7784 D3DRTYPE_TEXTURE, D3DFMT_V8U8);
7785 IDirect3D9_Release(d3d9);
7786 if(FAILED(hr)) {
7787 skip("D3DFMT_V8U8 not supported for legacy bump mapping\n");
7788 return;
7789 }
7790 }
7791
7792 /* Generate the textures */
7793 generate_bumpmap_textures(device);
7794
7795 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
7796 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7797 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
7798 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7799 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
7800 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7801 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
7802 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7803
7804 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAP);
7805 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7806 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
7807 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7808 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
7809 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7810
7811 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7812 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7813 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7814 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7815 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
7816 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7817
7818 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
7819 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7820
7821 hr = IDirect3DDevice9_SetVertexShader(device, NULL);
7822 ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
7823
7824 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
7825 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
7826
7827
7828 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
7829 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
7830 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
7831 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
7832
7833 hr = IDirect3DDevice9_BeginScene(device);
7834 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7835
7836 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7837 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7838
7839 hr = IDirect3DDevice9_EndScene(device);
7840 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7841
7842 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7843 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7844
7845 /* on MacOS(10.5.4, radeon X1600), the white dots are have color 0x00fbfbfb rather than 0x00ffffff. This is
7846 * kinda strange since no calculations are done on the sampled colors, only on the texture coordinates.
7847 * But since testing the color match is not the purpose of the test don't be too picky
7848 */
7849 color = getPixelColor(device, 320-32, 240);
7850 ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7851 color = getPixelColor(device, 320+32, 240);
7852 ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7853 color = getPixelColor(device, 320, 240-32);
7854 ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7855 color = getPixelColor(device, 320, 240+32);
7856 ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7857 color = getPixelColor(device, 320, 240);
7858 ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7859 color = getPixelColor(device, 320+32, 240+32);
7860 ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7861 color = getPixelColor(device, 320-32, 240+32);
7862 ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7863 color = getPixelColor(device, 320+32, 240-32);
7864 ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7865 color = getPixelColor(device, 320-32, 240-32);
7866 ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7867
7868 for(i = 0; i < 2; i++) {
7869 hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
7870 ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
7871 IDirect3DTexture9_Release(texture); /* For the GetTexture */
7872 hr = IDirect3DDevice9_SetTexture(device, i, NULL);
7873 ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
7874 IDirect3DTexture9_Release(texture); /* To destroy it */
7875 }
7876
7877 if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAPLUMINANCE)) {
7878 skip("D3DTOP_BUMPENVMAPLUMINANCE not supported, skipping\n");
7879 goto cleanup;
7880 }
7881 if(L6V5U5_supported == FALSE) {
7882 skip("L6V5U5_supported not supported, skipping D3DTOP_BUMPENVMAPLUMINANCE test\n");
7883 goto cleanup;
7884 }
7885
7886 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00000000, 0.0, 0x8);
7887 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
7888 /* This test only tests the luminance part. The bumpmapping part was already tested above and
7889 * would only make this test more complicated
7890 */
7891 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_L6V5U5, D3DPOOL_MANAGED, &tex1, NULL);
7892 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
7893 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &tex2, NULL);
7894 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
7895
7896 memset(&locked_rect, 0, sizeof(locked_rect));
7897 hr = IDirect3DTexture9_LockRect(tex1, 0, &locked_rect, NULL, 0);
7898 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
7899 *((DWORD *)locked_rect.pBits) = 0x4000; /* L = 0.25, V = 0.0, U = 0.0 */
7900 hr = IDirect3DTexture9_UnlockRect(tex1, 0);
7901 ok(SUCCEEDED(hr), "UnlockRect failed with 0x%08x\n", hr);
7902
7903 memset(&locked_rect, 0, sizeof(locked_rect));
7904 hr = IDirect3DTexture9_LockRect(tex2, 0, &locked_rect, NULL, 0);
7905 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
7906 *((DWORD *)locked_rect.pBits) = 0x00ff80c0;
7907 hr = IDirect3DTexture9_UnlockRect(tex2, 0);
7908 ok(SUCCEEDED(hr), "UnlockRect failed with 0x%08x\n", hr);
7909
7910 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
7911 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7912 hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) tex2);
7913 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7914
7915 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAPLUMINANCE);
7916 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7917 scale = 2.0;
7918 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7919 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7920 offset = 0.1;
7921 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7922 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7923
7924 hr = IDirect3DDevice9_BeginScene(device);
7925 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7926 if(SUCCEEDED(hr)) {
7927 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7928 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7929 hr = IDirect3DDevice9_EndScene(device);
7930 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7931 }
7932
7933 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7934 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7935 color = getPixelColor(device, 320, 240);
7936 /* red: 1.0 * (0.25 * 2.0 + 0.1) = 1.0 * 0.6 = 0.6 = 0x99
7937 * green: 0.5 * (0.25 * 2.0 + 0.1) = 0.5 * 0.6 = 0.3 = 0x4c
7938 * green: 0.75 * (0.25 * 2.0 + 0.1) = 0.75 * 0.6 = 0.45 = 0x72
7939 */
7940 ok(color_match(color, 0x00994c72, 5), "bumpmap failed: Got color 0x%08x, expected 0x00994c72.\n", color);
7941
7942 /* Check a result scale factor > 1.0 */
7943 scale = 10;
7944 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7945 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7946 offset = 10;
7947 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7948 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7949
7950 hr = IDirect3DDevice9_BeginScene(device);
7951 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7952 if(SUCCEEDED(hr)) {
7953 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7954 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7955 hr = IDirect3DDevice9_EndScene(device);
7956 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7957 }
7958 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7959 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7960 color = getPixelColor(device, 320, 240);
7961 ok(color_match(color, 0x00ff80c0, 1), "bumpmap failed: Got color 0x%08x, expected 0x00ff80c0.\n", color);
7962
7963 /* Check clamping in the scale factor calculation */
7964 scale = 1000;
7965 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7966 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7967 offset = -1;
7968 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7969 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7970
7971 hr = IDirect3DDevice9_BeginScene(device);
7972 ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7973 if(SUCCEEDED(hr)) {
7974 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7975 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7976 hr = IDirect3DDevice9_EndScene(device);
7977 ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7978 }
7979 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7980 ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7981 color = getPixelColor(device, 320, 240);
7982 ok(color_match(color, 0x00ff80c0, 1), "bumpmap failed: Got color 0x%08x, expected 0x00ff80c0.\n", color);
7983
7984 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7985 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7986 hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
7987 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7988
7989 IDirect3DTexture9_Release(tex1);
7990 IDirect3DTexture9_Release(tex2);
7991
7992 cleanup:
7993 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
7994 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7995 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
7996 ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7997
7998 hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7999 ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
8000 IDirect3DVertexDeclaration9_Release(vertex_declaration);
8001 }
8002
8003 static void stencil_cull_test(IDirect3DDevice9 *device) {
8004 HRESULT hr;
8005 IDirect3DSurface9 *depthstencil = NULL;
8006 D3DSURFACE_DESC desc;
8007 float quad1[] = {
8008 -1.0, -1.0, 0.1,
8009 0.0, -1.0, 0.1,
8010 -1.0, 0.0, 0.1,
8011 0.0, 0.0, 0.1,
8012 };
8013 float quad2[] = {
8014 0.0, -1.0, 0.1,
8015 1.0, -1.0, 0.1,
8016 0.0, 0.0, 0.1,
8017 1.0, 0.0, 0.1,
8018 };
8019 float quad3[] = {
8020 0.0, 0.0, 0.1,
8021 1.0, 0.0, 0.1,
8022 0.0, 1.0, 0.1,
8023 1.0, 1.0, 0.1,
8024 };
8025 float quad4[] = {
8026 -1.0, 0.0, 0.1,
8027 0.0, 0.0, 0.1,
8028 -1.0, 1.0, 0.1,
8029 0.0, 1.0, 0.1,
8030 };
8031 struct vertex painter[] = {
8032 {-1.0, -1.0, 0.0, 0x00000000},
8033 { 1.0, -1.0, 0.0, 0x00000000},
8034 {-1.0, 1.0, 0.0, 0x00000000},
8035 { 1.0, 1.0, 0.0, 0x00000000},
8036 };
8037 WORD indices_cw[] = {0, 1, 3};
8038 WORD indices_ccw[] = {0, 2, 3};
8039 unsigned int i;
8040 DWORD color;
8041
8042 IDirect3DDevice9_GetDepthStencilSurface(device, &depthstencil);
8043 if(depthstencil == NULL) {
8044 skip("No depth stencil buffer\n");
8045 return;
8046 }
8047 hr = IDirect3DSurface9_GetDesc(depthstencil, &desc);
8048 ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %08x\n", hr);
8049 IDirect3DSurface9_Release(depthstencil);
8050 if(desc.Format != D3DFMT_D24S8 && desc.Format != D3DFMT_D24X4S4) {
8051 skip("No 4 or 8 bit stencil surface\n");
8052 return;
8053 }
8054
8055 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, 0x00ff0000, 0.0, 0x8);
8056 ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
8057 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8058
8059 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_INCR);
8060 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8061 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
8062 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8063 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
8064 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8065 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, 0x3);
8066 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8067
8068 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_REPLACE);
8069 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8070 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR);
8071 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8072 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILPASS, D3DSTENCILOP_INCR);
8073 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8074
8075 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, TRUE);
8076 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8077 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
8078 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8079
8080 /* First pass: Fill the stencil buffer with some values... */
8081 hr = IDirect3DDevice9_BeginScene(device);
8082 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
8083 if(SUCCEEDED(hr))
8084 {
8085 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
8086 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8087 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8088 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
8089 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8090 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
8091
8092 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, TRUE);
8093 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8094 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
8095 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8096 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8097 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
8098 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8099 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
8100
8101 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
8102 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8103 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8104 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
8105 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8106 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
8107
8108 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CCW);
8109 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8110 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8111 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
8112 hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8113 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
8114
8115 hr = IDirect3DDevice9_EndScene(device);
8116 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
8117 }
8118
8119 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8120 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
8121 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8122 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
8123 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8124 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
8125 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8126 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
8127 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8128 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
8129 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8130 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFUNC, D3DCMP_EQUAL);
8131 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8132
8133 /* 2nd pass: Make the stencil values visible */
8134 hr = IDirect3DDevice9_BeginScene(device);
8135 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
8136 if(SUCCEEDED(hr))
8137 {
8138 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8139 for(i = 0; i < 16; i++) {
8140 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, i);
8141 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8142
8143 painter[0].diffuse = (i * 16); /* Creates shades of blue */
8144 painter[1].diffuse = (i * 16);
8145 painter[2].diffuse = (i * 16);
8146 painter[3].diffuse = (i * 16);
8147 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, painter, sizeof(painter[0]));
8148 ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
8149 }
8150 hr = IDirect3DDevice9_EndScene(device);
8151 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
8152 }
8153
8154 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8155 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
8156
8157 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
8158 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8159
8160 color = getPixelColor(device, 160, 420);
8161 ok(color == 0x00000030, "CCW triangle, twoside FALSE, cull cw, replace, has color 0x%08x, expected 0x00000030\n", color);
8162 color = getPixelColor(device, 160, 300);
8163 ok(color == 0x00000080, "CW triangle, twoside FALSE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8164
8165 color = getPixelColor(device, 480, 420);
8166 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull off, incr, has color 0x%08x, expected 0x00000090\n", color);
8167 color = getPixelColor(device, 480, 300);
8168 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull off, replace, has color 0x%08x, expected 0x00000030\n", color);
8169
8170 color = getPixelColor(device, 160, 180);
8171 ok(color == 0x00000080, "CCW triangle, twoside TRUE, cull ccw, culled, has color 0x%08x, expected 0x00000080\n", color);
8172 color = getPixelColor(device, 160, 60);
8173 ok(color == 0x00000030, "CW triangle, twoside TRUE, cull ccw, replace, has color 0x%08x, expected 0x00000030\n", color);
8174
8175 color = getPixelColor(device, 480, 180);
8176 ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull cw, incr, has color 0x%08x, expected 0x00000090\n", color);
8177 color = getPixelColor(device, 480, 60);
8178 ok(color == 0x00000080, "CW triangle, twoside TRUE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8179 }
8180
8181 static void vpos_register_test(IDirect3DDevice9 *device)
8182 {
8183 HRESULT hr;
8184 DWORD color;
8185 const DWORD shader_code[] = {
8186 0xffff0300, /* ps_3_0 */
8187 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8188 0x03000002, 0x80030000, 0x90541000, 0xa1fe0000, /* sub r0.xy, vPos.xy, c0.zw */
8189 0x02000001, 0x800f0001, 0xa0e40000, /* mov r1, c0 */
8190 0x02000001, 0x80080002, 0xa0550000, /* mov r2.a, c0.y */
8191 0x02000001, 0x80010002, 0xa0550000, /* mov r2.r, c0.y */
8192 0x04000058, 0x80020002, 0x80000000, 0x80000001, 0x80550001, /* cmp r2.g, r0.x, r1.x, r1.y */
8193 0x04000058, 0x80040002, 0x80550000, 0x80000001, 0x80550001, /* cmp r2.b, r0.y, r1.x, r1.y */
8194 0x02000001, 0x800f0800, 0x80e40002, /* mov oC0, r2 */
8195 0x0000ffff /* end */
8196 };
8197 const DWORD shader_frac_code[] = {
8198 0xffff0300, /* ps_3_0 */
8199 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
8200 0x0200001f, 0x80000000, 0x90031000, /* dcl vPos.xy */
8201 0x02000001, 0x800f0000, 0xa0e40000, /* mov r0, c0 */
8202 0x02000013, 0x80030000, 0x90541000, /* frc r0.xy, vPos.xy */
8203 0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */
8204 0x0000ffff /* end */
8205 };
8206 IDirect3DPixelShader9 *shader, *shader_frac;
8207 IDirect3DSurface9 *surface = NULL, *backbuffer;
8208 const float quad[] = {
8209 -1.0, -1.0, 0.1, 0.0, 0.0,
8210 1.0, -1.0, 0.1, 1.0, 0.0,
8211 -1.0, 1.0, 0.1, 0.0, 1.0,
8212 1.0, 1.0, 0.1, 1.0, 1.0,
8213 };
8214 D3DLOCKED_RECT lr;
8215 float constant[4] = {1.0, 0.0, 320, 240};
8216 DWORD *pos;
8217
8218 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8219 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8220 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
8221 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
8222 hr = IDirect3DDevice9_CreatePixelShader(device, shader_frac_code, &shader_frac);
8223 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
8224 hr = IDirect3DDevice9_SetPixelShader(device, shader);
8225 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8226 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8227 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
8228 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8229 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%08x\n", hr);
8230
8231 hr = IDirect3DDevice9_BeginScene(device);
8232 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8233 if(SUCCEEDED(hr)) {
8234 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8235 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%08x\n", hr);
8236 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8237 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8238 hr = IDirect3DDevice9_EndScene(device);
8239 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8240 }
8241
8242 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8243 /* This has to be pixel exact */
8244 color = getPixelColor(device, 319, 239);
8245 ok(color == 0x00000000, "vPos: Pixel 319,239 has color 0x%08x, expected 0x00000000\n", color);
8246 color = getPixelColor(device, 320, 239);
8247 ok(color == 0x0000ff00, "vPos: Pixel 320,239 has color 0x%08x, expected 0x0000ff00\n", color);
8248 color = getPixelColor(device, 319, 240);
8249 ok(color == 0x000000ff, "vPos: Pixel 319,240 has color 0x%08x, expected 0x000000ff\n", color);
8250 color = getPixelColor(device, 320, 240);
8251 ok(color == 0x0000ffff, "vPos: Pixel 320,240 has color 0x%08x, expected 0x0000ffff\n", color);
8252
8253 hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_X8R8G8B8, 0, 0, TRUE,
8254 &surface, NULL);
8255 ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget failed hr=%08x\n", hr);
8256 hr = IDirect3DDevice9_BeginScene(device);
8257 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8258 if(SUCCEEDED(hr)) {
8259 constant[2] = 16; constant[3] = 16;
8260 hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8261 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%08x\n", hr);
8262 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
8263 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8264 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8265 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8266 hr = IDirect3DDevice9_EndScene(device);
8267 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8268 }
8269 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8270 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%08x\n", hr);
8271
8272 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8273 color = *pos & 0x00ffffff;
8274 ok(color == 0x00000000, "Pixel 14/14 has color 0x%08x, expected 0x00000000\n", color);
8275 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 18 * sizeof(DWORD));
8276 color = *pos & 0x00ffffff;
8277 ok(color == 0x0000ff00, "Pixel 14/18 has color 0x%08x, expected 0x0000ff00\n", color);
8278 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 14 * sizeof(DWORD));
8279 color = *pos & 0x00ffffff;
8280 ok(color == 0x000000ff, "Pixel 18/14 has color 0x%08x, expected 0x000000ff\n", color);
8281 pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 18 * sizeof(DWORD));
8282 color = *pos & 0x00ffffff;
8283 ok(color == 0x0000ffff, "Pixel 18/18 has color 0x%08x, expected 0x0000ffff\n", color);
8284
8285 hr = IDirect3DSurface9_UnlockRect(surface);
8286 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%08x\n", hr);
8287
8288 /* Test the fraction value of vPos. This is tested with the offscreen target and not the backbuffer to
8289 * have full control over the multisampling setting inside this test
8290 */
8291 hr = IDirect3DDevice9_SetPixelShader(device, shader_frac);
8292 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8293 hr = IDirect3DDevice9_BeginScene(device);
8294 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8295 if(SUCCEEDED(hr)) {
8296 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8297 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8298 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8299 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8300 hr = IDirect3DDevice9_EndScene(device);
8301 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8302 }
8303 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8304 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8305
8306 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8307 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%08x\n", hr);
8308
8309 pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8310 color = *pos & 0x00ffffff;
8311 ok(color == 0x00000000, "vPos fraction test has color 0x%08x, expected 0x00000000\n", color);
8312
8313 hr = IDirect3DSurface9_UnlockRect(surface);
8314 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%08x\n", hr);
8315
8316 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8317 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8318 IDirect3DPixelShader9_Release(shader);
8319 IDirect3DPixelShader9_Release(shader_frac);
8320 if(surface) IDirect3DSurface9_Release(surface);
8321 IDirect3DSurface9_Release(backbuffer);
8322 }
8323
8324 static void pointsize_test(IDirect3DDevice9 *device)
8325 {
8326 HRESULT hr;
8327 D3DCAPS9 caps;
8328 D3DMATRIX matrix;
8329 D3DMATRIX identity;
8330 float ptsize, ptsize_orig, ptsizemax_orig, ptsizemin_orig;
8331 DWORD color;
8332
8333 const float vertices[] = {
8334 64, 64, 0.1,
8335 128, 64, 0.1,
8336 192, 64, 0.1,
8337 256, 64, 0.1,
8338 320, 64, 0.1,
8339 384, 64, 0.1,
8340 448, 64, 0.1,
8341 512, 64, 0.1,
8342 576, 64, 0.1,
8343 };
8344
8345 /* 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 */
8346 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;
8347 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;
8348 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;
8349 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;
8350
8351 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;
8352 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;
8353 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;
8354 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;
8355
8356 memset(&caps, 0, sizeof(caps));
8357 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8358 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
8359 if(caps.MaxPointSize < 32.0) {
8360 skip("MaxPointSize < 32.0, skipping(MaxPointsize = %f)\n", caps.MaxPointSize);
8361 return;
8362 }
8363
8364 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 0.0, 0);
8365 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8366 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &matrix);
8367 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%08x\n", hr);
8368 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8369 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
8370 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE, (DWORD *) &ptsize_orig);
8371 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed hr=%08x\n", hr);
8372
8373 hr = IDirect3DDevice9_BeginScene(device);
8374 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8375 if(SUCCEEDED(hr)) {
8376 ptsize = 16.0;
8377 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8378 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8379 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[0], sizeof(float) * 3);
8380 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8381
8382 ptsize = 32.0;
8383 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8384 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8385 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[3], sizeof(float) * 3);
8386 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8387
8388 ptsize = 31.5;
8389 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8390 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8391 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[6], sizeof(float) * 3);
8392 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8393
8394 if(caps.MaxPointSize >= 64.0) {
8395 ptsize = 64.0;
8396 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8397 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8398 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[9], sizeof(float) * 3);
8399 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8400
8401 ptsize = 63.75;
8402 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8403 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8404 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[15], sizeof(float) * 3);
8405 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8406 }
8407
8408 ptsize = 1.0;
8409 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8410 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8411 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[12], sizeof(float) * 3);
8412 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8413
8414 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE_MAX, (DWORD *) (&ptsizemax_orig));
8415 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed, hr=%08x\n", hr);
8416 hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE_MAX, (DWORD *) (&ptsizemin_orig));
8417 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed, hr=%08x\n", hr);
8418
8419 /* What happens if point scaling is disabled, and POINTSIZE_MAX < POINTSIZE? */
8420 ptsize = 16.0;
8421 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8422 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8423 ptsize = 1.0;
8424 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MAX, *((DWORD *) (&ptsize)));
8425 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8426 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[18], sizeof(float) * 3);
8427 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8428
8429 /* What happens if POINTSIZE_MAX < POINTSIZE_MIN?
8430 * ptsize = 4.0, ptsize_max = 1.0, ptsize_min = 16.0
8431 */
8432 ptsize = 4.0;
8433 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8434 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8435 ptsize = 16.0;
8436 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsize)));
8437 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8438 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[21], sizeof(float) * 3);
8439 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8440
8441 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MAX, *((DWORD *) (&ptsizemax_orig)));
8442 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8443
8444 /* pointsize < pointsize_min < pointsize_max?
8445 * pointsize = 1.0, pointsize_min = 16.0, pointsize_max = default(usually 64.0)
8446 */
8447 ptsize = 1.0;
8448 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8449 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8450 ptsize = 16.0;
8451 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsize)));
8452 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8453 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[24], sizeof(float) * 3);
8454 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8455
8456 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsizemin_orig)));
8457 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8458
8459 hr = IDirect3DDevice9_EndScene(device);
8460 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8461 }
8462 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8463 color = getPixelColor(device, 64-9, 64-9);
8464 ok(color == 0x000000ff, "pSize: Pixel (64-9),(64-9) has color 0x%08x, expected 0x000000ff\n", color);
8465 color = getPixelColor(device, 64-8, 64-8);
8466 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (64-8),(64-8) has color 0x%08x, expected 0x00ffffff\n", color);
8467 color = getPixelColor(device, 64-7, 64-7);
8468 ok(color == 0x00ffffff, "pSize: Pixel (64-7),(64-7) has color 0x%08x, expected 0x00ffffff\n", color);
8469 color = getPixelColor(device, 64+7, 64+7);
8470 ok(color == 0x00ffffff, "pSize: Pixel (64+7),(64+7) has color 0x%08x, expected 0x00ffffff\n", color);
8471 color = getPixelColor(device, 64+8, 64+8);
8472 ok(color == 0x000000ff, "pSize: Pixel (64+8),(64+8) has color 0x%08x, expected 0x000000ff\n", color);
8473 color = getPixelColor(device, 64+9, 64+9);
8474 ok(color == 0x000000ff, "pSize: Pixel (64+9),(64+9) has color 0x%08x, expected 0x000000ff\n", color);
8475
8476 color = getPixelColor(device, 128-17, 64-17);
8477 ok(color == 0x000000ff, "pSize: Pixel (128-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8478 color = getPixelColor(device, 128-16, 64-16);
8479 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (128-16),(64-16) has color 0x%08x, expected 0x00ffffff\n", color);
8480 color = getPixelColor(device, 128-15, 64-15);
8481 ok(color == 0x00ffffff, "pSize: Pixel (128-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8482 color = getPixelColor(device, 128+15, 64+15);
8483 ok(color == 0x00ffffff, "pSize: Pixel (128+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8484 color = getPixelColor(device, 128+16, 64+16);
8485 ok(color == 0x000000ff, "pSize: Pixel (128+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8486 color = getPixelColor(device, 128+17, 64+17);
8487 ok(color == 0x000000ff, "pSize: Pixel (128+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8488
8489 color = getPixelColor(device, 192-17, 64-17);
8490 ok(color == 0x000000ff, "pSize: Pixel (192-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8491 color = getPixelColor(device, 192-16, 64-16);
8492 ok(color == 0x000000ff, "pSize: Pixel (192-16),(64-16) has color 0x%08x, expected 0x000000ff\n", color);
8493 color = getPixelColor(device, 192-15, 64-15);
8494 ok(color == 0x00ffffff, "pSize: Pixel (192-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8495 color = getPixelColor(device, 192+15, 64+15);
8496 ok(color == 0x00ffffff, "pSize: Pixel (192+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8497 color = getPixelColor(device, 192+16, 64+16);
8498 ok(color == 0x000000ff, "pSize: Pixel (192+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8499 color = getPixelColor(device, 192+17, 64+17);
8500 ok(color == 0x000000ff, "pSize: Pixel (192+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8501
8502 if(caps.MaxPointSize >= 64.0) {
8503 color = getPixelColor(device, 256-33, 64-33);
8504 ok(color == 0x000000ff, "pSize: Pixel (256-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8505 color = getPixelColor(device, 256-32, 64-32);
8506 todo_wine ok(color == 0x00ffffff, "pSize: Pixel (256-32),(64-32) has color 0x%08x, expected 0x00ffffff\n", color);
8507 color = getPixelColor(device, 256-31, 64-31);
8508 ok(color == 0x00ffffff, "pSize: Pixel (256-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8509 color = getPixelColor(device, 256+31, 64+31);
8510 ok(color == 0x00ffffff, "pSize: Pixel (256+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8511 color = getPixelColor(device, 256+32, 64+32);
8512 ok(color == 0x000000ff, "pSize: Pixel (256+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8513 color = getPixelColor(device, 256+33, 64+33);
8514 ok(color == 0x000000ff, "pSize: Pixel (256+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8515
8516 color = getPixelColor(device, 384-33, 64-33);
8517 ok(color == 0x000000ff, "pSize: Pixel (384-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8518 color = getPixelColor(device, 384-32, 64-32);
8519 ok(color == 0x000000ff, "pSize: Pixel (384-32),(64-32) has color 0x%08x, expected 0x000000ff\n", color);
8520 color = getPixelColor(device, 384-31, 64-31);
8521 ok(color == 0x00ffffff, "pSize: Pixel (384-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8522 color = getPixelColor(device, 384+31, 64+31);
8523 ok(color == 0x00ffffff, "pSize: Pixel (384+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8524 color = getPixelColor(device, 384+32, 64+32);
8525 ok(color == 0x000000ff, "pSize: Pixel (384+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8526 color = getPixelColor(device, 384+33, 64+33);
8527 ok(color == 0x000000ff, "pSize: Pixel (384+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8528 }
8529
8530 color = getPixelColor(device, 320-1, 64-1);
8531 ok(color == 0x000000ff, "pSize: Pixel (320-1),(64-1) has color 0x%08x, expected 0x000000ff\n", color);
8532 color = getPixelColor(device, 320-0, 64-0);
8533 ok(color == 0x00ffffff, "pSize: Pixel (320-0),(64-0) has color 0x%08x, expected 0x00ffffff\n", color);
8534 color = getPixelColor(device, 320+1, 64+1);
8535 ok(color == 0x000000ff, "pSize: Pixel (320+1),(64+1) has color 0x%08x, expected 0x000000ff\n", color);
8536
8537 /* ptsize = 16, ptsize_max = 1 --> point has size 1 */
8538 color = getPixelColor(device, 448-4, 64-4);
8539 ok(color == 0x000000ff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8540 color = getPixelColor(device, 448+4, 64+4);
8541 ok(color == 0x000000ff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8542
8543 /* ptsize = 4, ptsize_max = 1, ptsize_min = 16 --> point has size 1 */
8544 color = getPixelColor(device, 512-4, 64-4);
8545 ok(color == 0x000000ff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8546 color = getPixelColor(device, 512+4, 64+4);
8547 ok(color == 0x000000ff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8548
8549 /* ptsize = 1, ptsize_max = default(64), ptsize_min = 16 --> point has size 16
8550 * Don't be overly picky - just show that the point is bigger than 1 pixel
8551 */
8552 color = getPixelColor(device, 576-4, 64-4);
8553 ok(color == 0x00ffffff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8554 color = getPixelColor(device, 576+4, 64+4);
8555 ok(color == 0x00ffffff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8556
8557 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize_orig)));
8558 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed hr=%08x\n", hr);
8559 hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &identity);
8560 ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%08x\n", hr);
8561 }
8562
8563 static void multiple_rendertargets_test(IDirect3DDevice9 *device)
8564 {
8565 HRESULT hr;
8566 IDirect3DPixelShader9 *ps;
8567 IDirect3DTexture9 *tex1, *tex2;
8568 IDirect3DSurface9 *surf1, *surf2, *backbuf;
8569 D3DCAPS9 caps;
8570 DWORD color;
8571 DWORD shader_code[] = {
8572 0xffff0300, /* ps_3_0 */
8573 0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0, 1, 0, 0 */
8574 0x05000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x00000000, /* def c1, 0, 0, 1, 0 */
8575 0x02000001, 0x800f0800, 0xa0e40000, /* mov oC0, c0 */
8576 0x02000001, 0x800f0801, 0xa0e40001, /* mov oC1, c1 */
8577 0x0000ffff /* END */
8578 };
8579 float quad[] = {
8580 -1.0, -1.0, 0.1,
8581 1.0, -1.0, 0.1,
8582 -1.0, 1.0, 0.1,
8583 1.0, 1.0, 0.1,
8584 };
8585 float texquad[] = {
8586 -1.0, -1.0, 0.1, 0.0, 0.0,
8587 0.0, -1.0, 0.1, 1.0, 0.0,
8588 -1.0, 1.0, 0.1, 0.0, 1.0,
8589 0.0, 1.0, 0.1, 1.0, 1.0,
8590
8591 0.0, -1.0, 0.1, 0.0, 0.0,
8592 1.0, -1.0, 0.1, 1.0, 0.0,
8593 0.0, 1.0, 0.1, 0.0, 1.0,
8594 1.0, 1.0, 0.1, 1.0, 1.0,
8595 };
8596
8597 memset(&caps, 0, sizeof(caps));
8598 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8599 ok(hr == D3D_OK, "IDirect3DDevice9_GetCaps failed, hr=%08x\n", hr);
8600 if(caps.NumSimultaneousRTs < 2) {
8601 skip("Only 1 simultaneous render target supported, skipping MRT test\n");
8602 return;
8603 }
8604
8605 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 0.0, 0);
8606 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8607
8608 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex1, NULL);
8609 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
8610 hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex2, NULL);
8611 ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
8612 hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &ps);
8613 ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed, hr=%08x\n", hr);
8614
8615 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &backbuf);
8616 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr=%08x\n", hr);
8617 hr = IDirect3DTexture9_GetSurfaceLevel(tex1, 0, &surf1);
8618 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%08x\n", hr);
8619 hr = IDirect3DTexture9_GetSurfaceLevel(tex2, 0, &surf2);
8620 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%08x\n", hr);
8621
8622 hr = IDirect3DDevice9_SetPixelShader(device, ps);
8623 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
8624 hr = IDirect3DDevice9_SetRenderTarget(device, 0, surf1);
8625 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8626 hr = IDirect3DDevice9_SetRenderTarget(device, 1, surf2);
8627 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8628 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8629 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
8630
8631 hr = IDirect3DDevice9_BeginScene(device);
8632 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr=%08x\n", hr);
8633 if(SUCCEEDED(hr)) {
8634 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
8635 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8636
8637 hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8638 ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
8639 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuf);
8640 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8641 hr = IDirect3DDevice9_SetRenderTarget(device, 1, NULL);
8642 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8643 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8644 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
8645
8646 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
8647 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8648 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[0], 5 * sizeof(float));
8649 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8650
8651 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex2);
8652 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8653 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[20], 5 * sizeof(float));
8654 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8655
8656 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
8657 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8658
8659 hr = IDirect3DDevice9_EndScene(device);
8660 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
8661 }
8662
8663 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8664 color = getPixelColor(device, 160, 240);
8665 ok(color == 0x0000ff00, "Texture 1(output color 1) has color 0x%08x, expected 0x0000ff00\n", color);
8666 color = getPixelColor(device, 480, 240);
8667 ok(color == 0x000000ff, "Texture 2(output color 2) has color 0x%08x, expected 0x000000ff\n", color);
8668
8669 IDirect3DPixelShader9_Release(ps);
8670 IDirect3DTexture9_Release(tex1);
8671 IDirect3DTexture9_Release(tex2);
8672 IDirect3DSurface9_Release(surf1);
8673 IDirect3DSurface9_Release(surf2);
8674 IDirect3DSurface9_Release(backbuf);
8675 }
8676
8677 struct formats {
8678 const char *fmtName;
8679 D3DFORMAT textureFormat;
8680 DWORD resultColorBlending;
8681 DWORD resultColorNoBlending;
8682 };
8683
8684 const struct formats test_formats[] = {
8685 { "D3DFMT_G16R16", D3DFMT_G16R16, 0x001818ff, 0x002010ff},
8686 { "D3DFMT_R16F", D3DFMT_R16F, 0x0018ffff, 0x0020ffff },
8687 { "D3DFMT_G16R16F", D3DFMT_G16R16F, 0x001818ff, 0x002010ff },
8688 { "D3DFMT_A16B16G16R16F", D3DFMT_A16B16G16R16F, 0x00181800, 0x00201000 },
8689 { "D3DFMT_R32F", D3DFMT_R32F, 0x0018ffff, 0x0020ffff },
8690 { "D3DFMT_G32R32F", D3DFMT_G32R32F, 0x001818ff, 0x002010ff },
8691 { "D3DFMT_A32B32G32R32F", D3DFMT_A32B32G32R32F, 0x00181800, 0x00201000 },
8692 { NULL, 0 }
8693 };
8694
8695 static void pixelshader_blending_test(IDirect3DDevice9 *device)
8696 {
8697 HRESULT hr;
8698 IDirect3DTexture9 *offscreenTexture = NULL;
8699 IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
8700 IDirect3D9 *d3d = NULL;
8701 DWORD color;
8702 DWORD r0, g0, b0, r1, g1, b1;
8703 int fmt_index;
8704
8705 static const float quad[][5] = {
8706 {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
8707 {-0.5f, 0.5f, 0.1f, 0.0f, 1.0f},
8708 { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
8709 { 0.5f, 0.5f, 0.1f, 1.0f, 1.0f},
8710 };
8711
8712 /* Quad with R=0x10, G=0x20 */
8713 static const struct vertex quad1[] = {
8714 {-1.0f, -1.0f, 0.1f, 0x80102000},
8715 {-1.0f, 1.0f, 0.1f, 0x80102000},
8716 { 1.0f, -1.0f, 0.1f, 0x80102000},
8717 { 1.0f, 1.0f, 0.1f, 0x80102000},
8718 };
8719
8720 /* Quad with R=0x20, G=0x10 */
8721 static const struct vertex quad2[] = {
8722 {-1.0f, -1.0f, 0.1f, 0x80201000},
8723 {-1.0f, 1.0f, 0.1f, 0x80201000},
8724 { 1.0f, -1.0f, 0.1f, 0x80201000},
8725 { 1.0f, 1.0f, 0.1f, 0x80201000},
8726 };
8727
8728 IDirect3DDevice9_GetDirect3D(device, &d3d);
8729
8730 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8731 ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
8732 if(!backbuffer) {
8733 goto out;
8734 }
8735
8736 for(fmt_index=0; test_formats[fmt_index].textureFormat != 0; fmt_index++)
8737 {
8738 D3DFORMAT fmt = test_formats[fmt_index].textureFormat;
8739 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0, D3DRTYPE_TEXTURE, fmt) != D3D_OK) {
8740 skip("%s textures not supported\n", test_formats[fmt_index].fmtName);
8741 continue;
8742 }
8743
8744 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8745 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
8746
8747 hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, fmt, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
8748 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
8749 if(!offscreenTexture) {
8750 continue;
8751 }
8752
8753 hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
8754 ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
8755 if(!offscreen) {
8756 continue;
8757 }
8758
8759 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8760 ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
8761
8762 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8763 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8764 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
8765 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8766 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
8767 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
8768 hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
8769 ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
8770 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
8771 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8772
8773 /* Below we will draw two quads with different colors and try to blend them together.
8774 * The result color is compared with the expected outcome.
8775 */
8776 if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
8777 hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
8778 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
8779 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 0.0, 0);
8780 ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
8781
8782 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
8783 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8784
8785 /* Draw a quad using color 0x0010200 */
8786 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_ONE);
8787 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8788 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_ZERO);
8789 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8790 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
8791 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8792
8793 /* Draw a quad using color 0x0020100 */
8794 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
8795 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8796 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
8797 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8798 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
8799 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8800
8801 /* We don't want to blend the result on the backbuffer */
8802 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
8803 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8804
8805 /* Prepare rendering the 'blended' texture quad to the backbuffer */
8806 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8807 ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
8808 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
8809 ok(hr == D3D_OK, "SetTexture failed, %08x\n", hr);
8810
8811 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8812 ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
8813
8814 /* This time with the texture */
8815 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8816 ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
8817
8818 IDirect3DDevice9_EndScene(device);
8819 }
8820 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8821
8822
8823 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, fmt) == D3D_OK) {
8824 /* Compare the color of the center quad with our expectation */
8825 color = getPixelColor(device, 320, 240);
8826 r0 = (color & 0x00ff0000) >> 16;
8827 g0 = (color & 0x0000ff00) >> 8;
8828 b0 = (color & 0x000000ff) >> 0;
8829
8830 r1 = (test_formats[fmt_index].resultColorBlending & 0x00ff0000) >> 16;
8831 g1 = (test_formats[fmt_index].resultColorBlending & 0x0000ff00) >> 8;
8832 b1 = (test_formats[fmt_index].resultColorBlending & 0x000000ff) >> 0;
8833
8834 ok(r0 >= max(r1, 1) - 1 && r0 <= r1 + 1 &&
8835 g0 >= max(g1, 1) - 1 && g0 <= g1 + 1 &&
8836 b0 >= max(b1, 1) - 1 && b0 <= b1 + 1,
8837 "Offscreen failed for %s: Got color %#08x, expected %#08x.\n", test_formats[fmt_index].fmtName, color, test_formats[fmt_index].resultColorBlending);
8838 } else {
8839 /* No pixel shader blending is supported so expected garbage.The type of 'garbage' depends on the driver version and OS.
8840 * E.g. on G16R16 ati reports (on old r9600 drivers) 0x00ffffff and on modern ones 0x002010ff which is also what Nvidia
8841 * reports. On Vista Nvidia seems to report 0x00ffffff on Geforce7 cards. */
8842 color = getPixelColor(device, 320, 240);
8843 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);
8844 }
8845
8846 IDirect3DDevice9_SetTexture(device, 0, NULL);
8847 if(offscreenTexture) {
8848 IDirect3DTexture9_Release(offscreenTexture);
8849 }
8850 if(offscreen) {
8851 IDirect3DSurface9_Release(offscreen);
8852 }
8853 }
8854
8855 out:
8856 /* restore things */
8857 if(backbuffer) {
8858 IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8859 IDirect3DSurface9_Release(backbuffer);
8860 }
8861 }
8862
8863 static void tssargtemp_test(IDirect3DDevice9 *device)
8864 {
8865 HRESULT hr;
8866 DWORD color;
8867 static const struct vertex quad[] = {
8868 {-1.0, -1.0, 0.1, 0x00ff0000},
8869 { 1.0, -1.0, 0.1, 0x00ff0000},
8870 {-1.0, 1.0, 0.1, 0x00ff0000},
8871 { 1.0, 1.0, 0.1, 0x00ff0000}
8872 };
8873 D3DCAPS9 caps;
8874
8875 memset(&caps, 0, sizeof(caps));
8876 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8877 ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed with %08x\n", hr);
8878 if(!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_TSSARGTEMP)) {
8879 skip("D3DPMISCCAPS_TSSARGTEMP not supported\n");
8880 return;
8881 }
8882
8883 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
8884 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
8885
8886 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8887 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8888 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
8889 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8890
8891 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8892 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8893 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TFACTOR);
8894 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8895 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_TEMP);
8896 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8897
8898 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_ADD);
8899 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8900 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG1, D3DTA_CURRENT);
8901 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8902 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG2, D3DTA_TEMP);
8903 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8904
8905 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8906 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8907
8908 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x0000ff00);
8909 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8910 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8911 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %08x\n", hr);
8912
8913 hr = IDirect3DDevice9_BeginScene(device);
8914 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr = %08x\n", hr);
8915 if(SUCCEEDED(hr)) {
8916
8917 hr = IDirect3DDevice9_EndScene(device);
8918 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %08x\n", hr);
8919 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8920 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed with %08x\n", hr);
8921 }
8922 IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8923 color = getPixelColor(device, 320, 240);
8924 ok(color == 0x00FFFF00, "TSSARGTEMP test returned color 0x%08x, expected 0x00FFFF00\n", color);
8925
8926 /* Set stage 1 back to default */
8927 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_CURRENT);
8928 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8929 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
8930 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8931 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
8932 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8933 hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
8934 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8935 hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8936 ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8937 }
8938
8939 struct testdata
8940 {
8941 DWORD idxVertex; /* number of instances in the first stream */
8942 DWORD idxColor; /* number of instances in the second stream */
8943 DWORD idxInstance; /* should be 1 ?? */
8944 DWORD color1; /* color 1 instance */
8945 DWORD color2; /* color 2 instance */
8946 DWORD color3; /* color 3 instance */
8947 DWORD color4; /* color 4 instance */
8948 WORD strVertex; /* specify which stream to use 0-2*/
8949 WORD strColor;
8950 WORD strInstance;
8951 };
8952
8953 static const struct testdata testcases[]=
8954 {
8955 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 0 */
8956 {3, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 1 */
8957 {2, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 2 */
8958 {1, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 3 */
8959 {0, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /* 4 */
8960 {4, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 5 */
8961 {4, 2, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 6 */
8962 {4, 1, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 7 */
8963 {4, 0, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /* 8 */
8964 {3, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /* 9 */
8965 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 0, 2}, /* 10 */
8966 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 2, 1}, /* 11 */
8967 {4, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 3, 1}, /* 12 */
8968 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 2, 0, 1}, /* 13 */
8969 {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 2, 3}, /* 14 */
8970 /*
8971 This case is handled in a stand alone test, SetStreamSourceFreq(0,(D3DSTREAMSOURCE_INSTANCEDATA | 1)) has to return D3DERR_INVALIDCALL!
8972 {4, 4, 1, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 1, 0, D3DERR_INVALIDCALL},
8973 */
8974 };
8975
8976 /* Drawing Indexed Geometry with instances*/
8977 static void stream_test(IDirect3DDevice9 *device)
8978 {
8979 IDirect3DVertexBuffer9 *vb = NULL;
8980 IDirect3DVertexBuffer9 *vb2 = NULL;
8981 IDirect3DVertexBuffer9 *vb3 = NULL;
8982 IDirect3DIndexBuffer9 *ib = NULL;
8983 IDirect3DVertexDeclaration9 *pDecl = NULL;
8984 IDirect3DVertexShader9 *shader = NULL;
8985 HRESULT hr;
8986 BYTE *data;
8987 DWORD color;
8988 DWORD ind;
8989 unsigned i;
8990
8991 const DWORD shader_code[] =
8992 {
8993 0xfffe0101, /* vs_1_1 */
8994 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position v0 */
8995 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */
8996 0x0000001f, 0x80000005, 0x900f0002, /* dcl_texcoord v2 */
8997 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */
8998 0x00000002, 0xc00f0000, 0x80e40000, 0x90e40002, /* add oPos, r0, v2 */
8999 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */
9000 0x0000ffff
9001 };
9002
9003 const float quad[][3] =
9004 {
9005 {-0.5f, -0.5f, 1.1f}, /*0 */
9006 {-0.5f, 0.5f, 1.1f}, /*1 */
9007 { 0.5f, -0.5f, 1.1f}, /*2 */
9008 { 0.5f, 0.5f, 1.1f}, /*3 */
9009 };
9010
9011 const float vertcolor[][4] =
9012 {
9013 {1.0f, 0.0f, 0.0f, 1.0f}, /*0 */
9014 {1.0f, 0.0f, 0.0f, 1.0f}, /*1 */
9015 {1.0f, 0.0f, 0.0f, 1.0f}, /*2 */
9016 {1.0f, 0.0f, 0.0f, 1.0f}, /*3 */
9017 };
9018
9019 /* 4 position for 4 instances */
9020 const float instancepos[][3] =
9021 {
9022 {-0.6f,-0.6f, 0.0f},
9023 { 0.6f,-0.6f, 0.0f},
9024 { 0.6f, 0.6f, 0.0f},
9025 {-0.6f, 0.6f, 0.0f},
9026 };
9027
9028 short indices[] = {0, 1, 2, 1, 2, 3};
9029
9030 D3DVERTEXELEMENT9 decl[] =
9031 {
9032 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
9033 {1, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
9034 {2, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
9035 D3DDECL_END()
9036 };
9037
9038 /* set the default value because it isn't done in wine? */
9039 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
9040 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9041
9042 /* check for D3DSTREAMSOURCE_INDEXEDDATA at stream0 */
9043 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 0, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
9044 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9045
9046 /* check wrong cases */
9047 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 0);
9048 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9049 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9050 ok(hr == D3D_OK && ind == 1, "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9051 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 2);
9052 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9053 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9054 ok(hr == D3D_OK && ind == 2, "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9055 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INDEXEDDATA | 0));
9056 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9057 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9058 ok(hr == D3D_OK && ind == (D3DSTREAMSOURCE_INDEXEDDATA | 0), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9059 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | 0));
9060 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9061 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9062 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9063 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA | 0));
9064 ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9065 hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9066 ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9067
9068 /* set the default value back */
9069 hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
9070 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9071
9072 /* create all VertexBuffers*/
9073 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0, D3DPOOL_MANAGED, &vb, NULL);
9074 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9075 if(!vb) {
9076 skip("Failed to create a vertex buffer\n");
9077 return;
9078 }
9079 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(vertcolor), 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
9080 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9081 if(!vb2) {
9082 skip("Failed to create a vertex buffer\n");
9083 goto out;
9084 }
9085 hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(instancepos), 0, 0, D3DPOOL_MANAGED, &vb3, NULL);
9086 ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9087 if(!vb3) {
9088 skip("Failed to create a vertex buffer\n");
9089 goto out;
9090 }
9091
9092 /* create IndexBuffer*/
9093 hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
9094 ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %08x\n", hr);
9095 if(!ib) {
9096 skip("Failed to create a index buffer\n");
9097 goto out;
9098 }
9099
9100 /* copy all Buffers (Vertex + Index)*/
9101 hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
9102 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9103 memcpy(data, quad, sizeof(quad));
9104 hr = IDirect3DVertexBuffer9_Unlock(vb);
9105 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9106 hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(vertcolor), (void **) &data, 0);
9107 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9108 memcpy(data, vertcolor, sizeof(vertcolor));
9109 hr = IDirect3DVertexBuffer9_Unlock(vb2);
9110 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9111 hr = IDirect3DVertexBuffer9_Lock(vb3, 0, sizeof(instancepos), (void **) &data, 0);
9112 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9113 memcpy(data, instancepos, sizeof(instancepos));
9114 hr = IDirect3DVertexBuffer9_Unlock(vb3);
9115 ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9116 hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
9117 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %08x\n", hr);
9118 memcpy(data, indices, sizeof(indices));
9119 hr = IDirect3DIndexBuffer9_Unlock(ib);
9120 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
9121
9122 /* create VertexShader */
9123 hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
9124 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%08x\n", hr);
9125 if(!shader) {
9126 skip("Failed to create a vetex shader\n");
9127 goto out;
9128 }
9129
9130 hr = IDirect3DDevice9_SetVertexShader(device, shader);
9131 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
9132
9133 hr = IDirect3DDevice9_SetIndices(device, ib);
9134 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
9135
9136 /* run all tests */
9137 for( i = 0; i < sizeof(testcases)/sizeof(testcases[0]); ++i)
9138 {
9139 struct testdata act = testcases[i];
9140 decl[0].Stream = act.strVertex;
9141 decl[1].Stream = act.strColor;
9142 decl[2].Stream = act.strInstance;
9143 /* create VertexDeclarations */
9144 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl, &pDecl);
9145 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%08x (case %i)\n", hr, i);
9146
9147 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
9148 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x (case %i)\n", hr, i);
9149
9150 hr = IDirect3DDevice9_BeginScene(device);
9151 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x (case %i)\n", hr, i);
9152 if(SUCCEEDED(hr))
9153 {
9154 hr = IDirect3DDevice9_SetVertexDeclaration(device, pDecl);
9155 ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x (case %i)\n", hr, i);
9156
9157 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxVertex));
9158 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9159 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, vb, 0, sizeof(quad[0]));
9160 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9161
9162 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strColor, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxColor));
9163 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9164 hr = IDirect3DDevice9_SetStreamSource(device, act.strColor, vb2, 0, sizeof(vertcolor[0]));
9165 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9166
9167 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strInstance, (D3DSTREAMSOURCE_INSTANCEDATA | act.idxInstance));
9168 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9169 hr = IDirect3DDevice9_SetStreamSource(device, act.strInstance, vb3, 0, sizeof(instancepos[0]));
9170 ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9171
9172 /* don't know if this is right (1*3 and 4*1)*/
9173 hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 0, 1 * 3 , 0, 4*1);
9174 ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x (case %i)\n", hr, i);
9175 hr = IDirect3DDevice9_EndScene(device);
9176 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x (case %i)\n", hr, i);
9177
9178 /* set all StreamSource && StreamSourceFreq back to default */
9179 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, 1);
9180 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9181 hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, NULL, 0, 0);
9182 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9183 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxColor, 1);
9184 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9185 hr = IDirect3DDevice9_SetStreamSource(device, act.idxColor, NULL, 0, 0);
9186 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9187 hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxInstance, 1);
9188 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9189 hr = IDirect3DDevice9_SetStreamSource(device, act.idxInstance, NULL, 0, 0);
9190 ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9191 }
9192
9193 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9194 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x (case %i)\n", hr, i);
9195
9196 hr = IDirect3DVertexDeclaration9_Release(pDecl);
9197 ok(hr == D3D_OK, "IDirect3DVertexDeclaration9_Release failed with %08x (case %i)\n", hr, i);
9198
9199 color = getPixelColor(device, 160, 360);
9200 ok(color == act.color1, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color1, i);
9201 color = getPixelColor(device, 480, 360);
9202 ok(color == act.color2, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color2, i);
9203 color = getPixelColor(device, 480, 120);
9204 ok(color == act.color3, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color3, i);
9205 color = getPixelColor(device, 160, 120);
9206 ok(color == act.color4, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color4, i);
9207 }
9208
9209 hr = IDirect3DDevice9_SetIndices(device, NULL);
9210 ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
9211
9212 out:
9213 if(vb) IDirect3DVertexBuffer9_Release(vb);
9214 if(vb2)IDirect3DVertexBuffer9_Release(vb2);
9215 if(vb3)IDirect3DVertexBuffer9_Release(vb3);
9216 if(ib)IDirect3DIndexBuffer9_Release(ib);
9217 if(shader)IDirect3DVertexShader9_Release(shader);
9218 }
9219
9220 static void np2_stretch_rect_test(IDirect3DDevice9 *device) {
9221 IDirect3DSurface9 *src = NULL, *dst = NULL, *backbuffer = NULL;
9222 IDirect3DTexture9 *dsttex = NULL;
9223 HRESULT hr;
9224 DWORD color;
9225 D3DRECT r1 = {0, 0, 50, 50 };
9226 D3DRECT r2 = {50, 0, 100, 50 };
9227 D3DRECT r3 = {50, 50, 100, 100};
9228 D3DRECT r4 = {0, 50, 50, 100};
9229 const float quad[] = {
9230 -1.0, -1.0, 0.1, 0.0, 0.0,
9231 1.0, -1.0, 0.1, 1.0, 0.0,
9232 -1.0, 1.0, 0.1, 0.0, 1.0,
9233 1.0, 1.0, 0.1, 1.0, 1.0,
9234 };
9235
9236 hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
9237 ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %08x\n", hr);
9238
9239 hr = IDirect3DDevice9_CreateRenderTarget(device, 100, 100, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &src, NULL );
9240 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateRenderTarget failed with %08x\n", hr);
9241 hr = IDirect3DDevice9_CreateTexture(device, 25, 25, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &dsttex, NULL);
9242 ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
9243
9244 if(!src || !dsttex) {
9245 skip("One or more test resources could not be created\n");
9246 goto cleanup;
9247 }
9248
9249 hr = IDirect3DTexture9_GetSurfaceLevel(dsttex, 0, &dst);
9250 ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
9251
9252 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
9253 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9254
9255 /* Clear the StretchRect destination for debugging */
9256 hr = IDirect3DDevice9_SetRenderTarget(device, 0, dst);
9257 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9258 hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
9259 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9260
9261 hr = IDirect3DDevice9_SetRenderTarget(device, 0, src);
9262 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9263
9264 hr = IDirect3DDevice9_Clear(device, 1, &r1, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9265 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9266 hr = IDirect3DDevice9_Clear(device, 1, &r2, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
9267 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9268 hr = IDirect3DDevice9_Clear(device, 1, &r3, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
9269 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9270 hr = IDirect3DDevice9_Clear(device, 1, &r4, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
9271 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9272
9273 /* Stretchrect before setting the render target back to the backbuffer. This will make Wine use
9274 * the target -> texture GL blit path
9275 */
9276 hr = IDirect3DDevice9_StretchRect(device, src, NULL, dst, NULL, D3DTEXF_POINT);
9277 ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
9278 IDirect3DSurface9_Release(dst);
9279
9280 hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
9281 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9282
9283 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) dsttex);
9284 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9285 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
9286 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
9287 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9288 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9289 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9290 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9291
9292 hr = IDirect3DDevice9_BeginScene(device);
9293 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
9294 if(SUCCEEDED(hr)) {
9295 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
9296 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
9297 hr = IDirect3DDevice9_EndScene(device);
9298 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
9299 }
9300
9301 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9302 ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
9303 color = getPixelColor(device, 160, 360);
9304 ok(color == 0x00ff0000, "stretchrect: Pixel 160,360 has color 0x%08x, expected 0x00ff0000\n", color);
9305 color = getPixelColor(device, 480, 360);
9306 ok(color == 0x0000ff00, "stretchrect: Pixel 480,360 has color 0x%08x, expected 0x0000ff00\n", color);
9307 color = getPixelColor(device, 480, 120);
9308 ok(color == 0x000000ff, "stretchrect: Pixel 480,120 has color 0x%08x, expected 0x000000ff\n", color);
9309 color = getPixelColor(device, 160, 120);
9310 ok(color == 0x00000000, "stretchrect: Pixel 160,120 has color 0x%08x, expected 0x00000000\n", color);
9311
9312 hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
9313 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9314 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9315 ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9316
9317 cleanup:
9318 if(src) IDirect3DSurface9_Release(src);
9319 if(backbuffer) IDirect3DSurface9_Release(backbuffer);
9320 if(dsttex) IDirect3DTexture9_Release(dsttex);
9321 }
9322
9323 static void texop_test(IDirect3DDevice9 *device)
9324 {
9325 IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
9326 IDirect3DTexture9 *texture = NULL;
9327 D3DLOCKED_RECT locked_rect;
9328 D3DCOLOR color;
9329 D3DCAPS9 caps;
9330 HRESULT hr;
9331 unsigned i;
9332
9333 static const struct {
9334 float x, y, z;
9335 float s, t;
9336 D3DCOLOR diffuse;
9337 } quad[] = {
9338 {-1.0f, -1.0f, 0.1f, -1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9339 {-1.0f, 1.0f, 0.1f, -1.0f, 1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9340 { 1.0f, -1.0f, 0.1f, 1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9341 { 1.0f, 1.0f, 0.1f, 1.0f, 1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)}
9342 };
9343
9344 static const D3DVERTEXELEMENT9 decl_elements[] = {
9345 {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
9346 {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
9347 {0, 20, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
9348 D3DDECL_END()
9349 };
9350
9351 static const struct {
9352 D3DTEXTUREOP op;
9353 const char *name;
9354 DWORD caps_flag;
9355 D3DCOLOR result;
9356 } test_data[] = {
9357 {D3DTOP_SELECTARG1, "SELECTARG1", D3DTEXOPCAPS_SELECTARG1, D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9358 {D3DTOP_SELECTARG2, "SELECTARG2", D3DTEXOPCAPS_SELECTARG2, D3DCOLOR_ARGB(0x00, 0x33, 0x33, 0x33)},
9359 {D3DTOP_MODULATE, "MODULATE", D3DTEXOPCAPS_MODULATE, D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x00)},
9360 {D3DTOP_MODULATE2X, "MODULATE2X", D3DTEXOPCAPS_MODULATE2X, D3DCOLOR_ARGB(0x00, 0x00, 0x66, 0x00)},
9361 {D3DTOP_MODULATE4X, "MODULATE4X", D3DTEXOPCAPS_MODULATE4X, D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9362 {D3DTOP_ADD, "ADD", D3DTEXOPCAPS_ADD, D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9363 {D3DTOP_ADDSIGNED, "ADDSIGNED", D3DTEXOPCAPS_ADDSIGNED, D3DCOLOR_ARGB(0x00, 0x00, 0xb2, 0x00)},
9364 {D3DTOP_ADDSIGNED2X, "ADDSIGNED2X", D3DTEXOPCAPS_ADDSIGNED2X, D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9365 {D3DTOP_SUBTRACT, "SUBTRACT", D3DTEXOPCAPS_SUBTRACT, D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9366 {D3DTOP_ADDSMOOTH, "ADDSMOOTH", D3DTEXOPCAPS_ADDSMOOTH, D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9367 {D3DTOP_BLENDDIFFUSEALPHA, "BLENDDIFFUSEALPHA", D3DTEXOPCAPS_BLENDDIFFUSEALPHA, D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9368 {D3DTOP_BLENDTEXTUREALPHA, "BLENDTEXTUREALPHA", D3DTEXOPCAPS_BLENDTEXTUREALPHA, D3DCOLOR_ARGB(0x00, 0x14, 0xad, 0x14)},
9369 {D3DTOP_BLENDFACTORALPHA, "BLENDFACTORALPHA", D3DTEXOPCAPS_BLENDFACTORALPHA, D3DCOLOR_ARGB(0x00, 0x07, 0xe4, 0x07)},
9370 {D3DTOP_BLENDTEXTUREALPHAPM, "BLENDTEXTUREALPHAPM", D3DTEXOPCAPS_BLENDTEXTUREALPHAPM, D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9371 {D3DTOP_BLENDCURRENTALPHA, "BLENDCURRENTALPHA", D3DTEXOPCAPS_BLENDCURRENTALPHA, D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9372 {D3DTOP_MODULATEALPHA_ADDCOLOR, "MODULATEALPHA_ADDCOLOR", D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR, D3DCOLOR_ARGB(0x00, 0x1f, 0xff, 0x1f)},
9373 {D3DTOP_MODULATECOLOR_ADDALPHA, "MODULATECOLOR_ADDALPHA", D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA, D3DCOLOR_ARGB(0x00, 0x99, 0xcc, 0x99)},
9374 {D3DTOP_MODULATEINVALPHA_ADDCOLOR, "MODULATEINVALPHA_ADDCOLOR", D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR, D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9375 {D3DTOP_MODULATEINVCOLOR_ADDALPHA, "MODULATEINVCOLOR_ADDALPHA", D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA, D3DCOLOR_ARGB(0x00, 0xcc, 0x99, 0xcc)},
9376 /* BUMPENVMAP & BUMPENVMAPLUMINANCE have their own tests */
9377 {D3DTOP_DOTPRODUCT3, "DOTPRODUCT2", D3DTEXOPCAPS_DOTPRODUCT3, D3DCOLOR_ARGB(0x00, 0x99, 0x99, 0x99)},
9378 {D3DTOP_MULTIPLYADD, "MULTIPLYADD", D3DTEXOPCAPS_MULTIPLYADD, D3DCOLOR_ARGB(0x00, 0xff, 0x33, 0x00)},
9379 {D3DTOP_LERP, "LERP", D3DTEXOPCAPS_LERP, D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x33)},
9380 };
9381
9382 memset(&caps, 0, sizeof(caps));
9383 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9384 ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9385
9386 hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
9387 ok(SUCCEEDED(hr), "CreateVertexDeclaration failed with 0x%08x\n", hr);
9388 hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
9389 ok(SUCCEEDED(hr), "SetVertexDeclaration failed with 0x%08x\n", hr);
9390
9391 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
9392 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed with 0x%08x\n", hr);
9393 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
9394 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9395 *((DWORD *)locked_rect.pBits) = D3DCOLOR_ARGB(0x99, 0x00, 0xff, 0x00);
9396 hr = IDirect3DTexture9_UnlockRect(texture, 0);
9397 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9398 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
9399 ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9400
9401 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG0, D3DTA_DIFFUSE);
9402 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9403 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9404 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9405 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9406 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9407
9408 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9409 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9410
9411 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
9412 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9413 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0xdd333333);
9414 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9415 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA);
9416 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9417
9418 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9419 ok(SUCCEEDED(hr), "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9420
9421 for (i = 0; i < sizeof(test_data) / sizeof(*test_data); ++i)
9422 {
9423 if (!(caps.TextureOpCaps & test_data[i].caps_flag))
9424 {
9425 skip("tex operation %s not supported\n", test_data[i].name);
9426 continue;
9427 }
9428
9429 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, test_data[i].op);
9430 ok(SUCCEEDED(hr), "SetTextureStageState (%s) failed with 0x%08x\n", test_data[i].name, hr);
9431
9432 hr = IDirect3DDevice9_BeginScene(device);
9433 ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9434
9435 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9436 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9437
9438 hr = IDirect3DDevice9_EndScene(device);
9439 ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9440
9441 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9442 ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9443
9444 color = getPixelColor(device, 320, 240);
9445 ok(color_match(color, test_data[i].result, 3), "Operation %s returned color 0x%08x, expected 0x%08x\n",
9446 test_data[i].name, color, test_data[i].result);
9447 }
9448
9449 if (texture) IDirect3DTexture9_Release(texture);
9450 if (vertex_declaration) IDirect3DVertexDeclaration9_Release(vertex_declaration);
9451 }
9452
9453 static void yuv_color_test(IDirect3DDevice9 *device) {
9454 HRESULT hr;
9455 IDirect3DSurface9 *surface = NULL, *target = NULL;
9456 unsigned int fmt, i;
9457 D3DFORMAT format;
9458 const char *fmt_string;
9459 D3DLOCKED_RECT lr;
9460 IDirect3D9 *d3d;
9461 HRESULT color;
9462 DWORD ref_color_left, ref_color_right;
9463
9464 struct {
9465 DWORD in; /* The input color */
9466 DWORD uyvy_left; /* "in" interpreted as uyvy and transformed to RGB, pixel 1/1*/
9467 DWORD uyvy_right; /* "in" interpreted as uyvy and transformed to RGB, pixel 2/1*/
9468 DWORD yuy2_left; /* "in" interpreted as yuy2 and transformed to RGB, pixel 1/1 */
9469 DWORD yuy2_right; /* "in" interpreted as yuy2 and transformed to RGB, pixel 2/1 */
9470 } test_data[] = {
9471 /* Originally I wanted to avoid being evil, and set Y1 = Y2 to avoid triggering troubles in shader converters,
9472 * but the main difference between YUY2 and UYVY is the swapped ordering of the chroma and luminance
9473 * values. However, handling the two Y's properly could have a big impact on image quality, so be picky about
9474 * that
9475 */
9476 { 0x00000000, 0x00008700, 0x00008700, 0x00008700, 0x00008700 },
9477 { 0xff000000, 0x00008700, 0x004bff1c, 0x00b30000, 0x00b30000 },
9478 { 0x00ff0000, 0x00b30000, 0x00b30000, 0x00008700, 0x004bff1c },
9479 { 0x0000ff00, 0x004bff1c, 0x00008700, 0x000030e1, 0x000030e1 },
9480 { 0x000000ff, 0x000030e1, 0x000030e1, 0x004bff1c, 0x00008700 },
9481 { 0xffff0000, 0x00b30000, 0x00ffd01c, 0x00b30000, 0x00ffd01c },
9482 { 0xff00ff00, 0x004bff1c, 0x004bff1c, 0x00b300e1, 0x00b300e1 },
9483 { 0xff0000ff, 0x000030e1, 0x004bffff, 0x00ffd01c, 0x00b30000 },
9484 { 0x00ffff00, 0x00ffd01c, 0x00b30000, 0x000030e1, 0x004bffff },
9485 { 0x00ff00ff, 0x00b300e1, 0x00b300e1, 0x004bff1c, 0x004bff1c },
9486 { 0x0000ffff, 0x004bffff, 0x000030e1, 0x004bffff, 0x000030e1 },
9487 { 0xffffff00, 0x00ffd01c, 0x00ffd01c, 0x00b300e1, 0x00ff79ff },
9488 { 0xffff00ff, 0x00b300e1, 0x00ff79ff, 0x00ffd01c, 0x00ffd01c },
9489 { 0xffffffff, 0x00ff79ff, 0x00ff79ff, 0x00ff79ff, 0x00ff79ff },
9490
9491 { 0x4cff4c54, 0x00ff0000, 0x00ff0000, 0x000b8b00, 0x00b6ffa3 },
9492 { 0x00800080, 0x00000000, 0x00000000, 0x0000ff00, 0x0000ff00 },
9493 { 0xFF80FF80, 0x00ffffff, 0x00ffffff, 0x00ff00ff, 0x00ff00ff },
9494 { 0x1c6b1cff, 0x000000fd, 0x000000fd, 0x006dff45, 0x0000d500 },
9495 };
9496
9497 hr = IDirect3DDevice9_GetDirect3D(device, &d3d);
9498 ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D failed, hr = %08x\n", hr);
9499 hr = IDirect3DDevice9_GetRenderTarget(device, 0, &target);
9500 ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr = %08x\n", hr);
9501
9502 IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX0);
9503 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %08x\n", hr);
9504
9505 for(fmt = 0; fmt < 2; fmt++) {
9506 if(fmt == 0) {
9507 format = D3DFMT_UYVY;
9508 fmt_string = "D3DFMT_UYVY";
9509 } else {
9510 format = D3DFMT_YUY2;
9511 fmt_string = "D3DFMT_YUY2";
9512 }
9513
9514 /* Some(all?) Windows drivers do not support YUV 3D textures, only 2D surfaces in StretchRect. Thus use
9515 * StretchRect to draw the YUV surface onto the screen instead of drawPrimitive
9516 */
9517 if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
9518 D3DRTYPE_SURFACE, format) != D3D_OK) {
9519 skip("%s is not supported\n", fmt_string);
9520 continue;
9521 }
9522
9523 /* A pixel is effectively 16 bit large, but two pixels are stored together, so the minimum size is 2x1 */
9524 hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 2, 1, format, D3DPOOL_DEFAULT, &surface, NULL);
9525 ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed, hr = %08x\n", hr);
9526
9527 for(i = 0; i < (sizeof(test_data)/sizeof(test_data[0])); i++) {
9528 if(fmt == 0) {
9529 ref_color_left = test_data[i].uyvy_left;
9530 ref_color_right = test_data[i].uyvy_right;
9531 } else {
9532 ref_color_left = test_data[i].yuy2_left;
9533 ref_color_right = test_data[i].yuy2_right;
9534 }
9535
9536 memset(&lr, 0, sizeof(lr));
9537 hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
9538 ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr = %08x\n", hr);
9539 *((DWORD *) lr.pBits) = test_data[i].in;
9540 hr = IDirect3DSurface9_UnlockRect(surface);
9541 ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr = %08x\n", hr);
9542
9543 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9544 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9545 hr = IDirect3DDevice9_StretchRect(device, surface, NULL, target, NULL, D3DTEXF_POINT);
9546 ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with 0x%08x\n", hr);
9547 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9548 ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9549
9550 /* Native D3D can't resist filtering the YUY surface, even though we asked it not to do so above. To
9551 * prevent running into precision problems, read a far left and far right pixel. In the future we may
9552 * want to add tests for the filtered pixels as well.
9553 *
9554 * Unfortunately different implementations(Windows-NV and Mac-ATI tested) interpret some colors vastly
9555 * differently, so we need a max diff of 16
9556 */
9557 color = getPixelColor(device, 40, 240);
9558 ok(color_match(color, ref_color_left, 16),
9559 "Input 0x%08x: Got color 0x%08x for pixel 1/1, expected 0x%08x, format %s\n",
9560 test_data[i].in, color, ref_color_left, fmt_string);
9561 color = getPixelColor(device, 600, 240);
9562 ok(color_match(color, ref_color_right, 16),
9563 "Input 0x%08x: Got color 0x%08x for pixel 2/1, expected 0x%08x, format %s\n",
9564 test_data[i].in, color, ref_color_left, fmt_string);
9565 }
9566 IDirect3DSurface9_Release(surface);
9567 }
9568 IDirect3DSurface9_Release(target);
9569 IDirect3D9_Release(d3d);
9570 }
9571
9572 static void texop_range_test(IDirect3DDevice9 *device)
9573 {
9574 static const struct {
9575 float x, y, z;
9576 D3DCOLOR diffuse;
9577 } quad[] = {
9578 {-1.0f, -1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9579 {-1.0f, 1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9580 { 1.0f, -1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9581 { 1.0f, 1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)}
9582 };
9583 HRESULT hr;
9584 IDirect3DTexture9 *texture;
9585 D3DLOCKED_RECT locked_rect;
9586 D3DCAPS9 caps;
9587 DWORD color;
9588
9589 /* We need ADD and SUBTRACT operations */
9590 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9591 ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9592 if (!(caps.TextureOpCaps & D3DTEXOPCAPS_ADD)) {
9593 skip("D3DTOP_ADD is not supported, skipping value range test\n");
9594 }
9595 if (!(caps.TextureOpCaps & D3DTEXOPCAPS_SUBTRACT)) {
9596 skip("D3DTEXOPCAPS_SUBTRACT is not supported, skipping value range test\n");
9597 }
9598
9599 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9600 ok(SUCCEEDED(hr), "SetFVF failed with 0x%08x\n", hr);
9601 /* Stage 1: result = diffuse(=1.0) + diffuse
9602 * stage 2: result = result - tfactor(= 0.5)
9603 */
9604 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x80808080);
9605 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9606 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
9607 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9608 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
9609 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9610 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
9611 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9612 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT);
9613 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9614 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9615 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9616 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SUBTRACT);
9617 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9618
9619 hr = IDirect3DDevice9_BeginScene(device);
9620 ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9621 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9622 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9623 hr = IDirect3DDevice9_EndScene(device);
9624 ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9625 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9626 ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9627
9628 color = getPixelColor(device, 320, 240);
9629 ok(color_match(color, 0x00808080, 1), "texop Range > 1.0 returned 0x%08x, expected 0x00808080\n",
9630 color);
9631
9632 hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
9633 ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed with 0x%08x\n", hr);
9634 hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
9635 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9636 *((DWORD *)locked_rect.pBits) = D3DCOLOR_ARGB(0x00, 0x00, 0x00, 0x00);
9637 hr = IDirect3DTexture9_UnlockRect(texture, 0);
9638 ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9639 hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
9640 ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9641
9642 /* Stage 1: result = texture(=0.0) - tfactor(= 0.5)
9643 * stage 2: result = result + diffuse(1.0)
9644 */
9645 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x80808080);
9646 ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9647 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9648 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9649 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9650 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9651 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SUBTRACT);
9652 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9653 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT);
9654 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9655 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
9656 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9657 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_ADD);
9658 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9659
9660 hr = IDirect3DDevice9_BeginScene(device);
9661 ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9662 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9663 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9664 hr = IDirect3DDevice9_EndScene(device);
9665 ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9666 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9667 ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9668
9669 color = getPixelColor(device, 320, 240);
9670 ok(color_match(color, 0x00ffffff, 1), "texop Range < 0.0 returned 0x%08x, expected 0x00ffffff\n",
9671 color);
9672
9673 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9674 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9675 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9676 ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9677 hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
9678 ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9679 IDirect3DTexture9_Release(texture);
9680 }
9681
9682 static void alphareplicate_test(IDirect3DDevice9 *device) {
9683 struct vertex quad[] = {
9684 { -1.0, -1.0, 0.1, 0x80ff00ff },
9685 { 1.0, -1.0, 0.1, 0x80ff00ff },
9686 { -1.0, 1.0, 0.1, 0x80ff00ff },
9687 { 1.0, 1.0, 0.1, 0x80ff00ff },
9688 };
9689 HRESULT hr;
9690 DWORD color;
9691
9692 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9693 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9694
9695 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9696 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9697
9698 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9699 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9700 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE | D3DTA_ALPHAREPLICATE);
9701 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9702
9703 hr = IDirect3DDevice9_BeginScene(device);
9704 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9705 if(SUCCEEDED(hr)) {
9706 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9707 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9708 hr = IDirect3DDevice9_EndScene(device);
9709 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9710 }
9711
9712 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9713 ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9714
9715 color = getPixelColor(device, 320, 240);
9716 ok(color_match(color, 0x00808080, 1), "alphareplicate test 0x%08x, expected 0x00808080\n",
9717 color);
9718
9719 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9720 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9721
9722 }
9723
9724 static void dp3_alpha_test(IDirect3DDevice9 *device) {
9725 HRESULT hr;
9726 D3DCAPS9 caps;
9727 DWORD color;
9728 struct vertex quad[] = {
9729 { -1.0, -1.0, 0.1, 0x408080c0 },
9730 { 1.0, -1.0, 0.1, 0x408080c0 },
9731 { -1.0, 1.0, 0.1, 0x408080c0 },
9732 { 1.0, 1.0, 0.1, 0x408080c0 },
9733 };
9734
9735 memset(&caps, 0, sizeof(caps));
9736 hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9737 ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9738 if (!(caps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)) {
9739 skip("D3DTOP_DOTPRODUCT3 not supported\n");
9740 return;
9741 }
9742
9743 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9744 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9745
9746 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9747 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9748
9749 /* dp3_x4 r0, diffuse_bias, tfactor_bias
9750 * mov r0.a, diffuse.a
9751 * mov r0, r0.a
9752 *
9753 * It turns out that the 2nd line is ignored, and the dp3 result written into r0.a instead
9754 * thus with input vec4(0.5, 0.5, 0.75, 0.25) and vec4(1.0, 1.0, 1.0, 1.0) the result is
9755 * (0.0 * 0.5 + 0.0 * 0.5 + 0.25 * 0.5) * 4 = 0.125 * 4 = 0.5, with a bunch of inprecision.
9756 */
9757 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DOTPRODUCT3);
9758 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9759 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
9760 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9761 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9762 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9763 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
9764 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9765 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
9766 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9767 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9768 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9769 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT | D3DTA_ALPHAREPLICATE);
9770 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9771 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
9772 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9773 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0xffffffff);
9774 ok(SUCCEEDED(hr), "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9775
9776 hr = IDirect3DDevice9_BeginScene(device);
9777 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9778 if(SUCCEEDED(hr)) {
9779 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9780 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9781 hr = IDirect3DDevice9_EndScene(device);
9782 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9783 }
9784
9785 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9786 ok(SUCCEEDED(hr), "IDirect3DDevice9_Present failed with 0x%08x\n", hr);
9787
9788 color = getPixelColor(device, 320, 240);
9789 ok(color_match(color, 0x00808080, 4), "dp3 alpha test 0x%08x, expected 0x00808080\n",
9790 color);
9791
9792 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9793 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9794 hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
9795 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9796 hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9797 ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9798 }
9799
9800 static void zwriteenable_test(IDirect3DDevice9 *device) {
9801 HRESULT hr;
9802 DWORD color;
9803 struct vertex quad1[] = {
9804 { -1.0, -1.0, 0.1, 0x00ff0000},
9805 { -1.0, 1.0, 0.1, 0x00ff0000},
9806 { 1.0, -1.0, 0.1, 0x00ff0000},
9807 { 1.0, 1.0, 0.1, 0x00ff0000},
9808 };
9809 struct vertex quad2[] = {
9810 { -1.0, -1.0, 0.9, 0x0000ff00},
9811 { -1.0, 1.0, 0.9, 0x0000ff00},
9812 { 1.0, -1.0, 0.9, 0x0000ff00},
9813 { 1.0, 1.0, 0.9, 0x0000ff00},
9814 };
9815
9816 hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x000000ff, 1.0f, 0);
9817 ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9818
9819 hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9820 ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9821 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
9822 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9823 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
9824 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9825 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
9826 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9827
9828 hr = IDirect3DDevice9_BeginScene(device);
9829 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9830 if(SUCCEEDED(hr)) {
9831 /* The Z buffer is filled with 1.0. Draw a red quad with z = 0.1, zenable = D3DZB_FALSE, zwriteenable = TRUE.
9832 * The red color is written because the z test is disabled. The question is whether the z = 0.1 values
9833 * are written into the Z buffer. After the draw, set zenable = TRUE and draw a green quad at z = 0.9.
9834 * If the values are written, the z test will fail(0.9 > 0.1) and the red color remains. If the values
9835 * are not written, the z test succeeds(0.9 < 1.0) and the green color is written. It turns out that
9836 * the screen is green, so zenable = D3DZB_FALSE and zwriteenable = TRUE does NOT write to the z buffer.
9837 */
9838 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(*quad1));
9839 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9840 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
9841 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9842 hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(*quad2));
9843 ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9844
9845 hr = IDirect3DDevice9_EndScene(device);
9846 ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9847 }
9848
9849 hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9850 ok(SUCCEEDED(hr), "IDirect3DDevice9_Present failed with 0x%08x\n", hr);
9851 color = getPixelColor(device, 320, 240);
9852 ok(color_match(color, 0x0000ff00, 1), "zwriteenable test returned 0x%08x, expected 0x0000ff00\n",
9853 color);
9854
9855 hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
9856 ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9857 }
9858
9859 START_TEST(visual)
9860 {
9861 IDirect3DDevice9 *device_ptr;
9862 D3DCAPS9 caps;
9863 HRESULT hr;
9864 DWORD color;
9865
9866 d3d9_handle = LoadLibraryA("d3d9.dll");
9867 if (!d3d9_handle)
9868 {
9869 skip("Could not load d3d9.dll\n");
9870 return;
9871 }
9872
9873 device_ptr = init_d3d9();
9874 if (!device_ptr)
9875 {
9876 skip("Creating the device failed\n");
9877 return;
9878 }
9879
9880 IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps);
9881
9882 /* Check for the reliability of the returned data */
9883 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9884 if(FAILED(hr))
9885 {
9886 skip("Clear failed, can't assure correctness of the test results, skipping\n");
9887 goto cleanup;
9888 }
9889 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9890
9891 color = getPixelColor(device_ptr, 1, 1);
9892 if(color !=0x00ff0000)
9893 {
9894 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9895 goto cleanup;
9896 }
9897
9898 hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
9899 if(FAILED(hr))
9900 {
9901 skip("Clear failed, can't assure correctness of the test results, skipping\n");
9902 goto cleanup;
9903 }
9904 IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9905
9906 color = getPixelColor(device_ptr, 639, 479);
9907 if(color != 0x0000ddee)
9908 {
9909 skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9910 goto cleanup;
9911 }
9912
9913 /* Now execute the real tests */
9914 stretchrect_test(device_ptr);
9915 lighting_test(device_ptr);
9916 clear_test(device_ptr);
9917 fog_test(device_ptr);
9918 if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
9919 {
9920 test_cube_wrap(device_ptr);
9921 } else {
9922 skip("No cube texture support\n");
9923 }
9924 z_range_test(device_ptr);
9925 if(caps.TextureCaps & D3DPTEXTURECAPS_MIPMAP)
9926 {
9927 maxmip_test(device_ptr);
9928 }
9929 else
9930 {
9931 skip("No mipmap support\n");
9932 }
9933 offscreen_test(device_ptr);
9934 alpha_test(device_ptr);
9935 shademode_test(device_ptr);
9936 srgbtexture_test(device_ptr);
9937 release_buffer_test(device_ptr);
9938 float_texture_test(device_ptr);
9939 g16r16_texture_test(device_ptr);
9940 pixelshader_blending_test(device_ptr);
9941 texture_transform_flags_test(device_ptr);
9942 autogen_mipmap_test(device_ptr);
9943 fixed_function_decl_test(device_ptr);
9944 conditional_np2_repeat_test(device_ptr);
9945 fixed_function_bumpmap_test(device_ptr);
9946 if(caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) {
9947 stencil_cull_test(device_ptr);
9948 } else {
9949 skip("No two sided stencil support\n");
9950 }
9951 pointsize_test(device_ptr);
9952 tssargtemp_test(device_ptr);
9953 np2_stretch_rect_test(device_ptr);
9954 yuv_color_test(device_ptr);
9955 zwriteenable_test(device_ptr);
9956
9957 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
9958 {
9959 test_constant_clamp_vs(device_ptr);
9960 test_compare_instructions(device_ptr);
9961 }
9962 else skip("No vs_1_1 support\n");
9963
9964 if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
9965 {
9966 test_mova(device_ptr);
9967 if (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9968 test_vshader_input(device_ptr);
9969 test_vshader_float16(device_ptr);
9970 stream_test(device_ptr);
9971 } else {
9972 skip("No vs_3_0 support\n");
9973 }
9974 }
9975 else skip("No vs_2_0 support\n");
9976
9977 if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1) && caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9978 {
9979 fog_with_shader_test(device_ptr);
9980 fog_srgbwrite_test(device_ptr);
9981 }
9982 else skip("No vs_1_1 and ps_1_1 support\n");
9983
9984 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9985 {
9986 texbem_test(device_ptr);
9987 texdepth_test(device_ptr);
9988 texkill_test(device_ptr);
9989 x8l8v8u8_test(device_ptr);
9990 if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 4)) {
9991 constant_clamp_ps_test(device_ptr);
9992 cnd_test(device_ptr);
9993 if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) {
9994 dp2add_ps_test(device_ptr);
9995 if (caps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) {
9996 nested_loop_test(device_ptr);
9997 fixed_function_varying_test(device_ptr);
9998 vFace_register_test(device_ptr);
9999 vpos_register_test(device_ptr);
10000 multiple_rendertargets_test(device_ptr);
10001 if(caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
10002 vshader_version_varying_test(device_ptr);
10003 pshader_version_varying_test(device_ptr);
10004 } else {
10005 skip("No vs_3_0 support\n");
10006 }
10007 } else {
10008 skip("No ps_3_0 support\n");
10009 }
10010 } else {
10011 skip("No ps_2_0 support\n");
10012 }
10013 }
10014 }
10015 else skip("No ps_1_1 support\n");
10016
10017 texop_test(device_ptr);
10018 texop_range_test(device_ptr);
10019 alphareplicate_test(device_ptr);
10020 dp3_alpha_test(device_ptr);
10021
10022 cleanup:
10023 if(device_ptr) {
10024 ULONG ref;
10025
10026 D3DPRESENT_PARAMETERS present_parameters;
10027 IDirect3DSwapChain9 *swapchain;
10028 IDirect3DDevice9_GetSwapChain(device_ptr, 0, &swapchain);
10029 IDirect3DSwapChain9_GetPresentParameters(swapchain, &present_parameters);
10030 IDirect3DSwapChain9_Release(swapchain);
10031 ref = IDirect3DDevice9_Release(device_ptr);
10032 DestroyWindow(present_parameters.hDeviceWindow);
10033 ok(ref == 0, "The device was not properly freed: refcount %u\n", ref);
10034 }
10035 }
useful hacks and other patches not (yet) suitable for mainline