git.oblomov.eu Git - wine/blob - dlls/d3d9/tests/visual.c

   1 /*
   2  * Copyright 2005, 2007 Henri Verbeet
   3  * Copyright (C) 2007 Stefan Dösinger(for CodeWeavers)
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 /* This test framework allows limited testing of rendering results. Things are rendered, shown on
  21  * the framebuffer, read back from there and compared to expected colors.
  22  *
  23  * However, neither d3d nor opengl is guaranteed to be pixel exact, and thus the capability of this test
  24  * is rather limited. As a general guideline for adding tests, do not rely on corner pixels. Draw a big enough
  25  * area which shows specific behavior(like a quad on the whole screen), and try to get resulting colos with
  26  * all bits set or unset in all channels(like pure red, green, blue, white, black). Hopefully everything that
  27  * causes visible results in games can be tested in a way that does not depend on pixel exactness
  28  */
  29
  30 #define COBJMACROS
  31 #include <d3d9.h>
  32 #include <dxerr9.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 DWORD getPixelColor(IDirect3DDevice9 *device, UINT x, UINT y)
  51 {
  52     DWORD ret;
  53     IDirect3DSurface9 *surf;
  54     HRESULT hr;
  55     D3DLOCKED_RECT lockedRect;
  56     RECT rectToLock = {x, y, x+1, y+1};
  57
  58     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 640, 480, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf, NULL);
  59     if(FAILED(hr) || !surf )  /* This is not a test */
  60     {
  61         trace("Can't create an offscreen plain surface to read the render target data, hr=%s\n", DXGetErrorString9(hr));
  62         return 0xdeadbeef;
  63     }
  64
  65     hr = IDirect3DDevice9_GetFrontBufferData(device, 0, surf);
  66     if(FAILED(hr))
  67     {
  68         trace("Can't read the front buffer data, hr=%s\n", DXGetErrorString9(hr));
  69         ret = 0xdeadbeed;
  70         goto out;
  71     }
  72
  73     hr = IDirect3DSurface9_LockRect(surf, &lockedRect, &rectToLock, D3DLOCK_READONLY);
  74     if(FAILED(hr))
  75     {
  76         trace("Can't lock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
  77         ret = 0xdeadbeec;
  78         goto out;
  79     }
  80
  81     /* Remove the X channel for now. DirectX and OpenGL have different ideas how to treat it apparently, and it isn't
  82      * really important for these tests
  83      */
  84     ret = ((DWORD *) lockedRect.pBits)[0] & 0x00ffffff;
  85     hr = IDirect3DSurface9_UnlockRect(surf);
  86     if(FAILED(hr))
  87     {
  88         trace("Can't unlock the offscreen surface, hr=%s\n", DXGetErrorString9(hr));
  89     }
  90
  91 out:
  92     if(surf) IDirect3DSurface9_Release(surf);
  93     return ret;
  94 }
  95
  96 static IDirect3DDevice9 *init_d3d9(void)
  97 {
  98     IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
  99     IDirect3D9 *d3d9_ptr = 0;
 100     IDirect3DDevice9 *device_ptr = 0;
 101     D3DPRESENT_PARAMETERS present_parameters;
 102     HRESULT hr;
 103
 104     d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
 105     ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
 106     if (!d3d9_create) return NULL;
 107
 108     d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
 109     ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
 110     if (!d3d9_ptr) return NULL;
 111
 112     ZeroMemory(&present_parameters, sizeof(present_parameters));
 113     present_parameters.Windowed = FALSE;
 114     present_parameters.hDeviceWindow = create_window();
 115     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
 116     present_parameters.BackBufferWidth = 640;
 117     present_parameters.BackBufferHeight = 480;
 118     present_parameters.BackBufferFormat = D3DFMT_X8R8G8B8;
 119
 120     hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, present_parameters.hDeviceWindow, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
 121     ok(hr == D3D_OK, "IDirect3D_CreateDevice returned: %s\n", DXGetErrorString9(hr));
 122
 123     return device_ptr;
 124 }
 125
 126 struct vertex
 127 {
 128     float x, y, z;
 129     DWORD diffuse;
 130 };
 131
 132 struct nvertex
 133 {
 134     float x, y, z;
 135     float nx, ny, nz;
 136     DWORD diffuse;
 137 };
 138
 139 static void lighting_test(IDirect3DDevice9 *device)
 140 {
 141     HRESULT hr;
 142     DWORD fvf = D3DFVF_XYZ | D3DFVF_DIFFUSE;
 143     DWORD nfvf = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_NORMAL;
 144     DWORD color;
 145
 146     float mat[16] = { 1.0, 0.0, 0.0, 0.0,
 147                       0.0, 1.0, 0.0, 0.0,
 148                       0.0, 0.0, 1.0, 0.0,
 149                       0.0, 0.0, 0.0, 1.0 };
 150
 151     struct vertex unlitquad[] =
 152     {
 153         {-1.0,  -1.0,    0.1,                           0xffff0000},
 154         {-1.0,   0.0,    0.1,                           0xffff0000},
 155         { 0.0,   0.0,    0.1,                           0xffff0000},
 156         { 0.0,  -1.0,    0.1,                           0xffff0000},
 157     };
 158     struct vertex litquad[] =
 159     {
 160         {-1.0,   0.0,    0.1,                           0xff00ff00},
 161         {-1.0,   1.0,    0.1,                           0xff00ff00},
 162         { 0.0,   1.0,    0.1,                           0xff00ff00},
 163         { 0.0,   0.0,    0.1,                           0xff00ff00},
 164     };
 165     struct nvertex unlitnquad[] =
 166     {
 167         { 0.0,  -1.0,    0.1,   1.0,    1.0,    1.0,    0xff0000ff},
 168         { 0.0,   0.0,    0.1,   1.0,    1.0,    1.0,    0xff0000ff},
 169         { 1.0,   0.0,    0.1,   1.0,    1.0,    1.0,    0xff0000ff},
 170         { 1.0,  -1.0,    0.1,   1.0,    1.0,    1.0,    0xff0000ff},
 171     };
 172     struct nvertex litnquad[] =
 173     {
 174         { 0.0,   0.0,    0.1,   1.0,    1.0,    1.0,    0xffffff00},
 175         { 0.0,   1.0,    0.1,   1.0,    1.0,    1.0,    0xffffff00},
 176         { 1.0,   1.0,    0.1,   1.0,    1.0,    1.0,    0xffffff00},
 177         { 1.0,   0.0,    0.1,   1.0,    1.0,    1.0,    0xffffff00},
 178     };
 179     WORD Indices[] = {0, 1, 2, 2, 3, 0};
 180
 181     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 182     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
 183
 184     /* Setup some states that may cause issues */
 185     hr = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(0), (D3DMATRIX *) mat);
 186     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
 187     hr = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, (D3DMATRIX *)mat);
 188     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
 189     hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, (D3DMATRIX *) mat);
 190     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform returned %s\n", DXGetErrorString9(hr));
 191     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
 192     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 193     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE);
 194     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 195     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
 196     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 197     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
 198     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 199     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHATESTENABLE, FALSE);
 200     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 201     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
 202     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 203     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
 204     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 205     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
 206     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
 207     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLED_RED | D3DCOLORWRITEENABLED_GREEN | D3DCOLORWRITEENABLED_BLUE);
 208     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %s\n", DXGetErrorString9(hr));
 209
 210     hr = IDirect3DDevice9_SetFVF(device, fvf);
 211     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %s\n", DXGetErrorString9(hr));
 212
 213     hr = IDirect3DDevice9_BeginScene(device);
 214     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %s\n", DXGetErrorString9(hr));
 215     if(hr == D3D_OK)
 216     {
 217         /* No lights are defined... That means, lit vertices should be entirely black */
 218         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 219         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 220         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 221                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitquad, sizeof(unlitquad[0]));
 222         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
 223
 224         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
 225         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 226         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 227                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, litquad, sizeof(litquad[0]));
 228         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
 229
 230         hr = IDirect3DDevice9_SetFVF(device, nfvf);
 231         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %s\n", DXGetErrorString9(hr));
 232
 233         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 234         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 235         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 236                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitnquad, sizeof(unlitnquad[0]));
 237         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
 238
 239         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
 240         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 241         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 242                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, litnquad, sizeof(litnquad[0]));
 243         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %s\n", DXGetErrorString9(hr));
 244
 245         IDirect3DDevice9_EndScene(device);
 246         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %s\n", DXGetErrorString9(hr));
 247     }
 248
 249     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 250
 251     color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
 252     ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
 253     color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
 254     ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
 255     color = getPixelColor(device, 480, 360); /* lower left quad - unlit width normals */
 256     ok(color == 0x000000ff, "Unlit quad width normals has color %08x\n", color);
 257     color = getPixelColor(device, 480, 120); /* upper left quad - lit width normals */
 258     ok(color == 0x00000000, "Lit quad width normals has color %08x\n", color);
 259
 260     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 261     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 262
 263     /* Hack for a bug in d3d9: SetFVF creates a converted vertex declaration, with a circular refcount.
 264      * This prevents the screen resolution from being restored correctly on device release. Unset the vdecl
 265      */
 266     IDirect3DDevice9_SetVertexDeclaration(device, NULL);
 267 }
 268
 269 static void clear_test(IDirect3DDevice9 *device)
 270 {
 271     /* Tests the correctness of clearing parameters */
 272     HRESULT hr;
 273     D3DRECT rect[2];
 274     D3DRECT rect_negneg;
 275     DWORD color;
 276
 277     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 278     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
 279
 280     /* Positive x, negative y */
 281     rect[0].x1 = 0;
 282     rect[0].y1 = 480;
 283     rect[0].x2 = 320;
 284     rect[0].y2 = 240;
 285
 286     /* Positive x, positive y */
 287     rect[1].x1 = 0;
 288     rect[1].y1 = 0;
 289     rect[1].x2 = 320;
 290     rect[1].y2 = 240;
 291     /* Clear 2 rectangles with one call. Shows that a positive value is returned, but the negative rectangle
 292      * is ignored, the positive is still cleared afterwards
 293      */
 294     hr = IDirect3DDevice9_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
 295     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
 296
 297     /* negative x, negative y */
 298     rect_negneg.x1 = 640;
 299     rect_negneg.x1 = 240;
 300     rect_negneg.x2 = 320;
 301     rect_negneg.y2 = 0;
 302     hr = IDirect3DDevice9_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
 303     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %s\n", DXGetErrorString9(hr));
 304
 305     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 306
 307     color = getPixelColor(device, 160, 360); /* lower left quad */
 308     ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
 309     color = getPixelColor(device, 160, 120); /* upper left quad */
 310     ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
 311     color = getPixelColor(device, 480, 360); /* lower right quad  */
 312     ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
 313     color = getPixelColor(device, 480, 120); /* upper right quad */
 314     ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
 315 }
 316
 317 typedef struct {
 318     float in[4];
 319     DWORD out;
 320 } test_data_t;
 321
 322 /*
 323  *  c7      rounded     ARGB
 324  * -2.4     -2          0x00ffff00
 325  * -1.6     -2          0x00ffff00
 326  * -0.4      0          0x0000ffff
 327  *  0.4      0          0x0000ffff
 328  *  1.6      2          0x00ff00ff
 329  *  2.4      2          0x00ff00ff
 330  */
 331 static void test_mova(IDirect3DDevice9 *device)
 332 {
 333     static const DWORD mova_test[] = {
 334         0xfffe0200,                                                             /* vs_2_0                       */
 335         0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
 336         0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0   */
 337         0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0   */
 338         0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0   */
 339         0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0   */
 340         0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0   */
 341         0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0   */
 342         0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0   */
 343         0x0200002e, 0xb0010000, 0xa0000007,                                     /* mova a0.x, c7.x              */
 344         0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000,                         /* mov oD0, c[a0.x + 3]         */
 345         0x02000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
 346         0x0000ffff                                                              /* END                          */
 347     };
 348
 349     static const test_data_t test_data[] = {
 350         {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
 351         {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
 352         {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
 353         {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
 354         {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff},
 355         {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
 356     };
 357
 358     static const float quad[][3] = {
 359         {-1.0f, -1.0f, 0.0f},
 360         {-1.0f,  1.0f, 0.0f},
 361         { 1.0f, -1.0f, 0.0f},
 362         { 1.0f,  1.0f, 0.0f},
 363     };
 364
 365     static const D3DVERTEXELEMENT9 decl_elements[] = {
 366         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 367         D3DDECL_END()
 368     };
 369
 370     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
 371     IDirect3DVertexShader9 *mova_shader = NULL;
 372     HRESULT hr;
 373     int i;
 374
 375     hr = IDirect3DDevice9_CreateVertexShader(device, mova_test, &mova_shader);
 376     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
 377     hr = IDirect3DDevice9_SetVertexShader(device, mova_shader);
 378     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 379
 380     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
 381     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
 382     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
 383     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
 384
 385     for (i = 0; i < (sizeof(test_data) / sizeof(test_data_t)); ++i)
 386     {
 387         DWORD color;
 388
 389         hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 7, test_data[i].in, 1);
 390         ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
 391
 392         hr = IDirect3DDevice9_BeginScene(device);
 393         ok(SUCCEEDED(hr), "BeginScene failed (%08x)\n", hr);
 394
 395         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], 3 * sizeof(float));
 396         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
 397
 398         hr = IDirect3DDevice9_EndScene(device);
 399         ok(SUCCEEDED(hr), "EndScene failed (%08x)\n", hr);
 400
 401         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 402         ok(SUCCEEDED(hr), "Present failed (%08x)\n", hr);
 403
 404         color = getPixelColor(device, 320, 240);
 405         ok(color == test_data[i].out, "Expected color %08x, got %08x (for input %f)\n", test_data[i].out, color, test_data[i].in[0]);
 406
 407         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
 408         ok(SUCCEEDED(hr), "Clear failed (%08x)\n", hr);
 409     }
 410
 411     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
 412     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 413
 414     IDirect3DVertexDeclaration9_Release(vertex_declaration);
 415     IDirect3DVertexShader9_Release(mova_shader);
 416 }
 417
 418 struct sVertex {
 419     float x, y, z;
 420     DWORD diffuse;
 421     DWORD specular;
 422 };
 423
 424 struct sVertexT {
 425     float x, y, z, rhw;
 426     DWORD diffuse;
 427     DWORD specular;
 428 };
 429
 430 static void fog_test(IDirect3DDevice9 *device)
 431 {
 432     HRESULT hr;
 433     DWORD color;
 434     float start = 0.0, end = 1.0;
 435
 436     /* Gets full z based fog with linear fog, no fog with specular color */
 437     struct sVertex unstransformed_1[] = {
 438         {-1,    -1,   0.1,          0xFFFF0000,     0xFF000000  },
 439         {-1,     0,   0.1,          0xFFFF0000,     0xFF000000  },
 440         { 0,     0,   0.1,          0xFFFF0000,     0xFF000000  },
 441         { 0,    -1,   0.1,          0xFFFF0000,     0xFF000000  },
 442     };
 443     /* Ok, I am too lazy to deal with transform matrices */
 444     struct sVertex unstransformed_2[] = {
 445         {-1,     0,   1.0,          0xFFFF0000,     0xFF000000  },
 446         {-1,     1,   1.0,          0xFFFF0000,     0xFF000000  },
 447         { 0,     1,   1.0,          0xFFFF0000,     0xFF000000  },
 448         { 0,     0,   1.0,          0xFFFF0000,     0xFF000000  },
 449     };
 450     /* Untransformed ones. Give them a different diffuse color to make the test look
 451      * nicer. It also makes making sure that they are drawn correctly easier.
 452      */
 453     struct sVertexT transformed_1[] = {
 454         {320,    0,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 455         {640,    0,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 456         {640,  240,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 457         {320,  240,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 458     };
 459     struct sVertexT transformed_2[] = {
 460         {320,  240,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 461         {640,  240,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 462         {640,  480,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 463         {320,  480,   1.0,  1.0,    0xFFFFFF00,     0xFF000000  },
 464     };
 465     WORD Indices[] = {0, 1, 2, 2, 3, 0};
 466
 467     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
 468     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %s\n", DXGetErrorString9(hr));
 469
 470     /* Setup initial states: No lighting, fog on, fog color */
 471     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 472     ok(hr == D3D_OK, "Turning off lighting returned %s\n", DXGetErrorString9(hr));
 473     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
 474     ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
 475     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
 476     ok(hr == D3D_OK, "Turning on fog calculations returned %s\n", DXGetErrorString9(hr));
 477
 478     /* First test: Both table fog and vertex fog off */
 479     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
 480     ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
 481     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
 482     ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
 483
 484     /* Start = 0, end = 1. Should be default, but set them */
 485     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
 486     ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
 487     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
 488     ok(hr == D3D_OK, "Setting fog start returned %s\n", DXGetErrorString9(hr));
 489
 490     if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
 491     {
 492         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 493         ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
 494         /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
 495         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 496                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
 497                                                      sizeof(unstransformed_1[0]));
 498         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
 499
 500         /* That makes it use the Z value */
 501         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
 502         ok(hr == D3D_OK, "Turning off table fog returned %s\n", DXGetErrorString9(hr));
 503         /* Untransformed, vertex fog != none (or table fog != none):
 504          * Use the Z value as input into the equation
 505          */
 506         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 507                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
 508                                                      sizeof(unstransformed_1[0]));
 509         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
 510
 511         /* transformed verts */
 512         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 513         ok( hr == D3D_OK, "SetFVF returned %s\n", DXGetErrorString9(hr));
 514         /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
 515         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 516                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
 517                                                      sizeof(transformed_1[0]));
 518         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %s\n", DXGetErrorString9(hr));
 519
 520         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
 521         ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %s\n", DXGetErrorString9(hr));
 522         /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
 523          * equation
 524          */
 525         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 526                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_2,
 527                                                      sizeof(transformed_2[0]));
 528
 529         hr = IDirect3DDevice9_EndScene(device);
 530         ok(hr == D3D_OK, "EndScene returned %s\n", DXGetErrorString9(hr));
 531     }
 532     else
 533     {
 534         ok(FALSE, "BeginScene failed\n");
 535     }
 536
 537     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 538     color = getPixelColor(device, 160, 360);
 539     ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
 540     color = getPixelColor(device, 160, 120);
 541     ok(color == 0x0000FF00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
 542     color = getPixelColor(device, 480, 120);
 543     ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
 544     color = getPixelColor(device, 480, 360);
 545     ok(color == 0x0000FF00, "Transformed vertex with linear table fog has color %08x\n", color);
 546
 547     /* Turn off the fog master switch to avoid confusing other tests */
 548     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
 549     ok(hr == D3D_OK, "Turning off fog calculations returned %s\n", DXGetErrorString9(hr));
 550
 551     IDirect3DDevice9_SetVertexDeclaration(device, NULL);
 552 }
 553
 554 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
 555  * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
 556  * regardless of the actual addressing mode set. */
 557 static void test_cube_wrap(IDirect3DDevice9 *device)
 558 {
 559     static const float quad[][6] = {
 560         {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
 561         {-1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
 562         { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
 563         { 1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
 564     };
 565
 566     static const D3DVERTEXELEMENT9 decl_elements[] = {
 567         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 568         {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
 569         D3DDECL_END()
 570     };
 571
 572     static const struct {
 573         D3DTEXTUREADDRESS mode;
 574         const char *name;
 575     } address_modes[] = {
 576         {D3DTADDRESS_WRAP, "D3DTADDRESS_WRAP"},
 577         {D3DTADDRESS_MIRROR, "D3DTADDRESS_MIRROR"},
 578         {D3DTADDRESS_CLAMP, "D3DTADDRESS_CLAMP"},
 579         {D3DTADDRESS_BORDER, "D3DTADDRESS_BORDER"},
 580         {D3DTADDRESS_MIRRORONCE, "D3DTADDRESS_MIRRORONCE"},
 581     };
 582
 583     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
 584     IDirect3DCubeTexture9 *texture = NULL;
 585     IDirect3DSurface9 *surface = NULL;
 586     D3DLOCKED_RECT locked_rect;
 587     HRESULT hr;
 588     INT x, y, face;
 589
 590     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
 591     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
 592     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
 593     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
 594
 595     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 128, 128,
 596             D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
 597     ok(SUCCEEDED(hr), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr);
 598
 599     hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, D3DLOCK_DISCARD);
 600     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
 601
 602     for (y = 0; y < 128; ++y)
 603     {
 604         DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
 605         for (x = 0; x < 64; ++x)
 606         {
 607             *ptr++ = 0xffff0000;
 608         }
 609         for (x = 64; x < 128; ++x)
 610         {
 611             *ptr++ = 0xff0000ff;
 612         }
 613     }
 614
 615     hr = IDirect3DSurface9_UnlockRect(surface);
 616     ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
 617
 618     hr = IDirect3DDevice9_CreateCubeTexture(device, 128, 1, 0, D3DFMT_A8R8G8B8,
 619             D3DPOOL_DEFAULT, &texture, NULL);
 620     ok(SUCCEEDED(hr), "CreateCubeTexture failed (0x%08x)\n", hr);
 621
 622     /* Create cube faces */
 623     for (face = 0; face < 6; ++face)
 624     {
 625         IDirect3DSurface9 *face_surface = NULL;
 626
 627         hr= IDirect3DCubeTexture9_GetCubeMapSurface(texture, face, 0, &face_surface);
 628         ok(SUCCEEDED(hr), "GetCubeMapSurface failed (0x%08x)\n", hr);
 629
 630         hr = IDirect3DDevice9_UpdateSurface(device, surface, NULL, face_surface, NULL);
 631         ok(SUCCEEDED(hr), "UpdateSurface failed (0x%08x)\n", hr);
 632
 633         IDirect3DSurface9_Release(face_surface);
 634     }
 635
 636     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
 637     ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
 638
 639     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 640     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
 641     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 642     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
 643     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_BORDERCOLOR, 0xff00ff00);
 644     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr);
 645
 646     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 647     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %s\n", DXGetErrorString9(hr));
 648
 649     for (x = 0; x < (sizeof(address_modes) / sizeof(*address_modes)); ++x)
 650     {
 651         DWORD color;
 652
 653         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, address_modes[x].mode);
 654         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes[x].name, hr);
 655         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, address_modes[x].mode);
 656         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes[x].name, hr);
 657
 658         hr = IDirect3DDevice9_BeginScene(device);
 659         ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
 660
 661         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
 662         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
 663
 664         hr = IDirect3DDevice9_EndScene(device);
 665         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
 666
 667         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 668         ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
 669
 670         /* Due to the nature of this test, we sample essentially at the edge
 671          * between two faces. Because of this it's undefined from which face
 672          * the driver will sample. Furtunately that's not important for this
 673          * test, since all we care about is that it doesn't sample from the
 674          * other side of the surface or from the border. */
 675         color = getPixelColor(device, 320, 240);
 676         ok(color == 0x00ff0000 || color == 0x000000ff,
 677                 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
 678                 color, address_modes[x].name);
 679
 680         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
 681         ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
 682     }
 683
 684     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
 685     ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
 686
 687     IDirect3DVertexDeclaration9_Release(vertex_declaration);
 688     IDirect3DCubeTexture9_Release(texture);
 689     IDirect3DSurface9_Release(surface);
 690 }
 691
 692 /* This test tests fog in combination with shaders.
 693  * What's tested: linear fog (vertex and table) with pixel shader
 694  *                linear table fog with non foggy vertex shader
 695  *                vertex fog with foggy vertex shader
 696  * What's not tested: non linear fog with shader
 697  *                    table fog with foggy vertex shader
 698  */
 699 static void fog_with_shader_test(IDirect3DDevice9 *device)
 700 {
 701     HRESULT hr;
 702     DWORD color;
 703     /* NOTE: changing these values will not effect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
 704     union {float f; DWORD i;} start={.f=0.9}, end={.f=0.1};
 705     unsigned int i, j;
 706
 707     /* basic vertex shader without fog computation ("non foggy") */
 708     static const DWORD vertex_shader_code1[] = {
 709         0xfffe0101,                                                             /* vs_1_1                       */
 710         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
 711         0x0000001f, 0x8000000a, 0x900f0001,                                     /* dcl_color0 v1                */
 712         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
 713         0x00000001, 0xd00f0000, 0x90e40001,                                     /* mov oD0, v1                  */
 714         0x0000ffff
 715     };
 716     /* basic vertex shader with reversed fog computation ("foggy") */
 717     static const DWORD vertex_shader_code2[] = {
 718         0xfffe0101,                                                             /* vs_1_1                        */
 719         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0               */
 720         0x0000001f, 0x8000000a, 0x900f0001,                                     /* dcl_color0 v1                 */
 721         0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
 722         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                  */
 723         0x00000001, 0xd00f0000, 0x90e40001,                                     /* mov oD0, v1                   */
 724         0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000,                         /* add r0, v0.z, c0.z            */
 725         0x00000005, 0xc00f0001, 0x80000000, 0xa0000000,                         /* mul oFog, r0.x, c0.x          */
 726         0x0000ffff
 727     };
 728     /* basic pixel shader */
 729     static const DWORD pixel_shader_code[] = {
 730         0xffff0101,                                                             /* ps_1_1     */
 731         0x00000001, 0x800f0000, 0x90e40000,                                     /* mov r0, vo */
 732         0x0000ffff
 733     };
 734
 735     static struct vertex quad[] = {
 736         {-1.0f, -1.0f,  0.0f,          0xFFFF0000  },
 737         {-1.0f,  1.0f,  0.0f,          0xFFFF0000  },
 738         { 1.0f, -1.0f,  0.0f,          0xFFFF0000  },
 739         { 1.0f,  1.0f,  0.0f,          0xFFFF0000  },
 740     };
 741
 742     static const D3DVERTEXELEMENT9 decl_elements[] = {
 743         {0,  0, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 744         {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT,    D3DDECLUSAGE_COLOR, 0},
 745         D3DDECL_END()
 746     };
 747
 748     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
 749     IDirect3DVertexShader9      *vertex_shader[3]   = {NULL, NULL, NULL};
 750     IDirect3DPixelShader9       *pixel_shader[2]    = {NULL, NULL};
 751
 752     /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
 753     static const struct test_data_t {
 754         int vshader;
 755         int pshader;
 756         D3DFOGMODE vfog;
 757         D3DFOGMODE tfog;
 758         unsigned int color[11];
 759     } test_data[] = {
 760         /* only pixel shader: */
 761         {0, 1, 0, 3,
 762         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 763          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 764         {0, 1, 1, 3,
 765         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 766          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 767         {0, 1, 2, 3,
 768         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 769          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 770         {0, 1, 3, 0,
 771         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 772          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 773         {0, 1, 3, 3,
 774         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 775          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 776
 777         /* vertex shader */
 778         {1, 0, 0, 0,
 779         {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
 780          0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
 781         {1, 0, 0, 3,
 782         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 783          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 784         {1, 0, 1, 3,
 785         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 786          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 787         {1, 0, 2, 3,
 788         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 789          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 790         {1, 0, 3, 3,
 791         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 792          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 793
 794         /* vertex shader and pixel shader */
 795         {1, 1, 0, 3,
 796         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 797          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 798         {1, 1, 1, 3,
 799         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 800          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 801         {1, 1, 2, 3,
 802         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 803          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 804         {1, 1, 3, 3,
 805         {0x0000ff00, 0x0000ff00, 0x0020df00, 0x0040bf00, 0x005fa000, 0x007f8000,
 806          0x009f6000, 0x00bf4000, 0x00df2000, 0x00ff0000, 0x00df2000}},
 807
 808         /* foggy vertex shader */
 809         {2, 0, 0, 0,
 810         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 811          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 812         {2, 0, 1, 0,
 813         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 814          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 815         {2, 0, 2, 0,
 816         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 817          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 818         {2, 0, 3, 0,
 819         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 820          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 821
 822         /* foggy vertex shader and pixel shader */
 823         {2, 1, 0, 0,
 824         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 825          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 826         {2, 1, 1, 0,
 827         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 828          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 829         {2, 1, 2, 0,
 830         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 831          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 832         {2, 1, 3, 0,
 833         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
 834          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x001fe000}},
 835
 836     };
 837
 838     hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]);
 839     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
 840     hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]);
 841     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
 842     hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]);
 843     ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
 844     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
 845     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
 846
 847     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
 848     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
 849
 850     /* Setup initial states: No lighting, fog on, fog color */
 851     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 852     ok(hr == D3D_OK, "Turning off lighting failed (%08x)\n", hr);
 853     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
 854     ok(hr == D3D_OK, "Turning on fog calculations failed (%08x)\n", hr);
 855     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
 856     ok(hr == D3D_OK, "Setting fog color failed (%08x)\n", hr);
 857     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
 858     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
 859
 860     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
 861     ok(hr == D3D_OK, "Turning off table fog failed (%08x)\n", hr);
 862     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
 863     ok(hr == D3D_OK, "Turning off vertex fog failed (%08x)\n", hr);
 864
 865     /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
 866     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i);
 867     ok(hr == D3D_OK, "Setting fog start failed (%08x)\n", hr);
 868     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i);
 869     ok(hr == D3D_OK, "Setting fog end failed (%08x)\n", hr);
 870
 871     for (i = 0; i < 22; i++)
 872     {
 873         hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]);
 874         ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 875         hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[test_data[i].pshader]);
 876         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
 877         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog);
 878         ok( hr == D3D_OK, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr);
 879         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog);
 880         ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr);
 881
 882         for(j=0; j < 11; j++)
 883         {
 884             /* Don't use the whole zrange to prevent rounding errors */
 885             quad[0].z = 0.001f + (float)j / 10.001f;
 886             quad[1].z = 0.001f + (float)j / 10.001f;
 887             quad[2].z = 0.001f + (float)j / 10.001f;
 888             quad[3].z = 0.001f + (float)j / 10.001f;
 889
 890             hr = IDirect3DDevice9_BeginScene(device);
 891             ok( hr == D3D_OK, "BeginScene returned failed (%08x)\n", hr);
 892
 893             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
 894             ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
 895
 896             hr = IDirect3DDevice9_EndScene(device);
 897             ok(hr == D3D_OK, "EndScene failed (%08x)\n", hr);
 898
 899             IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 900
 901             /* As the red and green component are the result of blending use 5% tolerance on the expected value */
 902             color = getPixelColor(device, 128, 240);
 903             ok((unsigned char)(color) == ((unsigned char)test_data[i].color[j])
 904                     && abs( ((unsigned char)(color>>8)) - (unsigned char)(test_data[i].color[j]>>8) ) < 13
 905                     && abs( ((unsigned char)(color>>16)) - (unsigned char)(test_data[i].color[j]>>16) ) < 13,
 906                     "fog ps%i vs%i fvm%i ftm%i: got color %08x, expected %08x +-5%%\n", test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, color, test_data[i].color[j]);
 907         }
 908     }
 909
 910     /* reset states */
 911     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
 912     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 913     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
 914     ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
 915     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
 916     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
 917     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
 918     ok(hr == D3D_OK, "Turning off fog calculations failed (%08x)\n", hr);
 919
 920     IDirect3DVertexShader9_Release(vertex_shader[1]);
 921     IDirect3DVertexShader9_Release(vertex_shader[2]);
 922     IDirect3DPixelShader9_Release(pixel_shader[1]);
 923     IDirect3DVertexDeclaration9_Release(vertex_declaration);
 924 }
 925
 926 /* test the behavior of the texbem instruction
 927  * with normal 2D and projective 2D textures
 928  */
 929 static void texbem_test(IDirect3DDevice9 *device)
 930 {
 931     HRESULT hr;
 932     DWORD color;
 933     unsigned int i, x, y;
 934
 935     static const DWORD pixel_shader_code[] = {
 936         0xffff0101,                         /* ps_1_1*/
 937         0x00000042, 0xb00f0000,             /* tex t0*/
 938         0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
 939         0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
 940         0x0000ffff
 941     };
 942
 943     static const float quad[][7] = {
 944         {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
 945         {-128.0f/640.0f,  128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
 946         { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
 947         { 128.0f/640.0f,  128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
 948     };
 949     static const float quad_proj[][9] = {
 950         {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f,   0.0f,   0.0f, 0.0f, 128.0f},
 951         {-128.0f/640.0f,  128.0f/480.0f, 0.1f, 0.0f, 1.0f,   0.0f, 128.0f, 0.0f, 128.0f},
 952         { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 128.0f,   0.0f, 0.0f, 128.0f},
 953         { 128.0f/640.0f,  128.0f/480.0f, 0.1f, 1.0f, 1.0f, 128.0f, 128.0f, 0.0f, 128.0f},
 954     };
 955
 956     static const D3DVERTEXELEMENT9 decl_elements[][4] = { {
 957         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 958         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
 959         {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
 960         D3DDECL_END()
 961     },{
 962         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 963         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
 964         {0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
 965         D3DDECL_END()
 966     } };
 967
 968     /* use assymetric matrix to test loading */
 969     float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
 970
 971     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
 972     IDirect3DPixelShader9       *pixel_shader       = NULL;
 973     IDirect3DTexture9           *texture[2]         = {NULL, NULL};
 974     D3DLOCKED_RECT locked_rect;
 975
 976     /* Generate the textures */
 977     for(i=0; i<2; i++)
 978     {
 979         hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, 0, i?D3DFMT_A8R8G8B8:D3DFMT_V8U8,
 980                 D3DPOOL_MANAGED, &texture[i], NULL);
 981         ok(SUCCEEDED(hr), "CreateTexture failed (0x%08x)\n", hr);
 982
 983         hr = IDirect3DTexture9_LockRect(texture[i], 0, &locked_rect, NULL, D3DLOCK_DISCARD);
 984         ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
 985         for (y = 0; y < 128; ++y)
 986         {
 987             if(i)
 988             { /* Set up black texture with 2x2 texel white spot in the middle */
 989                 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
 990                 for (x = 0; x < 128; ++x)
 991                 {
 992                     if(y>62 && y<66 && x>62 && x<66)
 993                         *ptr++ = 0xffffffff;
 994                     else
 995                         *ptr++ = 0xff000000;
 996                 }
 997             }
 998             else
 999             { /* Set up a displacement map which points away from the center parallel to the closest axis.
1000               * (if multiplied with bumpenvmat)
1001               */
1002                 WORD *ptr = (WORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1003                 for (x = 0; x < 128; ++x)
1004                 {
1005                     if(abs(x-64)>abs(y-64))
1006                     {
1007                         if(x < 64)
1008                             *ptr++ = 0xc000;
1009                         else
1010                             *ptr++ = 0x4000;
1011                     }
1012                     else
1013                     {
1014                         if(y < 64)
1015                             *ptr++ = 0x0040;
1016                         else
1017                             *ptr++ = 0x00c0;
1018                     }
1019                 }
1020             }
1021         }
1022         hr = IDirect3DTexture9_UnlockRect(texture[i], 0);
1023         ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1024
1025         hr = IDirect3DDevice9_SetTexture(device, i, (IDirect3DBaseTexture9 *)texture[i]);
1026         ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1027
1028         /* Disable texture filtering */
1029         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1030         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1031         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1032         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1033
1034         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1035         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr);
1036         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1037         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr);
1038     }
1039
1040     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1041     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1042     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1043     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1044     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
1045
1046     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1047     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1048
1049     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1050     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1051
1052     for(i=0; i<2; i++)
1053     {
1054         if(i)
1055         {
1056             hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
1057             ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1058         }
1059
1060         hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements[i], &vertex_declaration);
1061         ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1062         hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1063         ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1064
1065         hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader);
1066         ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1067         hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1068         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1069
1070         hr = IDirect3DDevice9_BeginScene(device);
1071         ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1072
1073         if(!i)
1074             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1075         else
1076             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad_proj[0], sizeof(quad_proj[0]));
1077         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1078
1079         hr = IDirect3DDevice9_EndScene(device);
1080         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1081
1082         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1083         ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1084
1085         color = getPixelColor(device, 320-32, 240);
1086         ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1087         color = getPixelColor(device, 320+32, 240);
1088         ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1089         color = getPixelColor(device, 320, 240-32);
1090         ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1091         color = getPixelColor(device, 320, 240+32);
1092         ok(color == 0x00ffffff, "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1093
1094         hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1095         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1096         IDirect3DPixelShader9_Release(pixel_shader);
1097
1098         hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1099         ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1100         IDirect3DVertexDeclaration9_Release(vertex_declaration);
1101     }
1102
1103     /* clean up */
1104     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1105     ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1106
1107     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
1108     ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1109
1110     for(i=0; i<2; i++)
1111     {
1112         hr = IDirect3DDevice9_SetTexture(device, i, NULL);
1113         ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1114         IDirect3DCubeTexture9_Release(texture[i]);
1115     }
1116 }
1117
1118 START_TEST(visual)
1119 {
1120     IDirect3DDevice9 *device_ptr;
1121     D3DCAPS9 caps;
1122     HRESULT hr;
1123     DWORD color;
1124
1125     d3d9_handle = LoadLibraryA("d3d9.dll");
1126     if (!d3d9_handle)
1127     {
1128         skip("Could not load d3d9.dll\n");
1129         return;
1130     }
1131
1132     device_ptr = init_d3d9();
1133     if (!device_ptr) return;
1134
1135     IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps);
1136
1137     /* Check for the reliability of the returned data */
1138     hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1139     if(FAILED(hr))
1140     {
1141         trace("Clear failed, can't assure correctness of the test results, skipping\n");
1142         goto cleanup;
1143     }
1144     IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
1145
1146     color = getPixelColor(device_ptr, 1, 1);
1147     if(color !=0x00ff0000)
1148     {
1149         trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
1150         goto cleanup;
1151     }
1152
1153     hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
1154     if(FAILED(hr))
1155     {
1156         trace("Clear failed, can't assure correctness of the test results, skipping\n");
1157         goto cleanup;
1158     }
1159     IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
1160
1161     color = getPixelColor(device_ptr, 639, 479);
1162     if(color != 0x0000ddee)
1163     {
1164         trace("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
1165         goto cleanup;
1166     }
1167
1168     /* Now execute the real tests */
1169     lighting_test(device_ptr);
1170     clear_test(device_ptr);
1171     fog_test(device_ptr);
1172     test_cube_wrap(device_ptr);
1173
1174     if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
1175     {
1176         test_mova(device_ptr);
1177     }
1178     else skip("No vs_2_0 support\n");
1179
1180     if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1) && caps.PixelShaderVersion >= D3DVS_VERSION(1, 1))
1181     {
1182         fog_with_shader_test(device_ptr);
1183     }
1184     else skip("No vs_1_1 and ps_1_1 support\n");
1185
1186     if (caps.PixelShaderVersion >= D3DVS_VERSION(1, 1))
1187     {
1188         texbem_test(device_ptr);
1189     }
1190     else skip("No ps_1_1 support\n");
1191
1192 cleanup:
1193     if(device_ptr) IDirect3DDevice9_Release(device_ptr);
1194 }