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

   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, 0);
 296     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
 297
 298     hr = IDirect3DDevice9_SetFVF(device, fvf);
 299     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
 300
 301     hr = IDirect3DDevice9_BeginScene(device);
 302     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
 303     if(hr == D3D_OK)
 304     {
 305         /* No lights are defined... That means, lit vertices should be entirely black */
 306         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 307         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 308         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 309                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitquad, sizeof(unlitquad[0]));
 310         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
 311
 312         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
 313         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 314         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 315                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, litquad, sizeof(litquad[0]));
 316         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
 317
 318         hr = IDirect3DDevice9_SetFVF(device, nfvf);
 319         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
 320
 321         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 322         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 323         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 324                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, unlitnquad, sizeof(unlitnquad[0]));
 325         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
 326
 327         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, TRUE);
 328         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 329         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 330                                                     2 /*PrimCount */, Indices, D3DFMT_INDEX16, litnquad, sizeof(litnquad[0]));
 331         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
 332
 333         IDirect3DDevice9_EndScene(device);
 334         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
 335     }
 336
 337     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 338
 339     color = getPixelColor(device, 160, 360); /* lower left quad - unlit without normals */
 340     ok(color == 0x00ff0000, "Unlit quad without normals has color %08x\n", color);
 341     color = getPixelColor(device, 160, 120); /* upper left quad - lit without normals */
 342     ok(color == 0x00000000, "Lit quad without normals has color %08x\n", color);
 343     color = getPixelColor(device, 480, 360); /* lower left quad - unlit with normals */
 344     ok(color == 0x000000ff, "Unlit quad with normals has color %08x\n", color);
 345     color = getPixelColor(device, 480, 120); /* upper left quad - lit with normals */
 346     ok(color == 0x00000000, "Lit quad with normals has color %08x\n", color);
 347
 348     hr = IDirect3DDevice9_GetMaterial(device, &old_material);
 349     ok(hr == D3D_OK, "IDirect3DDevice9_GetMaterial returned %08x\n", hr);
 350     memset(&material, 0, sizeof(material));
 351     material.Diffuse.r = 0.0;
 352     material.Diffuse.g = 0.0;
 353     material.Diffuse.b = 0.0;
 354     material.Diffuse.a = 1.0;
 355     material.Ambient.r = 0.0;
 356     material.Ambient.g = 0.0;
 357     material.Ambient.b = 0.0;
 358     material.Ambient.a = 0.0;
 359     material.Specular.r = 0.0;
 360     material.Specular.g = 0.0;
 361     material.Specular.b = 0.0;
 362     material.Specular.a = 0.0;
 363     material.Emissive.r = 0.0;
 364     material.Emissive.g = 0.0;
 365     material.Emissive.b = 0.0;
 366     material.Emissive.a = 0.0;
 367     material.Power = 0.0;
 368     IDirect3DDevice9_SetMaterial(device, &material);
 369     ok(hr == D3D_OK, "IDirect3DDevice9_SetMaterial returned %08x\n", hr);
 370
 371     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
 372     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 373     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);
 374     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 375
 376     hr = IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_COLOROP, &cop);
 377     ok(hr == D3D_OK, "IDirect3DDevice9_GetTextureStageState returned %08x\n", hr);
 378     hr = IDirect3DDevice9_GetTextureStageState(device, 0, D3DTSS_COLORARG1, &carg);
 379     ok(hr == D3D_OK, "IDirect3DDevice9_GetTextureStageState returned %08x\n", hr);
 380     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
 381     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
 382     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE | D3DTA_ALPHAREPLICATE);
 383     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
 384
 385     hr = IDirect3DDevice9_BeginScene(device);
 386     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
 387     if(SUCCEEDED(hr)) {
 388         struct vertex lighting_test[] = {
 389             {-1.0,   -1.0,   0.1,    0x8000ff00},
 390             { 1.0,   -1.0,   0.1,    0x80000000},
 391             {-1.0,    1.0,   0.1,    0x8000ff00},
 392             { 1.0,    1.0,   0.1,    0x80000000}
 393         };
 394         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
 395         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
 396         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, lighting_test, sizeof(lighting_test[0]));
 397         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
 398
 399         hr = IDirect3DDevice9_EndScene(device);
 400         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
 401     }
 402
 403     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 404     color = getPixelColor(device, 320, 240);
 405     ok(color == 0x00ffffff, "Lit vertex alpha test returned color %08x, expected 0x00ffffff\n", color);
 406
 407     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, cop);
 408     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
 409     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_COLOR1);
 410     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 411     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2);
 412     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 413     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 414     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
 415     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, carg);
 416     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState returned %08x\n", hr);
 417     hr = IDirect3DDevice9_SetMaterial(device, &old_material);
 418     ok(hr == D3D_OK, "IDirect3DDevice9_SetMaterial returned %08x\n", hr);
 419 }
 420
 421 static void clear_test(IDirect3DDevice9 *device)
 422 {
 423     /* Tests the correctness of clearing parameters */
 424     HRESULT hr;
 425     D3DRECT rect[2];
 426     D3DRECT rect_negneg;
 427     DWORD color;
 428     D3DVIEWPORT9 old_vp, vp;
 429     RECT scissor;
 430     DWORD oldColorWrite;
 431     BOOL invalid_clear_failed = FALSE;
 432
 433     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 434     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 435
 436     /* Positive x, negative y */
 437     rect[0].x1 = 0;
 438     rect[0].y1 = 480;
 439     rect[0].x2 = 320;
 440     rect[0].y2 = 240;
 441
 442     /* Positive x, positive y */
 443     rect[1].x1 = 0;
 444     rect[1].y1 = 0;
 445     rect[1].x2 = 320;
 446     rect[1].y2 = 240;
 447     /* Clear 2 rectangles with one call. The refrast returns an error in this case, every real driver tested so far
 448      * returns D3D_OK, but ignores the rectangle silently
 449      */
 450     hr = IDirect3DDevice9_Clear(device, 2, rect, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
 451     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 452     if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
 453
 454     /* negative x, negative y */
 455     rect_negneg.x1 = 640;
 456     rect_negneg.y1 = 240;
 457     rect_negneg.x2 = 320;
 458     rect_negneg.y2 = 0;
 459     hr = IDirect3DDevice9_Clear(device, 1, &rect_negneg, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
 460     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 461     if(hr == D3DERR_INVALIDCALL) invalid_clear_failed = TRUE;
 462
 463     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 464
 465     color = getPixelColor(device, 160, 360); /* lower left quad */
 466     ok(color == 0x00ffffff, "Clear rectangle 3(pos, neg) has color %08x\n", color);
 467     color = getPixelColor(device, 160, 120); /* upper left quad */
 468     if(invalid_clear_failed) {
 469         /* If the negative rectangle was refused, the other rectangles in the list shouldn't be cleared either */
 470         ok(color == 0x00ffffff, "Clear rectangle 1(pos, pos) has color %08x\n", color);
 471     } else {
 472         /* If the negative rectangle was dropped silently, the correct ones are cleared */
 473         ok(color == 0x00ff0000, "Clear rectangle 1(pos, pos) has color %08x\n", color);
 474     }
 475     color = getPixelColor(device, 480, 360); /* lower right quad  */
 476     ok(color == 0x00ffffff, "Clear rectangle 4(NULL) has color %08x\n", color);
 477     color = getPixelColor(device, 480, 120); /* upper right quad */
 478     ok(color == 0x00ffffff, "Clear rectangle 4(neg, neg) has color %08x\n", color);
 479
 480     /* Test how the viewport affects clears */
 481     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 482     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 483     hr = IDirect3DDevice9_GetViewport(device, &old_vp);
 484     ok(hr == D3D_OK, "IDirect3DDevice9_GetViewport failed with %08x\n", hr);
 485
 486     vp.X = 160;
 487     vp.Y = 120;
 488     vp.Width = 160;
 489     vp.Height = 120;
 490     vp.MinZ = 0.0;
 491     vp.MaxZ = 1.0;
 492     hr = IDirect3DDevice9_SetViewport(device, &vp);
 493     ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
 494     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
 495     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 496
 497     vp.X = 320;
 498     vp.Y = 240;
 499     vp.Width = 320;
 500     vp.Height = 240;
 501     vp.MinZ = 0.0;
 502     vp.MaxZ = 1.0;
 503     hr = IDirect3DDevice9_SetViewport(device, &vp);
 504     ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
 505     rect[0].x1 = 160;
 506     rect[0].y1 = 120;
 507     rect[0].x2 = 480;
 508     rect[0].y2 = 360;
 509     hr = IDirect3DDevice9_Clear(device, 1, &rect[0], D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
 510     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 511
 512     hr = IDirect3DDevice9_SetViewport(device, &old_vp);
 513     ok(hr == D3D_OK, "IDirect3DDevice9_SetViewport failed with %08x\n", hr);
 514
 515     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 516     color = getPixelColor(device, 158, 118);
 517     ok(color == 0x00ffffff, "(158,118) has color %08x\n", color);
 518     color = getPixelColor(device, 162, 118);
 519     ok(color == 0x00ffffff, "(162,118) has color %08x\n", color);
 520     color = getPixelColor(device, 158, 122);
 521     ok(color == 0x00ffffff, "(158,122) has color %08x\n", color);
 522     color = getPixelColor(device, 162, 122);
 523     ok(color == 0x000000ff, "(162,122) has color %08x\n", color);
 524
 525     color = getPixelColor(device, 318, 238);
 526     ok(color == 0x000000ff, "(318,238) has color %08x\n", color);
 527     color = getPixelColor(device, 322, 238);
 528     ok(color == 0x00ffffff, "(322,328) has color %08x\n", color);
 529     color = getPixelColor(device, 318, 242);
 530     ok(color == 0x00ffffff, "(318,242) has color %08x\n", color);
 531     color = getPixelColor(device, 322, 242);
 532     ok(color == 0x0000ff00, "(322,242) has color %08x\n", color);
 533
 534     color = getPixelColor(device, 478, 358);
 535     ok(color == 0x0000ff00, "(478,358 has color %08x\n", color);
 536     color = getPixelColor(device, 482, 358);
 537     ok(color == 0x00ffffff, "(482,358) has color %08x\n", color);
 538     color = getPixelColor(device, 478, 362);
 539     ok(color == 0x00ffffff, "(478,362) has color %08x\n", color);
 540     color = getPixelColor(device, 482, 362);
 541     ok(color == 0x00ffffff, "(482,362) has color %08x\n", color);
 542
 543     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 544     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 545
 546     scissor.left = 160;
 547     scissor.right = 480;
 548     scissor.top = 120;
 549     scissor.bottom = 360;
 550     hr = IDirect3DDevice9_SetScissorRect(device, &scissor);
 551     ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
 552     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, TRUE);
 553     ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
 554
 555     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
 556     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 557     hr = IDirect3DDevice9_Clear(device, 1, &rect[1], D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
 558     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 559
 560     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SCISSORTESTENABLE, FALSE);
 561     ok(hr == D3D_OK, "IDirect3DDevice_SetScissorRect failed with %08x\n", hr);
 562
 563     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 564     color = getPixelColor(device, 158, 118);
 565     ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
 566     color = getPixelColor(device, 162, 118);
 567     ok(color == 0x00ffffff, "Pixel 162/118 has color %08x\n", color);
 568     color = getPixelColor(device, 158, 122);
 569     ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
 570     color = getPixelColor(device, 162, 122);
 571     ok(color == 0x00ff0000, "Pixel 162/122 has color %08x\n", color);
 572
 573     color = getPixelColor(device, 158, 358);
 574     ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
 575     color = getPixelColor(device, 162, 358);
 576     ok(color == 0x0000ff00, "Pixel 162/358 has color %08x\n", color);
 577     color = getPixelColor(device, 158, 358);
 578     ok(color == 0x00ffffff, "Pixel 158/358 has color %08x\n", color);
 579     color = getPixelColor(device, 162, 362);
 580     ok(color == 0x00ffffff, "Pixel 162/362 has color %08x\n", color);
 581
 582     color = getPixelColor(device, 478, 118);
 583     ok(color == 0x00ffffff, "Pixel 158/118 has color %08x\n", color);
 584     color = getPixelColor(device, 478, 122);
 585     ok(color == 0x0000ff00, "Pixel 162/118 has color %08x\n", color);
 586     color = getPixelColor(device, 482, 122);
 587     ok(color == 0x00ffffff, "Pixel 158/122 has color %08x\n", color);
 588     color = getPixelColor(device, 482, 358);
 589     ok(color == 0x00ffffff, "Pixel 162/122 has color %08x\n", color);
 590
 591     color = getPixelColor(device, 478, 358);
 592     ok(color == 0x0000ff00, "Pixel 478/358 has color %08x\n", color);
 593     color = getPixelColor(device, 478, 362);
 594     ok(color == 0x00ffffff, "Pixel 478/118 has color %08x\n", color);
 595     color = getPixelColor(device, 482, 358);
 596     ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
 597     color = getPixelColor(device, 482, 362);
 598     ok(color == 0x00ffffff, "Pixel 482/122 has color %08x\n", color);
 599
 600     color = getPixelColor(device, 318, 238);
 601     ok(color == 0x00ff0000, "Pixel 318/238 has color %08x\n", color);
 602     color = getPixelColor(device, 318, 242);
 603     ok(color == 0x0000ff00, "Pixel 318/242 has color %08x\n", color);
 604     color = getPixelColor(device, 322, 238);
 605     ok(color == 0x0000ff00, "Pixel 322/238 has color %08x\n", color);
 606     color = getPixelColor(device, 322, 242);
 607     ok(color == 0x0000ff00, "Pixel 322/242 has color %08x\n", color);
 608
 609     hr = IDirect3DDevice9_GetRenderState(device, D3DRS_COLORWRITEENABLE, &oldColorWrite);
 610     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed with %08x\n", hr);
 611     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
 612     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
 613
 614     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
 615     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
 616
 617     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, oldColorWrite);
 618     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with %08x\n", hr);
 619
 620     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 621
 622     /* Colorwriteenable does not affect the clear */
 623     color = getPixelColor(device, 320, 240);
 624     ok(color == 0x00ffffff, "Color write protected clear returned color %08x\n", color);
 625 }
 626
 627 typedef struct {
 628     float in[4];
 629     DWORD out;
 630 } test_data_t;
 631
 632 /*
 633  *  c7      mova    ARGB            mov     ARGB
 634  * -2.4     -2      0x00ffff00      -3      0x00ff0000
 635  * -1.6     -2      0x00ffff00      -2      0x00ffff00
 636  * -0.4      0      0x0000ffff      -1      0x0000ff00
 637  *  0.4      0      0x0000ffff       0      0x0000ffff
 638  *  1.6      2      0x00ff00ff       1      0x000000ff
 639  *  2.4      2      0x00ff00ff       2      0x00ff00ff
 640  */
 641 static void test_mova(IDirect3DDevice9 *device)
 642 {
 643     static const DWORD mova_test[] = {
 644         0xfffe0200,                                                             /* vs_2_0                       */
 645         0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
 646         0x05000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0   */
 647         0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0   */
 648         0x05000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0   */
 649         0x05000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0   */
 650         0x05000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0   */
 651         0x05000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0   */
 652         0x05000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0   */
 653         0x0200002e, 0xb0010000, 0xa0000007,                                     /* mova a0.x, c7.x              */
 654         0x03000001, 0xd00f0000, 0xa0e42003, 0xb0000000,                         /* mov oD0, c[a0.x + 3]         */
 655         0x02000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
 656         0x0000ffff                                                              /* END                          */
 657     };
 658     static const DWORD mov_test[] = {
 659         0xfffe0101,                                                             /* vs_1_1                       */
 660         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
 661         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0   */
 662         0x00000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x00000000, 0x3f800000, /* def c1, 1.0, 1.0, 0.0, 1.0   */
 663         0x00000051, 0xa00f0002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, /* def c2, 0.0, 1.0, 0.0, 1.0   */
 664         0x00000051, 0xa00f0003, 0x00000000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 0.0, 1.0, 1.0, 1.0   */
 665         0x00000051, 0xa00f0004, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c4, 0.0, 0.0, 1.0, 1.0   */
 666         0x00000051, 0xa00f0005, 0x3f800000, 0x00000000, 0x3f800000, 0x3f800000, /* def c5, 1.0, 0.0, 1.0, 1.0   */
 667         0x00000051, 0xa00f0006, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c6, 1.0, 1.0, 1.0, 1.0   */
 668         0x00000001, 0xb0010000, 0xa0000007,                                     /* mov a0.x, c7.x               */
 669         0x00000001, 0xd00f0000, 0xa0e42003,                                     /* mov oD0, c[a0.x + 3]         */
 670         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
 671         0x0000ffff                                                              /* END                          */
 672     };
 673
 674     static const test_data_t test_data[2][6] = {
 675         {
 676             {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff0000},
 677             {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
 678             {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ff00},
 679             {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
 680             {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x000000ff},
 681             {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
 682         },
 683         {
 684             {{-2.4f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
 685             {{-1.6f, 0.0f, 0.0f, 0.0f}, 0x00ffff00},
 686             {{-0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
 687             {{ 0.4f, 0.0f, 0.0f, 0.0f}, 0x0000ffff},
 688             {{ 1.6f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff},
 689             {{ 2.4f, 0.0f, 0.0f, 0.0f}, 0x00ff00ff}
 690         }
 691     };
 692
 693     static const float quad[][3] = {
 694         {-1.0f, -1.0f, 0.0f},
 695         {-1.0f,  1.0f, 0.0f},
 696         { 1.0f, -1.0f, 0.0f},
 697         { 1.0f,  1.0f, 0.0f},
 698     };
 699
 700     static const D3DVERTEXELEMENT9 decl_elements[] = {
 701         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
 702         D3DDECL_END()
 703     };
 704
 705     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
 706     IDirect3DVertexShader9 *mova_shader = NULL;
 707     IDirect3DVertexShader9 *mov_shader = NULL;
 708     HRESULT hr;
 709     UINT i, j;
 710
 711     hr = IDirect3DDevice9_CreateVertexShader(device, mova_test, &mova_shader);
 712     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
 713     hr = IDirect3DDevice9_CreateVertexShader(device, mov_test, &mov_shader);
 714     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
 715     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
 716     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
 717     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
 718     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
 719
 720     hr = IDirect3DDevice9_SetVertexShader(device, mov_shader);
 721     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 722     for(j = 0; j < 2; ++j)
 723     {
 724         for (i = 0; i < (sizeof(test_data[0]) / sizeof(test_data_t)); ++i)
 725         {
 726             DWORD color;
 727
 728             hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 7, test_data[j][i].in, 1);
 729             ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
 730
 731             hr = IDirect3DDevice9_BeginScene(device);
 732             ok(SUCCEEDED(hr), "BeginScene failed (%08x)\n", hr);
 733
 734             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], 3 * sizeof(float));
 735             ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
 736
 737             hr = IDirect3DDevice9_EndScene(device);
 738             ok(SUCCEEDED(hr), "EndScene failed (%08x)\n", hr);
 739
 740             hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 741             ok(SUCCEEDED(hr), "Present failed (%08x)\n", hr);
 742
 743             color = getPixelColor(device, 320, 240);
 744             ok(color == test_data[j][i].out, "Expected color %08x, got %08x (for input %f, instruction %s)\n",
 745                test_data[j][i].out, color, test_data[j][i].in[0], j == 0 ? "mov" : "mova");
 746
 747             hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
 748             ok(SUCCEEDED(hr), "Clear failed (%08x)\n", hr);
 749         }
 750         hr = IDirect3DDevice9_SetVertexShader(device, mova_shader);
 751         ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 752     }
 753
 754     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
 755     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
 756
 757     IDirect3DVertexDeclaration9_Release(vertex_declaration);
 758     IDirect3DVertexShader9_Release(mova_shader);
 759     IDirect3DVertexShader9_Release(mov_shader);
 760 }
 761
 762 struct sVertex {
 763     float x, y, z;
 764     DWORD diffuse;
 765     DWORD specular;
 766 };
 767
 768 struct sVertexT {
 769     float x, y, z, rhw;
 770     DWORD diffuse;
 771     DWORD specular;
 772 };
 773
 774 static void fog_test(IDirect3DDevice9 *device)
 775 {
 776     HRESULT hr;
 777     DWORD color;
 778     BYTE r, g, b;
 779     float start = 0.0f, end = 1.0f;
 780     D3DCAPS9 caps;
 781     int i;
 782
 783     /* Gets full z based fog with linear fog, no fog with specular color */
 784     struct sVertex unstransformed_1[] = {
 785         {-1,    -1,   0.1f,         0xFFFF0000,     0xFF000000  },
 786         {-1,     0,   0.1f,         0xFFFF0000,     0xFF000000  },
 787         { 0,     0,   0.1f,         0xFFFF0000,     0xFF000000  },
 788         { 0,    -1,   0.1f,         0xFFFF0000,     0xFF000000  },
 789     };
 790     /* Ok, I am too lazy to deal with transform matrices */
 791     struct sVertex unstransformed_2[] = {
 792         {-1,     0,   1.0f,         0xFFFF0000,     0xFF000000  },
 793         {-1,     1,   1.0f,         0xFFFF0000,     0xFF000000  },
 794         { 0,     1,   1.0f,         0xFFFF0000,     0xFF000000  },
 795         { 0,     0,   1.0f,         0xFFFF0000,     0xFF000000  },
 796     };
 797     /* Untransformed ones. Give them a different diffuse color to make the test look
 798      * nicer. It also makes making sure that they are drawn correctly easier.
 799      */
 800     struct sVertexT transformed_1[] = {
 801         {320,    0,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 802         {640,    0,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 803         {640,  240,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 804         {320,  240,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 805     };
 806     struct sVertexT transformed_2[] = {
 807         {320,  240,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 808         {640,  240,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 809         {640,  480,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 810         {320,  480,   1.0f, 1.0f,   0xFFFFFF00,     0xFF000000  },
 811     };
 812     struct vertex rev_fog_quads[] = {
 813        {-1.0,   -1.0,   0.1,    0x000000ff},
 814        {-1.0,    0.0,   0.1,    0x000000ff},
 815        { 0.0,    0.0,   0.1,    0x000000ff},
 816        { 0.0,   -1.0,   0.1,    0x000000ff},
 817
 818        { 0.0,   -1.0,   0.9,    0x000000ff},
 819        { 0.0,    0.0,   0.9,    0x000000ff},
 820        { 1.0,    0.0,   0.9,    0x000000ff},
 821        { 1.0,   -1.0,   0.9,    0x000000ff},
 822
 823        { 0.0,    0.0,   0.4,    0x000000ff},
 824        { 0.0,    1.0,   0.4,    0x000000ff},
 825        { 1.0,    1.0,   0.4,    0x000000ff},
 826        { 1.0,    0.0,   0.4,    0x000000ff},
 827
 828        {-1.0,    0.0,   0.7,    0x000000ff},
 829        {-1.0,    1.0,   0.7,    0x000000ff},
 830        { 0.0,    1.0,   0.7,    0x000000ff},
 831        { 0.0,    0.0,   0.7,    0x000000ff},
 832     };
 833     WORD Indices[] = {0, 1, 2, 2, 3, 0};
 834
 835     memset(&caps, 0, sizeof(caps));
 836     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
 837     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %08x\n", hr);
 838     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
 839     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
 840
 841     /* Setup initial states: No lighting, fog on, fog color */
 842     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
 843     ok(hr == D3D_OK, "Turning off lighting returned %08x\n", hr);
 844     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
 845     ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
 846     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
 847     ok(hr == D3D_OK, "Turning on fog calculations returned %08x\n", hr);
 848
 849     /* First test: Both table fog and vertex fog off */
 850     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
 851     ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
 852     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
 853     ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
 854
 855     /* Start = 0, end = 1. Should be default, but set them */
 856     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
 857     ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
 858     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
 859     ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
 860
 861     if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
 862     {
 863         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 864         ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
 865         /* Untransformed, vertex fog = NONE, table fog = NONE: Read the fog weighting from the specular color */
 866         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 867                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
 868                                                      sizeof(unstransformed_1[0]));
 869         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 870
 871         /* That makes it use the Z value */
 872         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
 873         ok(hr == D3D_OK, "Turning off table fog returned %08x\n", hr);
 874         /* Untransformed, vertex fog != none (or table fog != none):
 875          * Use the Z value as input into the equation
 876          */
 877         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 878                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
 879                                                      sizeof(unstransformed_1[0]));
 880         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 881
 882         /* transformed verts */
 883         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 884         ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
 885         /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
 886         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 887                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
 888                                                      sizeof(transformed_1[0]));
 889         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 890
 891         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
 892         ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
 893         /* Transformed, table fog != none, vertex anything: Use Z value as input to the fog
 894          * equation
 895          */
 896         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 897                                                      2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_2,
 898                                                      sizeof(transformed_2[0]));
 899
 900         hr = IDirect3DDevice9_EndScene(device);
 901         ok(hr == D3D_OK, "EndScene returned %08x\n", hr);
 902     }
 903     else
 904     {
 905         ok(FALSE, "BeginScene failed\n");
 906     }
 907
 908     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 909     color = getPixelColor(device, 160, 360);
 910     ok(color == 0x00FF0000, "Untransformed vertex with no table or vertex fog has color %08x\n", color);
 911     color = getPixelColor(device, 160, 120);
 912     ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with linear vertex fog has color %08x\n", color);
 913     color = getPixelColor(device, 480, 120);
 914     ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
 915     if(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)
 916     {
 917         color = getPixelColor(device, 480, 360);
 918         ok(color == 0x0000FF00 || color == 0x0000FE00, "Transformed vertex with linear table fog has color %08x\n", color);
 919     }
 920     else
 921     {
 922         /* Without fog table support the vertex fog is still applied, even though table fog is turned on.
 923          * The settings above result in no fogging with vertex fog
 924          */
 925         color = getPixelColor(device, 480, 120);
 926         ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
 927         trace("Info: Table fog not supported by this device\n");
 928     }
 929
 930     /* Now test the special case fogstart == fogend */
 931     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
 932     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
 933
 934     if(IDirect3DDevice9_BeginScene(device) == D3D_OK)
 935     {
 936         start = 512;
 937         end = 512;
 938         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
 939         ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
 940         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
 941         ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
 942
 943         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 944         ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
 945         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
 946         ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %08x\n", hr);
 947         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
 948         ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
 949
 950         /* Untransformed vertex, z coord = 0.1, fogstart = 512, fogend = 512. Would result in
 951          * a completely fog-free primitive because start > zcoord, but because start == end, the primitive
 952          * is fully covered by fog. The same happens to the 2nd untransformed quad with z = 1.0.
 953          * The third transformed quad remains unfogged because the fogcoords are read from the specular
 954          * color and has fixed fogstart and fogend.
 955          */
 956         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 957                 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_1,
 958                 sizeof(unstransformed_1[0]));
 959         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 960         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 961                 2 /*PrimCount */, Indices, D3DFMT_INDEX16, unstransformed_2,
 962                 sizeof(unstransformed_1[0]));
 963         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 964
 965         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR);
 966         ok( hr == D3D_OK, "SetFVF returned %08x\n", hr);
 967         /* Transformed, vertex fog != NONE, pixel fog == NONE: Use specular color alpha component */
 968         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
 969                 2 /*PrimCount */, Indices, D3DFMT_INDEX16, transformed_1,
 970                 sizeof(transformed_1[0]));
 971         ok(hr == D3D_OK, "DrawIndexedPrimitiveUP returned %08x\n", hr);
 972
 973         hr = IDirect3DDevice9_EndScene(device);
 974         ok(hr == D3D_OK, "EndScene returned %08x\n", hr);
 975     }
 976     else
 977     {
 978         ok(FALSE, "BeginScene failed\n");
 979     }
 980     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
 981     color = getPixelColor(device, 160, 360);
 982     ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 0.1 has color %08x\n", color);
 983     color = getPixelColor(device, 160, 120);
 984     ok(color == 0x0000FF00 || color == 0x0000FE00, "Untransformed vertex with vertex fog and z = 1.0 has color %08x\n", color);
 985     color = getPixelColor(device, 480, 120);
 986     ok(color == 0x00FFFF00, "Transformed vertex with linear vertex fog has color %08x\n", color);
 987
 988     /* Test "reversed" fog without shaders. With shaders this fails on a few Windows D3D implementations,
 989      * but without shaders it seems to work everywhere
 990      */
 991     end = 0.2;
 992     start = 0.8;
 993     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
 994     ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
 995     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
 996     ok(hr == D3D_OK, "Setting fog end returned %08x\n", hr);
 997     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
 998     ok( hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
 999
1000     /* Test reversed fog without shaders. ATI cards have problems with reversed fog and shaders, so
1001      * it doesn't seem very important for games. ATI cards also have problems with reversed table fog,
1002      * so skip this for now
1003      */
1004     for(i = 0; i < 1 /*2 - Table fog test disabled, fails on ATI */; i++) {
1005         const char *mode = (i ? "table" : "vertex");
1006         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1007         ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
1008         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, i == 0 ? D3DFOG_LINEAR : D3DFOG_NONE);
1009         ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1010         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, i == 0 ? D3DFOG_NONE : D3DFOG_LINEAR);
1011         ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1012         hr = IDirect3DDevice9_BeginScene(device);
1013         ok( hr == D3D_OK, "IDirect3DDDevice9_BeginScene returned %08x\n", hr);
1014         if(SUCCEEDED(hr)) {
1015             WORD Indices2[] = { 0,  1,  2,  2,  3, 0,
1016                                 4,  5,  6,  6,  7, 4,
1017                                 8,  9, 10, 10, 11, 8,
1018                             12, 13, 14, 14, 15, 12};
1019
1020             hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */,
1021                     16 /* NumVerts */, 8 /*PrimCount */, Indices2, D3DFMT_INDEX16, rev_fog_quads,
1022                     sizeof(rev_fog_quads[0]));
1023
1024             hr = IDirect3DDevice9_EndScene(device);
1025             ok( hr == D3D_OK, "IDirect3DDDevice9_EndScene returned %08x\n", hr);
1026         }
1027         IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1028         color = getPixelColor(device, 160, 360);
1029         ok(color == 0x0000FF00 || color == 0x0000FE00, "Reversed %s fog: z=0.1 has color 0x%08x, expected 0x0000ff00\n", mode, color);
1030
1031         color = getPixelColor(device, 160, 120);
1032         r = (color & 0x00ff0000) >> 16;
1033         g = (color & 0x0000ff00) >>  8;
1034         b = (color & 0x000000ff);
1035         ok(r == 0x00 && g >= 0x29 && g <= 0x2d && b >= 0xd2 && b <= 0xd6,
1036            "Reversed %s fog: z=0.7 has color 0x%08x, expected\n", mode, color);
1037
1038         color = getPixelColor(device, 480, 120);
1039         r = (color & 0x00ff0000) >> 16;
1040         g = (color & 0x0000ff00) >>  8;
1041         b = (color & 0x000000ff);
1042         ok(r == 0x00 && g >= 0xa8 && g <= 0xac && b >= 0x53 && b <= 0x57,
1043            "Reversed %s fog: z=0.4 has color 0x%08x, expected\n", mode, color);
1044
1045         color = getPixelColor(device, 480, 360);
1046         ok(color == 0x000000ff, "Reversed %s fog: z=0.9 has color 0x%08x, expected 0x000000ff\n", mode, color);
1047
1048         if(!(caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE)) {
1049             skip("D3DPRASTERCAPS_FOGTABLE not supported, skipping reversed table fog test\n");
1050             break;
1051         }
1052     }
1053     /* Turn off the fog master switch to avoid confusing other tests */
1054     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1055     ok(hr == D3D_OK, "Turning off fog calculations returned %08x\n", hr);
1056     start = 0.0;
1057     end = 1.0;
1058     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, *((DWORD *) &start));
1059     ok(hr == D3D_OK, "Setting fog start returned %08x\n", hr);
1060     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, *((DWORD *) &end));
1061     ok(hr == D3D_OK, "Setting fog end returned %08x\n", hr);
1062     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
1063     ok( hr == D3D_OK, "IDirect3DDevice9_SetRenderState %08x\n", hr);
1064     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_LINEAR);
1065     ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR returned %08x\n", hr);
1066 }
1067
1068 /* This test verifies the behaviour of cube maps wrt. texture wrapping.
1069  * D3D cube map wrapping always behaves like GL_CLAMP_TO_EDGE,
1070  * regardless of the actual addressing mode set. */
1071 static void test_cube_wrap(IDirect3DDevice9 *device)
1072 {
1073     static const float quad[][6] = {
1074         {-1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1075         {-1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1076         { 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1077         { 1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f},
1078     };
1079
1080     static const D3DVERTEXELEMENT9 decl_elements[] = {
1081         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1082         {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1083         D3DDECL_END()
1084     };
1085
1086     static const struct {
1087         D3DTEXTUREADDRESS mode;
1088         const char *name;
1089     } address_modes[] = {
1090         {D3DTADDRESS_WRAP, "D3DTADDRESS_WRAP"},
1091         {D3DTADDRESS_MIRROR, "D3DTADDRESS_MIRROR"},
1092         {D3DTADDRESS_CLAMP, "D3DTADDRESS_CLAMP"},
1093         {D3DTADDRESS_BORDER, "D3DTADDRESS_BORDER"},
1094         {D3DTADDRESS_MIRRORONCE, "D3DTADDRESS_MIRRORONCE"},
1095     };
1096
1097     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1098     IDirect3DCubeTexture9 *texture = NULL;
1099     IDirect3DSurface9 *surface = NULL;
1100     D3DLOCKED_RECT locked_rect;
1101     HRESULT hr;
1102     UINT x;
1103     INT y, face;
1104
1105     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1106     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1107     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1108     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1109
1110     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 128, 128,
1111             D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surface, NULL);
1112     ok(SUCCEEDED(hr), "CreateOffscreenPlainSurface failed (0x%08x)\n", hr);
1113
1114     hr = IDirect3DSurface9_LockRect(surface, &locked_rect, NULL, 0);
1115     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1116
1117     for (y = 0; y < 128; ++y)
1118     {
1119         DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1120         for (x = 0; x < 64; ++x)
1121         {
1122             *ptr++ = 0xffff0000;
1123         }
1124         for (x = 64; x < 128; ++x)
1125         {
1126             *ptr++ = 0xff0000ff;
1127         }
1128     }
1129
1130     hr = IDirect3DSurface9_UnlockRect(surface);
1131     ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1132
1133     hr = IDirect3DDevice9_CreateCubeTexture(device, 128, 1, 0, D3DFMT_A8R8G8B8,
1134             D3DPOOL_DEFAULT, &texture, NULL);
1135     ok(SUCCEEDED(hr), "CreateCubeTexture failed (0x%08x)\n", hr);
1136
1137     /* Create cube faces */
1138     for (face = 0; face < 6; ++face)
1139     {
1140         IDirect3DSurface9 *face_surface = NULL;
1141
1142         hr= IDirect3DCubeTexture9_GetCubeMapSurface(texture, face, 0, &face_surface);
1143         ok(SUCCEEDED(hr), "GetCubeMapSurface failed (0x%08x)\n", hr);
1144
1145         hr = IDirect3DDevice9_UpdateSurface(device, surface, NULL, face_surface, NULL);
1146         ok(SUCCEEDED(hr), "UpdateSurface failed (0x%08x)\n", hr);
1147
1148         IDirect3DSurface9_Release(face_surface);
1149     }
1150
1151     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
1152     ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1153
1154     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
1155     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1156     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
1157     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1158     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_BORDERCOLOR, 0xff00ff00);
1159     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_BORDERCOLOR failed (0x%08x)\n", hr);
1160
1161     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1162     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1163
1164     for (x = 0; x < (sizeof(address_modes) / sizeof(*address_modes)); ++x)
1165     {
1166         DWORD color;
1167
1168         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, address_modes[x].mode);
1169         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1170         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, address_modes[x].mode);
1171         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV (%s) failed (0x%08x)\n", address_modes[x].name, hr);
1172
1173         hr = IDirect3DDevice9_BeginScene(device);
1174         ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1175
1176         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1177         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1178
1179         hr = IDirect3DDevice9_EndScene(device);
1180         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1181
1182         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1183         ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1184
1185         /* Due to the nature of this test, we sample essentially at the edge
1186          * between two faces. Because of this it's undefined from which face
1187          * the driver will sample. Fortunately that's not important for this
1188          * test, since all we care about is that it doesn't sample from the
1189          * other side of the surface or from the border. */
1190         color = getPixelColor(device, 320, 240);
1191         ok(color == 0x00ff0000 || color == 0x000000ff,
1192                 "Got color 0x%08x for addressing mode %s, expected 0x00ff0000 or 0x000000ff.\n",
1193                 color, address_modes[x].name);
1194
1195         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1196         ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1197     }
1198
1199     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1200     ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1201
1202     IDirect3DVertexDeclaration9_Release(vertex_declaration);
1203     IDirect3DCubeTexture9_Release(texture);
1204     IDirect3DSurface9_Release(surface);
1205 }
1206
1207 static void offscreen_test(IDirect3DDevice9 *device)
1208 {
1209     HRESULT hr;
1210     IDirect3DTexture9 *offscreenTexture = NULL;
1211     IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
1212     DWORD color;
1213
1214     static const float quad[][5] = {
1215         {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
1216         {-0.5f,  0.5f, 0.1f, 0.0f, 1.0f},
1217         { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
1218         { 0.5f,  0.5f, 0.1f, 1.0f, 1.0f},
1219     };
1220
1221     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
1222     ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
1223
1224     hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1225     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
1226     if(!offscreenTexture) {
1227         trace("Failed to create an X8R8G8B8 offscreen texture, trying R5G6B5\n");
1228         hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
1229         ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
1230         if(!offscreenTexture) {
1231             skip("Cannot create an offscreen render target\n");
1232             goto out;
1233         }
1234     }
1235
1236     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
1237     ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
1238     if(!backbuffer) {
1239         goto out;
1240     }
1241
1242     hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
1243     ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
1244     if(!offscreen) {
1245         goto out;
1246     }
1247
1248     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
1249     ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
1250
1251     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
1252     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
1253     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
1254     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
1255     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1256     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1257     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1258     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1259     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1260     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1261
1262     if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
1263         hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
1264         ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
1265         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1266         ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
1267
1268         /* Draw without textures - Should result in a white quad */
1269         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1270         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
1271
1272         hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1273         ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
1274         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
1275         ok(hr == D3D_OK, "SetTexture failed, %08x\n", hr);
1276
1277         /* This time with the texture */
1278         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
1279         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
1280
1281         IDirect3DDevice9_EndScene(device);
1282     }
1283
1284     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1285
1286     /* Center quad - should be white */
1287     color = getPixelColor(device, 320, 240);
1288     ok(color == 0x00ffffff, "Offscreen failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1289     /* Some quad in the cleared part of the texture */
1290     color = getPixelColor(device, 170, 240);
1291     ok(color == 0x00ff00ff, "Offscreen failed: Got color 0x%08x, expected 0x00ff00ff.\n", color);
1292     /* Part of the originally cleared back buffer */
1293     color = getPixelColor(device, 10, 10);
1294     ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1295     if(0) {
1296         /* Lower left corner of the screen, where back buffer offscreen rendering draws the offscreen texture.
1297          * It should be red, but the offscreen texture may leave some junk there. Not tested yet. Depending on
1298          * the offscreen rendering mode this test would succeed or fail
1299          */
1300         color = getPixelColor(device, 10, 470);
1301         ok(color == 0x00ff0000, "Offscreen failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
1302     }
1303
1304 out:
1305     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1306
1307     /* restore things */
1308     if(backbuffer) {
1309         IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
1310         IDirect3DSurface9_Release(backbuffer);
1311     }
1312     if(offscreenTexture) {
1313         IDirect3DTexture9_Release(offscreenTexture);
1314     }
1315     if(offscreen) {
1316         IDirect3DSurface9_Release(offscreen);
1317     }
1318 }
1319
1320 /* This test tests fog in combination with shaders.
1321  * What's tested: linear fog (vertex and table) with pixel shader
1322  *                linear table fog with non foggy vertex shader
1323  *                vertex fog with foggy vertex shader
1324  * What's not tested: non linear fog with shader
1325  *                    table fog with foggy vertex shader
1326  */
1327 static void fog_with_shader_test(IDirect3DDevice9 *device)
1328 {
1329     HRESULT hr;
1330     DWORD color;
1331     union {
1332         float f;
1333         DWORD i;
1334     } start, end;
1335     unsigned int i, j;
1336
1337     /* basic vertex shader without fog computation ("non foggy") */
1338     static const DWORD vertex_shader_code1[] = {
1339         0xfffe0101,                                                             /* vs_1_1                       */
1340         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
1341         0x0000001f, 0x8000000a, 0x900f0001,                                     /* dcl_color0 v1                */
1342         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
1343         0x00000001, 0xd00f0000, 0x90e40001,                                     /* mov oD0, v1                  */
1344         0x0000ffff
1345     };
1346     /* basic vertex shader with reversed fog computation ("foggy") */
1347     static const DWORD vertex_shader_code2[] = {
1348         0xfffe0101,                                                             /* vs_1_1                        */
1349         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0               */
1350         0x0000001f, 0x8000000a, 0x900f0001,                                     /* dcl_color0 v1                 */
1351         0x00000051, 0xa00f0000, 0xbfa00000, 0x00000000, 0xbf666666, 0x00000000, /* def c0, -1.25, 0.0, -0.9, 0.0 */
1352         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                  */
1353         0x00000001, 0xd00f0000, 0x90e40001,                                     /* mov oD0, v1                   */
1354         0x00000002, 0x800f0000, 0x90aa0000, 0xa0aa0000,                         /* add r0, v0.z, c0.z            */
1355         0x00000005, 0xc00f0001, 0x80000000, 0xa0000000,                         /* mul oFog, r0.x, c0.x          */
1356         0x0000ffff
1357     };
1358     /* basic pixel shader */
1359     static const DWORD pixel_shader_code[] = {
1360         0xffff0101,                                                             /* ps_1_1     */
1361         0x00000001, 0x800f0000, 0x90e40000,                                     /* mov r0, vo */
1362         0x0000ffff
1363     };
1364
1365     static struct vertex quad[] = {
1366         {-1.0f, -1.0f,  0.0f,          0xFFFF0000  },
1367         {-1.0f,  1.0f,  0.0f,          0xFFFF0000  },
1368         { 1.0f, -1.0f,  0.0f,          0xFFFF0000  },
1369         { 1.0f,  1.0f,  0.0f,          0xFFFF0000  },
1370     };
1371
1372     static const D3DVERTEXELEMENT9 decl_elements[] = {
1373         {0,  0, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1374         {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT,    D3DDECLUSAGE_COLOR, 0},
1375         D3DDECL_END()
1376     };
1377
1378     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1379     IDirect3DVertexShader9      *vertex_shader[3]   = {NULL, NULL, NULL};
1380     IDirect3DPixelShader9       *pixel_shader[2]    = {NULL, NULL};
1381
1382     /* This reference data was collected on a nVidia GeForce 7600GS driver version 84.19 DirectX version 9.0c on Windows XP */
1383     static const struct test_data_t {
1384         int vshader;
1385         int pshader;
1386         D3DFOGMODE vfog;
1387         D3DFOGMODE tfog;
1388         unsigned int color[11];
1389     } test_data[] = {
1390         /* only pixel shader: */
1391         {0, 1, D3DFOG_NONE, D3DFOG_LINEAR,
1392         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1393         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1394         {0, 1, D3DFOG_EXP, D3DFOG_LINEAR,
1395         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1396         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1397         {0, 1, D3DFOG_EXP2, D3DFOG_LINEAR,
1398         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1399         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1400         {0, 1, D3DFOG_LINEAR, D3DFOG_NONE,
1401         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1402         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1403         {0, 1, D3DFOG_LINEAR, D3DFOG_LINEAR,
1404         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1405         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1406
1407         /* vertex shader */
1408         {1, 0, D3DFOG_NONE, D3DFOG_NONE,
1409         {0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00,
1410          0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00, 0x0000ff00}},
1411         {1, 0, D3DFOG_NONE, D3DFOG_LINEAR,
1412         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1413         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1414         {1, 0, D3DFOG_EXP, D3DFOG_LINEAR,
1415         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1416         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1417
1418         {1, 0, D3DFOG_EXP2, D3DFOG_LINEAR,
1419         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1420         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1421         {1, 0, D3DFOG_LINEAR, D3DFOG_LINEAR,
1422         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1423         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1424
1425         /* vertex shader and pixel shader */
1426         {1, 1, D3DFOG_NONE, D3DFOG_LINEAR,
1427         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1428         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1429         {1, 1, D3DFOG_EXP, D3DFOG_LINEAR,
1430         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1431         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1432         {1, 1, D3DFOG_EXP2, D3DFOG_LINEAR,
1433         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1434         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1435
1436         {1, 1, D3DFOG_LINEAR, D3DFOG_LINEAR,
1437         {0x00ff0000, 0x00ff0000, 0x00df2000, 0x00bf4000, 0x009f6000, 0x007f8000,
1438         0x005fa000, 0x0040bf00, 0x0020df00, 0x0000ff00, 0x0000ff00}},
1439
1440
1441 #if 0  /* FIXME: these fail on GeForce 8500 */
1442         /* foggy vertex shader */
1443         {2, 0, D3DFOG_NONE, D3DFOG_NONE,
1444         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1445          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1446         {2, 0, D3DFOG_EXP, D3DFOG_NONE,
1447         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1448          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1449         {2, 0, D3DFOG_EXP2, D3DFOG_NONE,
1450         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1451          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1452         {2, 0, D3DFOG_LINEAR, D3DFOG_NONE,
1453         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1454          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1455 #endif
1456
1457         /* foggy vertex shader and pixel shader */
1458         {2, 1, D3DFOG_NONE, D3DFOG_NONE,
1459         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1460          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1461         {2, 1, D3DFOG_EXP, D3DFOG_NONE,
1462         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1463          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1464         {2, 1, D3DFOG_EXP2, D3DFOG_NONE,
1465         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1466          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1467         {2, 1, D3DFOG_LINEAR, D3DFOG_NONE,
1468         {0x00ff0000, 0x00fe0100, 0x00de2100, 0x00bf4000, 0x009f6000, 0x007f8000,
1469          0x005fa000, 0x003fc000, 0x001fe000, 0x0000ff00, 0x0000ff00}},
1470
1471     };
1472
1473     /* NOTE: changing these values will not affect the tests with foggy vertex shader, as the values are hardcoded in the shader*/
1474     start.f=0.1f;
1475     end.f=0.9f;
1476
1477     hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]);
1478     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1479     hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]);
1480     ok(SUCCEEDED(hr), "CreateVertexShader failed (%08x)\n", hr);
1481     hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]);
1482     ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1483     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
1484     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
1485
1486     /* Setup initial states: No lighting, fog on, fog color */
1487     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
1488     ok(hr == D3D_OK, "Turning off lighting failed (%08x)\n", hr);
1489     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
1490     ok(hr == D3D_OK, "Turning on fog calculations failed (%08x)\n", hr);
1491     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xFF00FF00 /* A nice green */);
1492     ok(hr == D3D_OK, "Setting fog color failed (%08x)\n", hr);
1493     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1494     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1495
1496     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
1497     ok(hr == D3D_OK, "Turning off table fog failed (%08x)\n", hr);
1498     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
1499     ok(hr == D3D_OK, "Turning off vertex fog failed (%08x)\n", hr);
1500
1501     /* Use fogtart = 0.1 and end = 0.9 to test behavior outside the fog transition phase, too*/
1502     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i);
1503     ok(hr == D3D_OK, "Setting fog start failed (%08x)\n", hr);
1504     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i);
1505     ok(hr == D3D_OK, "Setting fog end failed (%08x)\n", hr);
1506
1507     for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++)
1508     {
1509         hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]);
1510         ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1511         hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[test_data[i].pshader]);
1512         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1513         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog);
1514         ok( hr == D3D_OK, "Setting fog vertex mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1515         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog);
1516         ok( hr == D3D_OK, "Setting fog table mode to D3DFOG_LINEAR failed (%08x)\n", hr);
1517
1518         for(j=0; j < 11; j++)
1519         {
1520             /* Don't use the whole zrange to prevent rounding errors */
1521             quad[0].z = 0.001f + (float)j / 10.02f;
1522             quad[1].z = 0.001f + (float)j / 10.02f;
1523             quad[2].z = 0.001f + (float)j / 10.02f;
1524             quad[3].z = 0.001f + (float)j / 10.02f;
1525
1526             hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1527             ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1528
1529             hr = IDirect3DDevice9_BeginScene(device);
1530             ok( hr == D3D_OK, "BeginScene returned failed (%08x)\n", hr);
1531
1532             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1533             ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
1534
1535             hr = IDirect3DDevice9_EndScene(device);
1536             ok(hr == D3D_OK, "EndScene failed (%08x)\n", hr);
1537
1538             IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1539
1540             /* As the red and green component are the result of blending use 5% tolerance on the expected value */
1541             color = getPixelColor(device, 128, 240);
1542             if(test_data[i].vshader == 1 && test_data[i].tfog == 0 && color != test_data[i].color[j]) {
1543                 todo_wine ok(color_match(color, test_data[i].color[j], 13),
1544                              "fog vs%i ps%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%(todo)\n",
1545                              test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, j, color, test_data[i].color[j]);
1546             } else {
1547                 ok(color_match(color, test_data[i].color[j], 13),
1548                    "fog vs%i ps%i fvm%i ftm%i %d: got color %08x, expected %08x +-5%%\n",
1549                    test_data[i].vshader, test_data[i].pshader, test_data[i].vfog, test_data[i].tfog, j, color, test_data[i].color[j]);
1550             }
1551         }
1552     }
1553
1554     /* reset states */
1555     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1556     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1557     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1558     ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1559     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1560     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1561     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
1562     ok(hr == D3D_OK, "Turning off fog calculations failed (%08x)\n", hr);
1563
1564     IDirect3DVertexShader9_Release(vertex_shader[1]);
1565     IDirect3DVertexShader9_Release(vertex_shader[2]);
1566     IDirect3DPixelShader9_Release(pixel_shader[1]);
1567     IDirect3DVertexDeclaration9_Release(vertex_declaration);
1568 }
1569
1570 static void generate_bumpmap_textures(IDirect3DDevice9 *device) {
1571     unsigned int i, x, y;
1572     HRESULT hr;
1573     IDirect3DTexture9 *texture[2] = {NULL, NULL};
1574     D3DLOCKED_RECT locked_rect;
1575
1576     /* Generate the textures */
1577     for(i=0; i<2; i++)
1578     {
1579         hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, 0, i?D3DFMT_A8R8G8B8:D3DFMT_V8U8,
1580                                             D3DPOOL_MANAGED, &texture[i], NULL);
1581         ok(SUCCEEDED(hr), "CreateTexture failed (0x%08x)\n", hr);
1582
1583         hr = IDirect3DTexture9_LockRect(texture[i], 0, &locked_rect, NULL, 0);
1584         ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1585         for (y = 0; y < 128; ++y)
1586         {
1587             if(i)
1588             { /* Set up black texture with 2x2 texel white spot in the middle */
1589                 DWORD *ptr = (DWORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1590                 for (x = 0; x < 128; ++x)
1591                 {
1592                     if(y>62 && y<66 && x>62 && x<66)
1593                         *ptr++ = 0xffffffff;
1594                     else
1595                         *ptr++ = 0xff000000;
1596                 }
1597             }
1598             else
1599             { /* Set up a displacement map which points away from the center parallel to the closest axis.
1600                * (if multiplied with bumpenvmat)
1601               */
1602                 WORD *ptr = (WORD *)(((BYTE *)locked_rect.pBits) + (y * locked_rect.Pitch));
1603                 for (x = 0; x < 128; ++x)
1604                 {
1605                     if(abs(x-64)>abs(y-64))
1606                     {
1607                         if(x < 64)
1608                             *ptr++ = 0xc000;
1609                         else
1610                             *ptr++ = 0x4000;
1611                     }
1612                     else
1613                     {
1614                         if(y < 64)
1615                             *ptr++ = 0x0040;
1616                         else
1617                             *ptr++ = 0x00c0;
1618                     }
1619                 }
1620             }
1621         }
1622         hr = IDirect3DTexture9_UnlockRect(texture[i], 0);
1623         ok(SUCCEEDED(hr), "UnlockRect failed (0x%08x)\n", hr);
1624
1625         hr = IDirect3DDevice9_SetTexture(device, i, (IDirect3DBaseTexture9 *)texture[i]);
1626         ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1627
1628         /* Disable texture filtering */
1629         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MINFILTER, D3DTEXF_POINT);
1630         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
1631         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
1632         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
1633
1634         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1635         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSU failed (0x%08x)\n", hr);
1636         hr = IDirect3DDevice9_SetSamplerState(device, i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1637         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_ADDRESSV failed (0x%08x)\n", hr);
1638     }
1639 }
1640
1641 /* test the behavior of the texbem instruction
1642  * with normal 2D and projective 2D textures
1643  */
1644 static void texbem_test(IDirect3DDevice9 *device)
1645 {
1646     HRESULT hr;
1647     DWORD color;
1648     int i;
1649
1650     static const DWORD pixel_shader_code[] = {
1651         0xffff0101,                         /* ps_1_1*/
1652         0x00000042, 0xb00f0000,             /* tex t0*/
1653         0x00000043, 0xb00f0001, 0xb0e40000, /* texbem t1, t0*/
1654         0x00000001, 0x800f0000, 0xb0e40001, /* mov r0, t1*/
1655         0x0000ffff
1656     };
1657     static const DWORD double_texbem_code[] =  {
1658         0xffff0103,                                         /* ps_1_3           */
1659         0x00000042, 0xb00f0000,                             /* tex t0           */
1660         0x00000043, 0xb00f0001, 0xb0e40000,                 /* texbem t1, t0    */
1661         0x00000042, 0xb00f0002,                             /* tex t2           */
1662         0x00000043, 0xb00f0003, 0xb0e40002,                 /* texbem t3, t2    */
1663         0x00000002, 0x800f0000, 0xb0e40001, 0xb0e40003,     /* add r0, t1, t3   */
1664         0x0000ffff                                          /* end              */
1665     };
1666
1667
1668     static const float quad[][7] = {
1669         {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
1670         {-128.0f/640.0f,  128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
1671         { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
1672         { 128.0f/640.0f,  128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
1673     };
1674     static const float quad_proj[][9] = {
1675         {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f,   0.0f,   0.0f, 0.0f, 128.0f},
1676         {-128.0f/640.0f,  128.0f/480.0f, 0.1f, 0.0f, 1.0f,   0.0f, 128.0f, 0.0f, 128.0f},
1677         { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 128.0f,   0.0f, 0.0f, 128.0f},
1678         { 128.0f/640.0f,  128.0f/480.0f, 0.1f, 1.0f, 1.0f, 128.0f, 128.0f, 0.0f, 128.0f},
1679     };
1680
1681     static const D3DVERTEXELEMENT9 decl_elements[][4] = { {
1682         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1683         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1684         {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1685         D3DDECL_END()
1686     },{
1687         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1688         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
1689         {0, 20, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
1690         D3DDECL_END()
1691     } };
1692
1693     /* use asymmetric matrix to test loading */
1694     float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
1695
1696     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
1697     IDirect3DPixelShader9       *pixel_shader       = NULL;
1698     IDirect3DTexture9           *texture            = NULL, *texture1, *texture2;
1699     D3DLOCKED_RECT locked_rect;
1700
1701     generate_bumpmap_textures(device);
1702
1703     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1704     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1705     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1706     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1707     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
1708
1709     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
1710     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
1711
1712     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
1713     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
1714
1715     for(i=0; i<2; i++)
1716     {
1717         if(i)
1718         {
1719             hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
1720             ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1721         }
1722
1723         hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements[i], &vertex_declaration);
1724         ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
1725         hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
1726         ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
1727
1728         hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader);
1729         ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1730         hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1731         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1732
1733         hr = IDirect3DDevice9_BeginScene(device);
1734         ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1735
1736         if(!i)
1737             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
1738         else
1739             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad_proj[0], sizeof(quad_proj[0]));
1740         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1741
1742         hr = IDirect3DDevice9_EndScene(device);
1743         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1744
1745         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1746         ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1747
1748         color = getPixelColor(device, 320-32, 240);
1749         ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1750         color = getPixelColor(device, 320+32, 240);
1751         ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1752         color = getPixelColor(device, 320, 240-32);
1753         ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1754         color = getPixelColor(device, 320, 240+32);
1755         ok(color_match(color, 0x00ffffff, 4), "texbem failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
1756
1757         hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1758         ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
1759         IDirect3DPixelShader9_Release(pixel_shader);
1760
1761         hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
1762         ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
1763         IDirect3DVertexDeclaration9_Release(vertex_declaration);
1764     }
1765
1766     /* clean up */
1767     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0, 0.0f, 0);
1768     ok(SUCCEEDED(hr), "Clear failed (0x%08x)\n", hr);
1769
1770     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
1771     ok(SUCCEEDED(hr), "SetTextureStageState D3DTSS_TEXTURETRANSFORMFLAGS failed (0x%08x)\n", hr);
1772
1773     for(i=0; i<2; i++)
1774     {
1775         hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
1776         ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
1777         IDirect3DTexture9_Release(texture); /* For the GetTexture */
1778         hr = IDirect3DDevice9_SetTexture(device, i, NULL);
1779         ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
1780         IDirect3DTexture9_Release(texture);
1781     }
1782
1783     /* Test double texbem */
1784     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture, NULL);
1785     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1786     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_V8U8, D3DPOOL_MANAGED, &texture1, NULL);
1787     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1788     hr = IDirect3DDevice9_CreateTexture(device, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture2, NULL);
1789     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr);
1790     hr = IDirect3DDevice9_CreatePixelShader(device, double_texbem_code, &pixel_shader);
1791     ok(SUCCEEDED(hr), "CreatePixelShader failed (%08x)\n", hr);
1792
1793     hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
1794     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1795     ((signed char *) locked_rect.pBits)[0] = (-1.0 / 8.0) * 127;
1796     ((signed char *) locked_rect.pBits)[1] = ( 1.0 / 8.0) * 127;
1797
1798     hr = IDirect3DTexture9_UnlockRect(texture, 0);
1799     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1800
1801     hr = IDirect3DTexture9_LockRect(texture1, 0, &locked_rect, NULL, 0);
1802     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1803     ((signed char *) locked_rect.pBits)[0] = (-2.0 / 8.0) * 127;
1804     ((signed char *) locked_rect.pBits)[1] = (-4.0 / 8.0) * 127;
1805     hr = IDirect3DTexture9_UnlockRect(texture1, 0);
1806     ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1807
1808     {
1809         /* Some data without any meaning, just to have an 8x8 array to see which element is picked */
1810 #define tex  0x00ff0000
1811 #define tex1 0x0000ff00
1812 #define origin 0x000000ff
1813         static const DWORD pixel_data[] = {
1814             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1815             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1816             0x000000ff, tex1      , 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1817             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1818             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, origin,     0x000000ff, tex       , 0x000000ff,
1819             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1820             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1821             0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
1822         };
1823 #undef tex1
1824 #undef tex2
1825 #undef origin
1826
1827         hr = IDirect3DTexture9_LockRect(texture2, 0, &locked_rect, NULL, 0);
1828         ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1829         for(i = 0; i < 8; i++) {
1830             memcpy(((char *) locked_rect.pBits) + i * locked_rect.Pitch, pixel_data + 8 * i, 8 * sizeof(DWORD));
1831         }
1832         hr = IDirect3DTexture9_UnlockRect(texture2, 0);
1833         ok(SUCCEEDED(hr), "LockRect failed (0x%08x)\n", hr);
1834     }
1835
1836     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
1837     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1838     hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) texture2);
1839     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1840     hr = IDirect3DDevice9_SetTexture(device, 2, (IDirect3DBaseTexture9 *) texture1);
1841     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1842     hr = IDirect3DDevice9_SetTexture(device, 3, (IDirect3DBaseTexture9 *) texture2);
1843     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1844     hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader);
1845     ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1846     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX4);
1847     ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1848
1849     bumpenvmat[0] =-1.0;  bumpenvmat[2] =  2.0;
1850     bumpenvmat[1] = 0.0;  bumpenvmat[3] =  0.0;
1851     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1852     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1853     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1854     IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1855
1856     bumpenvmat[0] = 1.5; bumpenvmat[2] =  0.0;
1857     bumpenvmat[1] = 0.0; bumpenvmat[3] =  0.5;
1858     IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
1859     IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
1860     IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
1861     IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
1862
1863     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1864     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1865     hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1866     hr = IDirect3DDevice9_SetSamplerState(device, 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1867     hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1868     hr = IDirect3DDevice9_SetSamplerState(device, 2, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1869     hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
1870     hr = IDirect3DDevice9_SetSamplerState(device, 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
1871
1872     hr = IDirect3DDevice9_BeginScene(device);
1873     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
1874     if(SUCCEEDED(hr)) {
1875         static const float double_quad[] = {
1876             -1.0,   -1.0,   0.0,    0.0,    0.0,    0.5,    0.5,    0.0,    0.0,    0.5,    0.5,
1877              1.0,   -1.0,   0.0,    0.0,    0.0,    0.5,    0.5,    0.0,    0.0,    0.5,    0.5,
1878             -1.0,    1.0,   0.0,    0.0,    0.0,    0.5,    0.5,    0.0,    0.0,    0.5,    0.5,
1879              1.0,    1.0,   0.0,    0.0,    0.0,    0.5,    0.5,    0.0,    0.0,    0.5,    0.5,
1880         };
1881
1882         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, double_quad, sizeof(float) * 11);
1883         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
1884         hr = IDirect3DDevice9_EndScene(device);
1885         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
1886     }
1887     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1888     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
1889     color = getPixelColor(device, 320, 240);
1890     ok(color == 0x00ffff00, "double texbem failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
1891
1892     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
1893     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1894     hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
1895     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1896     hr = IDirect3DDevice9_SetTexture(device, 2, NULL);
1897     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1898     hr = IDirect3DDevice9_SetTexture(device, 3, NULL);
1899     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (0x%08x)\n", hr);
1900     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
1901     ok(SUCCEEDED(hr), "Direct3DDevice9_SetPixelShader failed (0x%08x)\n", hr);
1902
1903     IDirect3DPixelShader9_Release(pixel_shader);
1904     IDirect3DTexture9_Release(texture);
1905     IDirect3DTexture9_Release(texture1);
1906     IDirect3DTexture9_Release(texture2);
1907 }
1908
1909 static void z_range_test(IDirect3DDevice9 *device)
1910 {
1911     const struct vertex quad[] =
1912     {
1913         {-1.0f,  0.0f,   1.1f,                          0xffff0000},
1914         {-1.0f,  1.0f,   1.1f,                          0xffff0000},
1915         { 1.0f,  0.0f,  -1.1f,                          0xffff0000},
1916         { 1.0f,  1.0f,  -1.1f,                          0xffff0000},
1917     };
1918     const struct vertex quad2[] =
1919     {
1920         {-1.0f,  0.0f,   1.1f,                          0xff0000ff},
1921         {-1.0f,  1.0f,   1.1f,                          0xff0000ff},
1922         { 1.0f,  0.0f,  -1.1f,                          0xff0000ff},
1923         { 1.0f,  1.0f,  -1.1f,                          0xff0000ff},
1924     };
1925
1926     const struct tvertex quad3[] =
1927     {
1928         {    0,   240,   1.1f,  1.0,                    0xffffff00},
1929         {    0,   480,   1.1f,  1.0,                    0xffffff00},
1930         {  640,   240,  -1.1f,  1.0,                    0xffffff00},
1931         {  640,   480,  -1.1f,  1.0,                    0xffffff00},
1932     };
1933     const struct tvertex quad4[] =
1934     {
1935         {    0,   240,   1.1f,  1.0,                    0xff00ff00},
1936         {    0,   480,   1.1f,  1.0,                    0xff00ff00},
1937         {  640,   240,  -1.1f,  1.0,                    0xff00ff00},
1938         {  640,   480,  -1.1f,  1.0,                    0xff00ff00},
1939     };
1940     HRESULT hr;
1941     DWORD color;
1942     IDirect3DVertexShader9 *shader;
1943     IDirect3DVertexDeclaration9 *decl;
1944     D3DCAPS9 caps;
1945     const DWORD shader_code[] = {
1946         0xfffe0101,                                     /* vs_1_1           */
1947         0x0000001f, 0x80000000, 0x900f0000,             /* dcl_position v0  */
1948         0x00000001, 0xc00f0000, 0x90e40000,             /* mov oPos, v0     */
1949         0x00000001, 0xd00f0000, 0xa0e40000,             /* mov oD0, c0      */
1950         0x0000ffff                                      /* end              */
1951     };
1952     static const D3DVERTEXELEMENT9 decl_elements[] = {
1953         {0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
1954         D3DDECL_END()
1955     };
1956     /* Does the Present clear the depth stencil? Clear the depth buffer with some value != 0,
1957      * then call Present. Then clear the color buffer to make sure it has some defined content
1958      * after the Present with D3DSWAPEFFECT_DISCARD. After that draw a plane that is somewhere cut
1959      * by the depth value.
1960      */
1961     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.75, 0);
1962     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
1963     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
1964     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
1965
1966     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, TRUE);
1967     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1968     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
1969     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1970     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
1971     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1972     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1973     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1974     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
1975     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
1976
1977     hr = IDirect3DDevice9_BeginScene(device);
1978     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
1979     if(hr == D3D_OK)
1980     {
1981         /* Test the untransformed vertex path */
1982         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
1983         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1984         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
1985         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1986         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
1987         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1988
1989         /* Test the transformed vertex path */
1990         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_DIFFUSE);
1991         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
1992
1993         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad4, sizeof(quad4[0]));
1994         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1995         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
1996         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
1997         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad3, sizeof(quad3[0]));
1998         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
1999
2000         hr = IDirect3DDevice9_EndScene(device);
2001         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2002     }
2003
2004     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2005     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2006
2007     /* Do not test the exact corner pixels, but go pretty close to them */
2008
2009     /* Clipped because z > 1.0 */
2010     color = getPixelColor(device, 28, 238);
2011     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2012     color = getPixelColor(device, 28, 241);
2013     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2014
2015     /* Not clipped, > z buffer clear value(0.75) */
2016     color = getPixelColor(device, 31, 238);
2017     ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2018     color = getPixelColor(device, 31, 241);
2019     ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
2020     color = getPixelColor(device, 100, 238);
2021     ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2022     color = getPixelColor(device, 100, 241);
2023     ok(color == 0x00ffff00, "Z range failed: Got color 0x%08x, expected 0x00ffff00.\n", color);
2024
2025     /* Not clipped, < z buffer clear value */
2026     color = getPixelColor(device, 104, 238);
2027     ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2028     color = getPixelColor(device, 104, 241);
2029     ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
2030     color = getPixelColor(device, 318, 238);
2031     ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2032     color = getPixelColor(device, 318, 241);
2033     ok(color == 0x0000ff00, "Z range failed: Got color 0x%08x, expected 0x0000ff00.\n", color);
2034
2035     /* Clipped because z < 0.0 */
2036     color = getPixelColor(device, 321, 238);
2037     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2038     color = getPixelColor(device, 321, 241);
2039     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2040
2041     /* Test the shader path */
2042     IDirect3DDevice9_GetDeviceCaps(device, &caps);
2043     if (caps.VertexShaderVersion < D3DVS_VERSION(1, 1)) {
2044         skip("Vertex shaders not supported\n");
2045         goto out;
2046     }
2047     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
2048     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
2049     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
2050     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
2051
2052     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.4, 0);
2053
2054     IDirect3DDevice9_SetVertexDeclaration(device, decl);
2055     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
2056     IDirect3DDevice9_SetVertexShader(device, shader);
2057     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
2058
2059     hr = IDirect3DDevice9_BeginScene(device);
2060     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2061     if(hr == D3D_OK)
2062     {
2063         float colorf[] = {1.0, 0.0, 0.0, 1.0};
2064         float colorf2[] = {0.0, 0.0, 1.0, 1.0};
2065         IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf, 1);
2066         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad, sizeof(quad[0]));
2067         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
2068         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESS);
2069         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2070         IDirect3DDevice9_SetVertexShaderConstantF(device, 0, colorf2, 1);
2071         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2 /*PrimCount */, quad2, sizeof(quad2[0]));
2072         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitiveUP failed with %08x\n", hr);
2073
2074         hr = IDirect3DDevice9_EndScene(device);
2075         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2076     }
2077
2078     IDirect3DDevice9_SetVertexDeclaration(device, NULL);
2079     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
2080     IDirect3DDevice9_SetVertexShader(device, NULL);
2081     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
2082
2083     IDirect3DVertexDeclaration9_Release(decl);
2084     IDirect3DVertexShader9_Release(shader);
2085
2086     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2087     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2088     /* Z < 1.0 */
2089     color = getPixelColor(device, 28, 238);
2090     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2091
2092     /* 1.0 < z < 0.75 */
2093     color = getPixelColor(device, 31, 238);
2094     ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2095     color = getPixelColor(device, 100, 238);
2096     ok(color == 0x00ff0000, "Z range failed: Got color 0x%08x, expected 0x00ff0000.\n", color);
2097
2098     /* 0.75 < z < 0.0 */
2099     color = getPixelColor(device, 104, 238);
2100     ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2101     color = getPixelColor(device, 318, 238);
2102     ok(color == 0x000000ff, "Z range failed: Got color 0x%08x, expected 0x000000ff.\n", color);
2103
2104     /* 0.0 < z */
2105     color = getPixelColor(device, 321, 238);
2106     ok(color == 0x00ffffff, "Z range failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
2107
2108     out:
2109     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
2110     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2111     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CLIPPING, FALSE);
2112     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2113     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
2114     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
2115 }
2116
2117 static void fill_surface(IDirect3DSurface9 *surface, DWORD color)
2118 {
2119     D3DSURFACE_DESC desc;
2120     D3DLOCKED_RECT l;
2121     HRESULT hr;
2122     unsigned int x, y;
2123     DWORD *mem;
2124
2125     memset(&desc, 0, sizeof(desc));
2126     memset(&l, 0, sizeof(l));
2127     hr = IDirect3DSurface9_GetDesc(surface, &desc);
2128     ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %08x\n", hr);
2129     hr = IDirect3DSurface9_LockRect(surface, &l, NULL, 0);
2130     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed with %08x\n", hr);
2131     if(FAILED(hr)) return;
2132
2133     for(y = 0; y < desc.Height; y++)
2134     {
2135         mem = (DWORD *) ((BYTE *) l.pBits + y * l.Pitch);
2136         for(x = 0; x < l.Pitch / sizeof(DWORD); x++)
2137         {
2138             mem[x] = color;
2139         }
2140     }
2141     hr = IDirect3DSurface9_UnlockRect(surface);
2142     ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed with %08x\n", hr);
2143 }
2144
2145 /* This tests a variety of possible StretchRect() situations */
2146 static void stretchrect_test(IDirect3DDevice9 *device)
2147 {
2148     HRESULT hr;
2149     IDirect3DTexture9 *tex_rt32 = NULL, *tex_rt64 = NULL, *tex_rt_dest64 = NULL;
2150     IDirect3DSurface9 *surf_tex_rt32 = NULL, *surf_tex_rt64 = NULL, *surf_tex_rt_dest64 = NULL;
2151     IDirect3DTexture9 *tex32 = NULL, *tex64 = NULL, *tex_dest64 = NULL;
2152     IDirect3DSurface9 *surf_tex32 = NULL, *surf_tex64 = NULL, *surf_tex_dest64 = NULL;
2153     IDirect3DSurface9 *surf_rt32 = NULL, *surf_rt64 = NULL, *surf_rt_dest64 = NULL;
2154     IDirect3DSurface9 *surf_offscreen32 = NULL, *surf_offscreen64 = NULL, *surf_offscreen_dest64 = NULL;
2155     IDirect3DSurface9 *surf_temp32 = NULL, *surf_temp64 = NULL;
2156     IDirect3DSurface9 *orig_rt = NULL;
2157     DWORD color;
2158
2159     hr = IDirect3DDevice9_GetRenderTarget(device, 0, &orig_rt);
2160     ok(hr == D3D_OK, "Can't get render target, hr = %08x\n", hr);
2161     if(!orig_rt) {
2162         goto out;
2163     }
2164
2165     /* Create our temporary surfaces in system memory */
2166     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp32, NULL);
2167     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2168     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &surf_temp64, NULL);
2169     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2170
2171     /* Create offscreen plain surfaces in D3DPOOL_DEFAULT */
2172     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 32, 32, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen32, NULL);
2173     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2174     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen64, NULL);
2175     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2176     hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 64, 64, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &surf_offscreen_dest64, NULL);
2177     ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed with %08x\n", hr);
2178
2179     /* Create render target surfaces */
2180     hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt32, NULL );
2181     ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2182     hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt64, NULL );
2183     ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2184     hr = IDirect3DDevice9_CreateRenderTarget(device, 64, 64, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &surf_rt_dest64, NULL );
2185     ok(hr == D3D_OK, "Creating the render target surface failed with %08x\n", hr);
2186
2187     /* Create render target textures */
2188     hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt32, NULL);
2189     ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2190     hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt64, NULL);
2191     ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2192     hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_rt_dest64, NULL);
2193     ok(hr == D3D_OK, "Creating the render target texture failed with %08x\n", hr);
2194     if (tex_rt32) {
2195         hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt32, 0, &surf_tex_rt32);
2196         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2197     }
2198     if (tex_rt64) {
2199         hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt64, 0, &surf_tex_rt64);
2200         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2201     }
2202     if (tex_rt_dest64) {
2203         hr = IDirect3DTexture9_GetSurfaceLevel(tex_rt_dest64, 0, &surf_tex_rt_dest64);
2204         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2205     }
2206
2207     /* Create regular textures in D3DPOOL_DEFAULT */
2208     hr = IDirect3DDevice9_CreateTexture(device, 32, 32, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex32, NULL);
2209     ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2210     hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex64, NULL);
2211     ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2212     hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &tex_dest64, NULL);
2213     ok(hr == D3D_OK, "Creating the regular texture failed with %08x\n", hr);
2214     if (tex32) {
2215         hr = IDirect3DTexture9_GetSurfaceLevel(tex32, 0, &surf_tex32);
2216         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2217     }
2218     if (tex64) {
2219         hr = IDirect3DTexture9_GetSurfaceLevel(tex64, 0, &surf_tex64);
2220         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2221     }
2222     if (tex_dest64) {
2223         hr = IDirect3DTexture9_GetSurfaceLevel(tex_dest64, 0, &surf_tex_dest64);
2224         ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
2225     }
2226
2227     /*********************************************************************
2228      * Tests for when the source parameter is an offscreen plain surface *
2229      *********************************************************************/
2230
2231     /* Fill the offscreen 64x64 surface with green */
2232     if (surf_offscreen64)
2233         fill_surface(surf_offscreen64, 0xff00ff00);
2234
2235     /* offscreenplain ==> offscreenplain, same size */
2236     if(surf_offscreen64 && surf_offscreen_dest64) {
2237         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_offscreen_dest64, NULL, 0);
2238         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2239
2240         if (hr == D3D_OK) {
2241             color = getPixelColorFromSurface(surf_offscreen_dest64, 32, 32);
2242             ok(color == 0xff00ff00, "StretchRect offscreen ==> offscreen same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2243         }
2244     }
2245
2246     /* offscreenplain ==> rendertarget texture, same size */
2247     if(surf_offscreen64 && surf_tex_rt_dest64 && surf_temp64) {
2248         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_rt_dest64, NULL, 0);
2249         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2250
2251         /* We can't lock rendertarget textures, so copy to our temp surface first */
2252         if (hr == D3D_OK) {
2253             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2254             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2255         }
2256
2257         if (hr == D3D_OK) {
2258             color = getPixelColorFromSurface(surf_temp64, 32, 32);
2259             ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2260         }
2261     }
2262
2263     /* offscreenplain ==> rendertarget surface, same size */
2264     if(surf_offscreen64 && surf_rt_dest64) {
2265         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_rt_dest64, NULL, 0);
2266         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2267
2268         if (hr == D3D_OK) {
2269             color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2270             ok(color == 0xff00ff00, "StretchRect offscreen ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff00ff00.\n", color);
2271         }
2272     }
2273
2274     /* offscreenplain ==> texture, same size (should fail) */
2275     if(surf_offscreen64 && surf_tex_dest64) {
2276         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen64, NULL, surf_tex_dest64, NULL, 0);
2277         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2278     }
2279
2280     /* Fill the smaller offscreen surface with red */
2281     fill_surface(surf_offscreen32, 0xffff0000);
2282
2283     /* offscreenplain ==> offscreenplain, scaling (should fail) */
2284     if(surf_offscreen32 && surf_offscreen64) {
2285         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_offscreen64, NULL, 0);
2286         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2287     }
2288
2289     /* offscreenplain ==> rendertarget texture, scaling */
2290     if(surf_offscreen32 && surf_tex_rt_dest64 && surf_temp64) {
2291         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_rt_dest64, NULL, 0);
2292         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2293
2294         /* We can't lock rendertarget textures, so copy to our temp surface first */
2295         if (hr == D3D_OK) {
2296             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2297             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2298         }
2299
2300         if (hr == D3D_OK) {
2301             color = getPixelColorFromSurface(surf_temp64, 48, 48);
2302             ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2303         }
2304     }
2305
2306     /* offscreenplain ==> rendertarget surface, scaling */
2307     if(surf_offscreen32 && surf_rt_dest64) {
2308         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_rt_dest64, NULL, 0);
2309         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2310
2311         color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2312         ok(color == 0xffff0000, "StretchRect offscreen ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2313     }
2314
2315     /* offscreenplain ==> texture, scaling (should fail) */
2316     if(surf_offscreen32 && surf_tex_dest64) {
2317         hr = IDirect3DDevice9_StretchRect(device, surf_offscreen32, NULL, surf_tex_dest64, NULL, 0);
2318         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2319     }
2320
2321     /************************************************************
2322      * Tests for when the source parameter is a regular texture *
2323      ************************************************************/
2324
2325     /* Fill the surface of the regular texture with blue */
2326     if (surf_tex64 && surf_temp64) {
2327         /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2328         fill_surface(surf_temp64, 0xff0000ff);
2329         hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex64, NULL);
2330         ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2331     }
2332
2333     /* texture ==> offscreenplain, same size */
2334     if(surf_tex64 && surf_offscreen64) {
2335         hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_offscreen64, NULL, 0);
2336         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2337     }
2338
2339     /* texture ==> rendertarget texture, same size */
2340     if(surf_tex64 && surf_tex_rt_dest64 && surf_temp64) {
2341         hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_rt_dest64, NULL, 0);
2342         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2343
2344         /* We can't lock rendertarget textures, so copy to our temp surface first */
2345         if (hr == D3D_OK) {
2346             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2347             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2348         }
2349
2350         if (hr == D3D_OK) {
2351             color = getPixelColorFromSurface(surf_temp64, 32, 32);
2352             ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2353         }
2354     }
2355
2356     /* texture ==> rendertarget surface, same size */
2357     if(surf_tex64 && surf_rt_dest64) {
2358         hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_rt_dest64, NULL, 0);
2359         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2360
2361         if (hr == D3D_OK) {
2362             color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2363             ok(color == 0xff0000ff, "StretchRect texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff0000ff.\n", color);
2364         }
2365     }
2366
2367     /* texture ==> texture, same size (should fail) */
2368     if(surf_tex64 && surf_tex_dest64) {
2369         hr = IDirect3DDevice9_StretchRect(device, surf_tex64, NULL, surf_tex_dest64, NULL, 0);
2370         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2371     }
2372
2373     /* Fill the surface of the smaller regular texture with red */
2374     if (surf_tex32 && surf_temp32) {
2375         /* Can't fill the surf_tex directly because it's created in D3DPOOL_DEFAULT */
2376         fill_surface(surf_temp32, 0xffff0000);
2377         hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex32, NULL);
2378         ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2379     }
2380
2381     /* texture ==> offscreenplain, scaling (should fail) */
2382     if(surf_tex32 && surf_offscreen64) {
2383         hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_offscreen64, NULL, 0);
2384         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2385     }
2386
2387     /* texture ==> rendertarget texture, scaling */
2388     if(surf_tex32 && surf_tex_rt_dest64 && surf_temp64) {
2389         hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_rt_dest64, NULL, 0);
2390         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2391
2392         /* We can't lock rendertarget textures, so copy to our temp surface first */
2393         if (hr == D3D_OK) {
2394             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2395             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2396         }
2397
2398         if (hr == D3D_OK) {
2399             color = getPixelColorFromSurface(surf_temp64, 48, 48);
2400             ok(color == 0xffff0000, "StretchRect texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2401         }
2402     }
2403
2404     /* texture ==> rendertarget surface, scaling */
2405     if(surf_tex32 && surf_rt_dest64) {
2406         hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_rt_dest64, NULL, 0);
2407         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2408
2409         color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2410         ok(color == 0xffff0000, "StretchRect texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2411     }
2412
2413     /* texture ==> texture, scaling (should fail) */
2414     if(surf_tex32 && surf_tex_dest64) {
2415         hr = IDirect3DDevice9_StretchRect(device, surf_tex32, NULL, surf_tex_dest64, NULL, 0);
2416         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2417     }
2418
2419     /*****************************************************************
2420      * Tests for when the source parameter is a rendertarget texture *
2421      *****************************************************************/
2422
2423     /* Fill the surface of the rendertarget texture with white */
2424     if (surf_tex_rt64 && surf_temp64) {
2425         /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2426         fill_surface(surf_temp64, 0xffffffff);
2427         hr = IDirect3DDevice9_UpdateSurface(device, surf_temp64, NULL, surf_tex_rt64, NULL);
2428         ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2429     }
2430
2431     /* rendertarget texture ==> offscreenplain, same size */
2432     if(surf_tex_rt64 && surf_offscreen64) {
2433         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_offscreen64, NULL, 0);
2434         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2435     }
2436
2437     /* rendertarget texture ==> rendertarget texture, same size */
2438     if(surf_tex_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2439         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2440         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2441
2442         /* We can't lock rendertarget textures, so copy to our temp surface first */
2443         if (hr == D3D_OK) {
2444             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2445             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2446         }
2447
2448         if (hr == D3D_OK) {
2449             color = getPixelColorFromSurface(surf_temp64, 32, 32);
2450             ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2451         }
2452     }
2453
2454     /* rendertarget texture ==> rendertarget surface, same size */
2455     if(surf_tex_rt64 && surf_rt_dest64) {
2456         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_rt_dest64, NULL, 0);
2457         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2458
2459         if (hr == D3D_OK) {
2460             color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2461             ok(color == 0xffffffff, "StretchRect rendertarget texture ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xffffffff.\n", color);
2462         }
2463     }
2464
2465     /* rendertarget texture ==> texture, same size (should fail) */
2466     if(surf_tex_rt64 && surf_tex_dest64) {
2467         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt64, NULL, surf_tex_dest64, NULL, 0);
2468         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2469     }
2470
2471     /* Fill the surface of the smaller rendertarget texture with red */
2472     if (surf_tex_rt32 && surf_temp32) {
2473         /* Can't fill the surf_tex_rt directly because it's created in D3DPOOL_DEFAULT */
2474         fill_surface(surf_temp32, 0xffff0000);
2475         hr = IDirect3DDevice9_UpdateSurface(device, surf_temp32, NULL, surf_tex_rt32, NULL);
2476         ok( hr == D3D_OK, "IDirect3DDevice9_UpdateSurface failed with %08x\n", hr);
2477     }
2478
2479     /* rendertarget texture ==> offscreenplain, scaling (should fail) */
2480     if(surf_tex_rt32 && surf_offscreen64) {
2481         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_offscreen64, NULL, 0);
2482         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2483     }
2484
2485     /* rendertarget texture ==> rendertarget texture, scaling */
2486     if(surf_tex_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2487         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2488         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2489
2490         /* We can't lock rendertarget textures, so copy to our temp surface first */
2491         if (hr == D3D_OK) {
2492             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2493             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2494         }
2495
2496         if (hr == D3D_OK) {
2497             color = getPixelColorFromSurface(surf_temp64, 48, 48);
2498             ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2499         }
2500     }
2501
2502     /* rendertarget texture ==> rendertarget surface, scaling */
2503     if(surf_tex_rt32 && surf_rt_dest64) {
2504         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_rt_dest64, NULL, 0);
2505         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2506
2507         color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2508         ok(color == 0xffff0000, "StretchRect rendertarget texture ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2509     }
2510
2511     /* rendertarget texture ==> texture, scaling (should fail) */
2512     if(surf_tex_rt32 && surf_tex_dest64) {
2513         hr = IDirect3DDevice9_StretchRect(device, surf_tex_rt32, NULL, surf_tex_dest64, NULL, 0);
2514         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2515     }
2516
2517     /*****************************************************************
2518      * Tests for when the source parameter is a rendertarget surface *
2519      *****************************************************************/
2520
2521     /* Fill the surface of the rendertarget surface with black */
2522     if (surf_rt64)
2523         fill_surface(surf_rt64, 0xff000000);
2524
2525     /* rendertarget texture ==> offscreenplain, same size */
2526     if(surf_rt64 && surf_offscreen64) {
2527         hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_offscreen64, NULL, 0);
2528         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2529     }
2530
2531     /* rendertarget surface ==> rendertarget texture, same size */
2532     if(surf_rt64 && surf_tex_rt_dest64 && surf_temp64) {
2533         hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_rt_dest64, NULL, 0);
2534         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2535
2536         /* We can't lock rendertarget textures, so copy to our temp surface first */
2537         if (hr == D3D_OK) {
2538             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2539             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2540         }
2541
2542         if (hr == D3D_OK) {
2543             color = getPixelColorFromSurface(surf_temp64, 32, 32);
2544             ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget texture same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2545         }
2546     }
2547
2548     /* rendertarget surface ==> rendertarget surface, same size */
2549     if(surf_rt64 && surf_rt_dest64) {
2550         hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_rt_dest64, NULL, 0);
2551         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2552
2553         if (hr == D3D_OK) {
2554             color = getPixelColorFromSurface(surf_rt_dest64, 32, 32);
2555             ok(color == 0xff000000, "StretchRect rendertarget surface ==> rendertarget surface same size failed: Got color 0x%08x, expected 0xff000000.\n", color);
2556         }
2557     }
2558
2559     /* rendertarget surface ==> texture, same size (should fail) */
2560     if(surf_rt64 && surf_tex_dest64) {
2561         hr = IDirect3DDevice9_StretchRect(device, surf_rt64, NULL, surf_tex_dest64, NULL, 0);
2562         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2563     }
2564
2565     /* Fill the surface of the smaller rendertarget texture with red */
2566     if (surf_rt32)
2567         fill_surface(surf_rt32, 0xffff0000);
2568
2569     /* rendertarget surface ==> offscreenplain, scaling (should fail) */
2570     if(surf_rt32 && surf_offscreen64) {
2571         hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_offscreen64, NULL, 0);
2572         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2573     }
2574
2575     /* rendertarget surface ==> rendertarget texture, scaling */
2576     if(surf_rt32 && surf_tex_rt_dest64 && surf_temp64) {
2577         hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_rt_dest64, NULL, 0);
2578         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2579
2580         /* We can't lock rendertarget textures, so copy to our temp surface first */
2581         if (hr == D3D_OK) {
2582             hr = IDirect3DDevice9_GetRenderTargetData(device, surf_tex_rt_dest64, surf_temp64);
2583             ok( hr == D3D_OK, "IDirect3DDevice9_GetRenderTargetData failed with %08x\n", hr);
2584         }
2585
2586         if (hr == D3D_OK) {
2587             color = getPixelColorFromSurface(surf_temp64, 48, 48);
2588             ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget texture scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2589         }
2590     }
2591
2592     /* rendertarget surface ==> rendertarget surface, scaling */
2593     if(surf_rt32 && surf_rt_dest64) {
2594         hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_rt_dest64, NULL, 0);
2595         ok( hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
2596
2597         color = getPixelColorFromSurface(surf_rt_dest64, 48, 48);
2598         ok(color == 0xffff0000, "StretchRect rendertarget surface ==> rendertarget surface scaling failed: Got color 0x%08x, expected 0xffff0000.\n", color);
2599     }
2600
2601     /* rendertarget surface ==> texture, scaling (should fail) */
2602     if(surf_rt32 && surf_tex_dest64) {
2603         hr = IDirect3DDevice9_StretchRect(device, surf_rt32, NULL, surf_tex_dest64, NULL, 0);
2604         todo_wine ok( hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_StretchRect succeeded, shouldn't happen (todo)\n");
2605     }
2606
2607     /* TODO: Test when source and destination RECT parameters are given... */
2608     /* TODO: Test format conversions */
2609
2610
2611 out:
2612     /* Clean up */
2613     if (surf_rt32)
2614         IDirect3DSurface9_Release(surf_rt32);
2615     if (surf_rt64)
2616         IDirect3DSurface9_Release(surf_rt64);
2617     if (surf_rt_dest64)
2618         IDirect3DSurface9_Release(surf_rt_dest64);
2619     if (surf_temp32)
2620         IDirect3DSurface9_Release(surf_temp32);
2621     if (surf_temp64)
2622         IDirect3DSurface9_Release(surf_temp64);
2623     if (surf_offscreen32)
2624         IDirect3DSurface9_Release(surf_offscreen32);
2625     if (surf_offscreen64)
2626         IDirect3DSurface9_Release(surf_offscreen64);
2627     if (surf_offscreen_dest64)
2628         IDirect3DSurface9_Release(surf_offscreen_dest64);
2629
2630     if (tex_rt32) {
2631         if (surf_tex_rt32)
2632             IDirect3DSurface9_Release(surf_tex_rt32);
2633         IDirect3DTexture9_Release(tex_rt32);
2634     }
2635     if (tex_rt64) {
2636         if (surf_tex_rt64)
2637             IDirect3DSurface9_Release(surf_tex_rt64);
2638         IDirect3DTexture9_Release(tex_rt64);
2639     }
2640     if (tex_rt_dest64) {
2641         if (surf_tex_rt_dest64)
2642             IDirect3DSurface9_Release(surf_tex_rt_dest64);
2643         IDirect3DTexture9_Release(tex_rt_dest64);
2644     }
2645     if (tex32) {
2646         if (surf_tex32)
2647             IDirect3DSurface9_Release(surf_tex32);
2648         IDirect3DTexture9_Release(tex32);
2649     }
2650     if (tex64) {
2651         if (surf_tex64)
2652             IDirect3DSurface9_Release(surf_tex64);
2653         IDirect3DTexture9_Release(tex64);
2654     }
2655     if (tex_dest64) {
2656         if (surf_tex_dest64)
2657             IDirect3DSurface9_Release(surf_tex_dest64);
2658         IDirect3DTexture9_Release(tex_dest64);
2659     }
2660
2661     if (orig_rt) {
2662         hr = IDirect3DDevice9_SetRenderTarget(device, 0, orig_rt);
2663         ok(hr == D3D_OK, "IDirect3DSetRenderTarget failed with %08x\n", hr);
2664         IDirect3DSurface9_Release(orig_rt);
2665     }
2666 }
2667
2668 static void maxmip_test(IDirect3DDevice9 *device)
2669 {
2670     IDirect3DTexture9 *texture = NULL;
2671     IDirect3DSurface9 *surface = NULL;
2672     HRESULT hr;
2673     DWORD color;
2674     const float quads[] = {
2675         -1.0,   -1.0,   0.0,    0.0,    0.0,
2676         -1.0,    0.0,   0.0,    0.0,    1.0,
2677          0.0,   -1.0,   0.0,    1.0,    0.0,
2678          0.0,    0.0,   0.0,    1.0,    1.0,
2679
2680          0.0,   -1.0,   0.0,    0.0,    0.0,
2681          0.0,    0.0,   0.0,    0.0,    1.0,
2682          1.0,   -1.0,   0.0,    1.0,    0.0,
2683          1.0,    0.0,   0.0,    1.0,    1.0,
2684
2685          0.0,    0.0,   0.0,    0.0,    0.0,
2686          0.0,    1.0,   0.0,    0.0,    1.0,
2687          1.0,    0.0,   0.0,    1.0,    0.0,
2688          1.0,    1.0,   0.0,    1.0,    1.0,
2689
2690         -1.0,    0.0,   0.0,    0.0,    0.0,
2691         -1.0,    1.0,   0.0,    0.0,    1.0,
2692          0.0,    0.0,   0.0,    1.0,    0.0,
2693          0.0,    1.0,   0.0,    1.0,    1.0,
2694     };
2695
2696     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2697     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
2698
2699     hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
2700                                         &texture, NULL);
2701     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2702     if(!texture)
2703     {
2704         skip("Failed to create test texture\n");
2705         return;
2706     }
2707
2708     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
2709     fill_surface(surface, 0xffff0000);
2710     IDirect3DSurface9_Release(surface);
2711     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 1, &surface);
2712     fill_surface(surface, 0xff00ff00);
2713     IDirect3DSurface9_Release(surface);
2714     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 2, &surface);
2715     fill_surface(surface, 0xff0000ff);
2716     IDirect3DSurface9_Release(surface);
2717
2718     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2719     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2720     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2721     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2722
2723     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2724     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2725
2726     hr = IDirect3DDevice9_BeginScene(device);
2727     if(SUCCEEDED(hr))
2728     {
2729         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2730         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2731         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2732         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2733
2734         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2735         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2736         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2737         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2738
2739         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2740         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2741         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2742         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2743
2744         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2745         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2746         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2747         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2748         hr = IDirect3DDevice9_EndScene(device);
2749     }
2750
2751     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2752     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2753     /* With mipmapping disabled, the max mip level is ignored, only level 0 is used */
2754     color = getPixelColor(device, 160, 360);
2755     ok(color == 0x00FF0000, "MapMip 0, no mipfilter has color %08x\n", color);
2756     color = getPixelColor(device, 160, 120);
2757     ok(color == 0x00FF0000, "MapMip 3, no mipfilter has color %08x\n", color);
2758     color = getPixelColor(device, 480, 120);
2759     ok(color == 0x00FF0000, "MapMip 2, no mipfilter has color %08x\n", color);
2760     color = getPixelColor(device, 480, 360);
2761     ok(color == 0x00FF0000, "MapMip 1, no mipfilter has color %08x\n", color);
2762
2763     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 0.0, 0);
2764     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
2765
2766     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
2767     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2768
2769     hr = IDirect3DDevice9_BeginScene(device);
2770     if(SUCCEEDED(hr))
2771     {
2772         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2773         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2774         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[ 0], 5 * sizeof(float));
2775         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2776
2777         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 1);
2778         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2779         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[20], 5 * sizeof(float));
2780         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2781
2782         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 2);
2783         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2784         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[40], 5 * sizeof(float));
2785         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2786
2787         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 3);
2788         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2789         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quads[60], 5 * sizeof(float));
2790         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2791         hr = IDirect3DDevice9_EndScene(device);
2792     }
2793
2794     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2795     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2796     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
2797     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2798
2799     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2800     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
2801     /* Max Mip level 0-2 sample from the specified texture level, Max Mip level 3(> levels in texture)
2802      * samples from the highest level in the texture(level 2)
2803      */
2804     color = getPixelColor(device, 160, 360);
2805     ok(color == 0x00FF0000, "MapMip 0, point mipfilter has color %08x\n", color);
2806     color = getPixelColor(device, 160, 120);
2807     ok(color == 0x000000FF, "MapMip 3, point mipfilter has color %08x\n", color);
2808     color = getPixelColor(device, 480, 120);
2809     ok(color == 0x000000FF, "MapMip 2, point mipfilter has color %08x\n", color);
2810     color = getPixelColor(device, 480, 360);
2811     ok(color == 0x0000FF00, "MapMip 1, point mipfilter has color %08x\n", color);
2812
2813     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2814     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2815     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAXMIPLEVEL, 0);
2816     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
2817     IDirect3DTexture9_Release(texture);
2818 }
2819
2820 static void release_buffer_test(IDirect3DDevice9 *device)
2821 {
2822     IDirect3DVertexBuffer9 *vb = NULL;
2823     IDirect3DIndexBuffer9 *ib = NULL;
2824     HRESULT hr;
2825     BYTE *data;
2826     long ref;
2827
2828     static const struct vertex quad[] = {
2829         {-1.0,      -1.0,       0.1,        0xffff0000},
2830         {-1.0,       1.0,       0.1,        0xffff0000},
2831         { 1.0,       1.0,       0.1,        0xffff0000},
2832
2833         {-1.0,      -1.0,       0.1,        0xff00ff00},
2834         {-1.0,       1.0,       0.1,        0xff00ff00},
2835         { 1.0,       1.0,       0.1,        0xff00ff00}
2836     };
2837     short indices[] = {3, 4, 5};
2838
2839     /* Index and vertex buffers should always be creatable */
2840     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, D3DFVF_XYZ | D3DFVF_DIFFUSE,
2841                                               D3DPOOL_MANAGED, &vb, NULL);
2842     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
2843     if(!vb) {
2844         skip("Failed to create a vertex buffer\n");
2845         return;
2846     }
2847     hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
2848     ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %08x\n", hr);
2849     if(!ib) {
2850         skip("Failed to create an index buffer\n");
2851         return;
2852     }
2853
2854     hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
2855     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
2856     memcpy(data, quad, sizeof(quad));
2857     hr = IDirect3DVertexBuffer9_Unlock(vb);
2858     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
2859
2860     hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
2861     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %08x\n", hr);
2862     memcpy(data, indices, sizeof(indices));
2863     hr = IDirect3DIndexBuffer9_Unlock(ib);
2864     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2865
2866     hr = IDirect3DDevice9_SetIndices(device, ib);
2867     ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
2868     hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad[0]));
2869     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
2870     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
2871     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2872
2873     /* Now destroy the bound index buffer and draw again */
2874     ref = IDirect3DIndexBuffer9_Release(ib);
2875     ok(ref == 0, "Index Buffer reference count is %08ld\n", ref);
2876
2877     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
2878     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
2879
2880     hr = IDirect3DDevice9_BeginScene(device);
2881     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2882     if(SUCCEEDED(hr))
2883     {
2884         /* Deliberately using minvertexindex = 0 and numVertices = 6 to prevent d3d from
2885          * making assumptions about the indices or vertices
2886          */
2887         hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 3, 3, 0, 1);
2888         ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x\n", hr);
2889         hr = IDirect3DDevice9_EndScene(device);
2890         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2891     }
2892
2893     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2894     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2895
2896     hr = IDirect3DDevice9_SetIndices(device, NULL);
2897     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2898     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
2899     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
2900
2901     /* Index buffer was already destroyed as part of the test */
2902     IDirect3DVertexBuffer9_Release(vb);
2903 }
2904
2905 static void float_texture_test(IDirect3DDevice9 *device)
2906 {
2907     IDirect3D9 *d3d = NULL;
2908     HRESULT hr;
2909     IDirect3DTexture9 *texture = NULL;
2910     D3DLOCKED_RECT lr;
2911     float *data;
2912     DWORD color;
2913     float quad[] = {
2914         -1.0,      -1.0,       0.1,     0.0,    0.0,
2915         -1.0,       1.0,       0.1,     0.0,    1.0,
2916          1.0,      -1.0,       0.1,     1.0,    0.0,
2917          1.0,       1.0,       0.1,     1.0,    1.0,
2918     };
2919
2920     memset(&lr, 0, sizeof(lr));
2921     IDirect3DDevice9_GetDirect3D(device, &d3d);
2922     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2923                                      D3DRTYPE_TEXTURE, D3DFMT_R32F) != D3D_OK) {
2924         skip("D3DFMT_R32F textures not supported\n");
2925         goto out;
2926     }
2927
2928     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_R32F,
2929                                         D3DPOOL_MANAGED, &texture, NULL);
2930     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2931     if(!texture) {
2932         skip("Failed to create R32F texture\n");
2933         goto out;
2934     }
2935
2936     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
2937     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
2938     data = lr.pBits;
2939     *data = 0.0;
2940     hr = IDirect3DTexture9_UnlockRect(texture, 0);
2941     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
2942
2943     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
2944     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2945
2946     hr = IDirect3DDevice9_BeginScene(device);
2947     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
2948     if(SUCCEEDED(hr))
2949     {
2950         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
2951         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
2952
2953         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
2954         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
2955
2956         hr = IDirect3DDevice9_EndScene(device);
2957         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
2958     }
2959     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
2960     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
2961
2962     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
2963     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
2964
2965     color = getPixelColor(device, 240, 320);
2966     ok(color == 0x0000FFFF, "R32F with value 0.0 has color %08x, expected 0x0000FFFF\n", color);
2967
2968 out:
2969     if(texture) IDirect3DTexture9_Release(texture);
2970     IDirect3D9_Release(d3d);
2971 }
2972
2973 static void g16r16_texture_test(IDirect3DDevice9 *device)
2974 {
2975     IDirect3D9 *d3d = NULL;
2976     HRESULT hr;
2977     IDirect3DTexture9 *texture = NULL;
2978     D3DLOCKED_RECT lr;
2979     DWORD *data;
2980     DWORD color, red, green, blue;
2981     float quad[] = {
2982        -1.0,      -1.0,       0.1,     0.0,    0.0,
2983        -1.0,       1.0,       0.1,     0.0,    1.0,
2984         1.0,      -1.0,       0.1,     1.0,    0.0,
2985         1.0,       1.0,       0.1,     1.0,    1.0,
2986     };
2987
2988     memset(&lr, 0, sizeof(lr));
2989     IDirect3DDevice9_GetDirect3D(device, &d3d);
2990     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
2991        D3DRTYPE_TEXTURE, D3DFMT_G16R16) != D3D_OK) {
2992            skip("D3DFMT_G16R16 textures not supported\n");
2993            goto out;
2994     }
2995
2996     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_G16R16,
2997                                         D3DPOOL_MANAGED, &texture, NULL);
2998     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
2999     if(!texture) {
3000         skip("Failed to create D3DFMT_G16R16 texture\n");
3001         goto out;
3002     }
3003
3004     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3005     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
3006     data = lr.pBits;
3007     *data = 0x0f00f000;
3008     hr = IDirect3DTexture9_UnlockRect(texture, 0);
3009     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
3010
3011     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3012     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3013
3014     hr = IDirect3DDevice9_BeginScene(device);
3015     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3016     if(SUCCEEDED(hr))
3017     {
3018         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3019         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3020
3021         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
3022         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3023
3024         hr = IDirect3DDevice9_EndScene(device);
3025         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3026     }
3027     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3028     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3029
3030     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3031     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3032
3033     color = getPixelColor(device, 240, 320);
3034     red   = (color & 0x00ff0000) >> 16;
3035     green = (color & 0x0000ff00) >>  8;
3036     blue  = (color & 0x000000ff) >>  0;
3037     ok(blue == 0xff && red >= 0xef && red <= 0xf1 && green >= 0x0e && green <= 0x10,
3038        "D3DFMT_G16R16 with value 0x00ffff00 has color %08x, expected 0x00F00FFF\n", color);
3039
3040 out:
3041     if(texture) IDirect3DTexture9_Release(texture);
3042     IDirect3D9_Release(d3d);
3043 }
3044
3045 static void texture_transform_flags_test(IDirect3DDevice9 *device)
3046 {
3047     HRESULT hr;
3048     IDirect3D9 *d3d;
3049     D3DFORMAT fmt = D3DFMT_X8R8G8B8;
3050     D3DCAPS9 caps;
3051     IDirect3DTexture9 *texture = NULL;
3052     IDirect3DVolumeTexture9 *volume = NULL;
3053     unsigned int x, y, z;
3054     D3DLOCKED_RECT lr;
3055     D3DLOCKED_BOX lb;
3056     DWORD color;
3057     UINT w, h;
3058     IDirect3DVertexDeclaration9 *decl, *decl2, *decl3;
3059     float identity[16] = {1.0, 0.0, 0.0, 0.0,
3060                            0.0, 1.0, 0.0, 0.0,
3061                            0.0, 0.0, 1.0, 0.0,
3062                            0.0, 0.0, 0.0, 1.0};
3063     static const D3DVERTEXELEMENT9 decl_elements[] = {
3064         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3065         {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3066         D3DDECL_END()
3067     };
3068     static const D3DVERTEXELEMENT9 decl_elements2[] = {
3069         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3070         {0, 12, D3DDECLTYPE_FLOAT1, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3071         D3DDECL_END()
3072     };
3073     static const D3DVERTEXELEMENT9 decl_elements3[] = {
3074         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
3075         {0, 12, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
3076         D3DDECL_END()
3077     };
3078     static const unsigned char proj_texdata[] = {0x00, 0x00, 0x00, 0x00,
3079                                                  0x00, 0xff, 0x00, 0x00,
3080                                                  0x00, 0x00, 0x00, 0x00,
3081                                                  0x00, 0x00, 0x00, 0x00};
3082
3083     memset(&lr, 0, sizeof(lr));
3084     memset(&lb, 0, sizeof(lb));
3085     IDirect3DDevice9_GetDirect3D(device, &d3d);
3086     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
3087                                      D3DRTYPE_TEXTURE, D3DFMT_A16B16G16R16) == D3D_OK) {
3088         fmt = D3DFMT_A16B16G16R16;
3089     }
3090     IDirect3D9_Release(d3d);
3091
3092     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
3093     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3094     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
3095     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3096     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements3, &decl3);
3097     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
3098     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
3099     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_SRGBTEXTURE) returned %08x\n", hr);
3100     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
3101     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MAGFILTER) returned %08x\n", hr);
3102     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
3103     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MINFILTER) returned %08x\n", hr);
3104     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
3105     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_MIPFILTER) returned %08x\n", hr);
3106     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
3107     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSU) returned %08x\n", hr);
3108     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
3109     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSV) returned %08x\n", hr);
3110     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
3111     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState(D3DSAMP_ADDRESSW) returned %08x\n", hr);
3112     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
3113     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState(D3DRS_LIGHTING) returned %08x\n", hr);
3114     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3115     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3116
3117     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
3118     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps returned %08x\n", hr);
3119     w = min(1024, caps.MaxTextureWidth);
3120     h = min(1024, caps.MaxTextureHeight);
3121     hr = IDirect3DDevice9_CreateTexture(device, w, h, 1,
3122                                         0, fmt, D3DPOOL_MANAGED, &texture, NULL);
3123     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
3124     if(!texture) {
3125         skip("Failed to create the test texture\n");
3126         return;
3127     }
3128
3129     /* Unfortunately there is no easy way to set up a texture coordinate passthrough
3130      * in d3d fixed function pipeline, so create a texture that has a gradient from 0.0 to
3131      * 1.0 in red and green for the x and y coords
3132      */
3133     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3134     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %08x\n", hr);
3135     for(y = 0; y < h; y++) {
3136         for(x = 0; x < w; x++) {
3137             double r_f = (double) y / (double) h;
3138             double g_f = (double) x / (double) w;
3139             if(fmt == D3DFMT_A16B16G16R16) {
3140                 unsigned short r, g;
3141                 unsigned short *dst = (unsigned short *) (((char *) lr.pBits) + y * lr.Pitch + x * 8);
3142                 r = (unsigned short) (r_f * 65536.0);
3143                 g = (unsigned short) (g_f * 65536.0);
3144                 dst[0] = r;
3145                 dst[1] = g;
3146                 dst[2] = 0;
3147                 dst[3] = 65535;
3148             } else {
3149                 unsigned char *dst = ((unsigned char *) lr.pBits) + y * lr.Pitch + x * 4;
3150                 unsigned char r = (unsigned char) (r_f * 255.0);
3151                 unsigned char g = (unsigned char) (g_f * 255.0);
3152                 dst[0] = 0;
3153                 dst[1] = g;
3154                 dst[2] = r;
3155                 dst[3] = 255;
3156             }
3157         }
3158     }
3159     hr = IDirect3DTexture9_UnlockRect(texture, 0);
3160     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %08x\n", hr);
3161     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3162     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
3163
3164     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3165     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3166     hr = IDirect3DDevice9_BeginScene(device);
3167     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3168     if(SUCCEEDED(hr))
3169     {
3170         float quad1[] = {
3171             -1.0,      -1.0,       0.1,     1.0,    1.0,
3172             -1.0,       0.0,       0.1,     1.0,    1.0,
3173              0.0,      -1.0,       0.1,     1.0,    1.0,
3174              0.0,       0.0,       0.1,     1.0,    1.0,
3175         };
3176         float quad2[] = {
3177             -1.0,       0.0,       0.1,     1.0,    1.0,
3178             -1.0,       1.0,       0.1,     1.0,    1.0,
3179              0.0,       0.0,       0.1,     1.0,    1.0,
3180              0.0,       1.0,       0.1,     1.0,    1.0,
3181         };
3182         float quad3[] = {
3183              0.0,       0.0,       0.1,     0.5,    0.5,
3184              0.0,       1.0,       0.1,     0.5,    0.5,
3185              1.0,       0.0,       0.1,     0.5,    0.5,
3186              1.0,       1.0,       0.1,     0.5,    0.5,
3187         };
3188         float quad4[] = {
3189              320,       480,       0.1,     1.0,    0.0,    1.0,
3190              320,       240,       0.1,     1.0,    0.0,    1.0,
3191              640,       480,       0.1,     1.0,    0.0,    1.0,
3192              640,       240,       0.1,     1.0,    0.0,    1.0,
3193         };
3194         float mat[16] = {0.0, 0.0, 0.0, 0.0,
3195                           0.0, 0.0, 0.0, 0.0,
3196                           0.0, 0.0, 0.0, 0.0,
3197                           0.0, 0.0, 0.0, 0.0};
3198
3199         /* What happens with the texture matrix if D3DTSS_TEXTURETRANSFORMFLAGS is disabled? */
3200         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3201         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3202         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3203         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3204
3205         /* What happens with transforms enabled? */
3206         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3207         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3208         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3209         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3210
3211         /* What happens if 4 coords are used, but only 2 given ?*/
3212         mat[8] = 1.0;
3213         mat[13] = 1.0;
3214         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3215         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3216         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3217         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3218         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3219         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3220
3221         /* What happens with transformed geometry? This setup lead to 0/0 coords with untransformed
3222          * geometry. If the same applies to transformed vertices, the quad will be black, otherwise red,
3223          * due to the coords in the vertices. (turns out red, indeed)
3224          */
3225         memset(mat, 0, sizeof(mat));
3226         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3227         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3228         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZRHW | D3DFVF_TEX1);
3229         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3230         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3231         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3232         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3233         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3234
3235         hr = IDirect3DDevice9_EndScene(device);
3236         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3237     }
3238     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3239     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3240     color = getPixelColor(device, 160, 360);
3241     ok(color == 0x00FFFF00 || color == 0x00FEFE00, "quad 1 has color %08x, expected 0x00FFFF00\n", color);
3242     color = getPixelColor(device, 160, 120);
3243     ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3244     color = getPixelColor(device, 480, 120);
3245     ok(color == 0x0000FF00 || color == 0x0000FE00, "quad 3 has color %08x, expected 0x0000FF00\n", color);
3246     color = getPixelColor(device, 480, 360);
3247     ok(color == 0x00FF0000 || 0x00FE0000, "quad 4 has color %08x, expected 0x00FF0000\n", color);
3248
3249     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
3250     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3251
3252     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3253     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3254     hr = IDirect3DDevice9_BeginScene(device);
3255     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3256     if(SUCCEEDED(hr))
3257     {
3258         float quad1[] = {
3259             -1.0,      -1.0,       0.1,     0.8,    0.2,
3260             -1.0,       0.0,       0.1,     0.8,    0.2,
3261              0.0,      -1.0,       0.1,     0.8,    0.2,
3262              0.0,       0.0,       0.1,     0.8,    0.2,
3263         };
3264         float quad2[] = {
3265             -1.0,       0.0,       0.1,     0.5,    1.0,
3266             -1.0,       1.0,       0.1,     0.5,    1.0,
3267              0.0,       0.0,       0.1,     0.5,    1.0,
3268              0.0,       1.0,       0.1,     0.5,    1.0,
3269         };
3270         float quad3[] = {
3271              0.0,       0.0,       0.1,     0.5,    1.0,
3272              0.0,       1.0,       0.1,     0.5,    1.0,
3273              1.0,       0.0,       0.1,     0.5,    1.0,
3274              1.0,       1.0,       0.1,     0.5,    1.0,
3275         };
3276         float quad4[] = {
3277              0.0,      -1.0,       0.1,     0.8,    0.2,
3278              0.0,       0.0,       0.1,     0.8,    0.2,
3279              1.0,      -1.0,       0.1,     0.8,    0.2,
3280              1.0,       0.0,       0.1,     0.8,    0.2,
3281         };
3282         float mat[16] = {0.0, 0.0, 0.0, 0.0,
3283                           0.0, 0.0, 0.0, 0.0,
3284                           0.0, 1.0, 0.0, 0.0,
3285                           0.0, 0.0, 0.0, 0.0};
3286
3287         /* What happens to the default 1 in the 3rd coordinate if it is disabled?
3288          */
3289         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3290         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3291         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3292         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3293
3294         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 5 * sizeof(float));
3295         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3296
3297         /* D3DTFF_COUNT1 does not work on Nvidia drivers. It behaves like D3DTTFF_DISABLE. On ATI drivers
3298          * it behaves like COUNT2 because normal textures require 2 coords
3299          */
3300         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3301         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3302         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 5 * sizeof(float));
3303         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3304
3305         /* Just to be sure, the same as quad2 above */
3306         memset(mat, 0, sizeof(mat));
3307         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &mat);
3308         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3309         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3310         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3311         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 5 * sizeof(float));
3312         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3313
3314         /* Now, what happens to the 2nd coordinate(that is disabled in the matrix) if it is not
3315          * used? And what happens to the first?
3316          */
3317         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3318         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3319         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3320         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3321
3322         hr = IDirect3DDevice9_EndScene(device);
3323         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3324     }
3325     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3326     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3327     color = getPixelColor(device, 160, 360);
3328     ok(color == 0x00FF0000 || color == 0x00FE0000, "quad 1 has color %08x, expected 0x00FF0000\n", color);
3329     color = getPixelColor(device, 160, 120);
3330     ok(color == 0x00000000, "quad 2 has color %08x, expected 0x0000000\n", color);
3331     color = getPixelColor(device, 480, 120);
3332     ok(color == 0x00ff8000 || color == 0x00fe7f00 || color == 0x00000000,
3333        "quad 3 has color %08x, expected 0x00ff8000\n", color);
3334     color = getPixelColor(device, 480, 360);
3335     ok(color == 0x0033cc00 || color == 0x0032cb00 || color == 0x00FF0000 || color == 0x00FE0000,
3336        "quad 4 has color %08x, expected 0x0033cc00\n", color);
3337
3338     IDirect3DTexture9_Release(texture);
3339
3340     /* Test projected textures, without any fancy matrices */
3341     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3342     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3343     hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 1, 0, D3DFMT_L8, D3DPOOL_MANAGED, &texture, NULL);
3344     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
3345     hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3346     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3347     hr = IDirect3DDevice9_SetVertexDeclaration(device, decl3);
3348     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3349
3350     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
3351     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed with %08x\n", hr);
3352     for(x = 0; x < 4; x++) {
3353         memcpy(((BYTE *) lr.pBits) + lr.Pitch * x, proj_texdata + 4 * x, 4 * sizeof(proj_texdata[0]));
3354     }
3355     hr = IDirect3DTexture9_UnlockRect(texture, 0);
3356     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed with %08x\n", hr);
3357     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
3358     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3359
3360     hr = IDirect3DDevice9_BeginScene(device);
3361     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3362     if(SUCCEEDED(hr))
3363     {
3364         const float proj_quads[] = {
3365            -1.0,   -1.0,    0.1,    0.0,    0.0,    4.0,    6.0,
3366             1.0,   -1.0,    0.1,    4.0,    0.0,    4.0,    6.0,
3367            -1.0,    0.0,    0.1,    0.0,    4.0,    4.0,    6.0,
3368             1.0,    0.0,    0.1,    4.0,    4.0,    4.0,    6.0,
3369            -1.0,    0.0,    0.1,    0.0,    0.0,    4.0,    6.0,
3370             1.0,    0.0,    0.1,    4.0,    0.0,    4.0,    6.0,
3371            -1.0,    1.0,    0.1,    0.0,    4.0,    4.0,    6.0,
3372             1.0,    1.0,    0.1,    4.0,    4.0,    4.0,    6.0,
3373         };
3374
3375         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);
3376         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3377         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[0*7], 7 * sizeof(float));
3378         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3379
3380         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED);
3381         ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3382         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &proj_quads[4*7], 7 * sizeof(float));
3383         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
3384
3385         hr = IDirect3DDevice9_EndScene(device);
3386         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3387     }
3388
3389     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3390     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
3391     IDirect3DTexture9_Release(texture);
3392
3393     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3394     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3395     color = getPixelColor(device, 158, 118);
3396     ok(color == 0x00000000, "proj: Pixel 158/118 has color 0x%08x, expected 0x00000000\n", color);
3397     color = getPixelColor(device, 162, 118);
3398     ok(color == 0x00000000, "proj: Pixel 162/118 has color 0x%08x, expected 0x00000000\n", color);
3399     color = getPixelColor(device, 158, 122);
3400     ok(color == 0x00000000, "proj: Pixel 158/122 has color 0x%08x, expected 0x00000000\n", color);
3401     color = getPixelColor(device, 162, 122);
3402     ok(color == 0x00FFFFFF, "proj: Pixel 162/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3403
3404     color = getPixelColor(device, 158, 178);
3405     ok(color == 0x00000000, "proj: Pixel 158/178 has color 0x%08x, expected 0x00000000\n", color);
3406     color = getPixelColor(device, 162, 178);
3407     ok(color == 0x00FFFFFF, "proj: Pixel 158/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3408     color = getPixelColor(device, 158, 182);
3409     ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3410     color = getPixelColor(device, 162, 182);
3411     ok(color == 0x00000000, "proj: Pixel 158/182 has color 0x%08x, expected 0x00000000\n", color);
3412
3413     color = getPixelColor(device, 318, 118);
3414     ok(color == 0x00000000, "proj: Pixel 318/118 has color 0x%08x, expected 0x00000000\n", color);
3415     color = getPixelColor(device, 322, 118);
3416     ok(color == 0x00000000, "proj: Pixel 322/118 has color 0x%08x, expected 0x00000000\n", color);
3417     color = getPixelColor(device, 318, 122);
3418     ok(color == 0x00FFFFFF, "proj: Pixel 318/122 has color 0x%08x, expected 0x00FFFFFF\n", color);
3419     color = getPixelColor(device, 322, 122);
3420     ok(color == 0x00000000, "proj: Pixel 322/122 has color 0x%08x, expected 0x00000000\n", color);
3421
3422     color = getPixelColor(device, 318, 178);
3423     ok(color == 0x00FFFFFF, "proj: Pixel 318/178 has color 0x%08x, expected 0x00FFFFFF\n", color);
3424     color = getPixelColor(device, 322, 178);
3425     ok(color == 0x00000000, "proj: Pixel 322/178 has color 0x%08x, expected 0x00000000\n", color);
3426     color = getPixelColor(device, 318, 182);
3427     ok(color == 0x00000000, "proj: Pixel 318/182 has color 0x%08x, expected 0x00000000\n", color);
3428     color = getPixelColor(device, 322, 182);
3429     ok(color == 0x00000000, "proj: Pixel 322/182 has color 0x%08x, expected 0x00000000\n", color);
3430
3431     color = getPixelColor(device, 238, 298);
3432     ok(color == 0x00000000, "proj: Pixel 238/298 has color 0x%08x, expected 0x00000000\n", color);
3433     color = getPixelColor(device, 242, 298);
3434     ok(color == 0x00000000, "proj: Pixel 242/298 has color 0x%08x, expected 0x00000000\n", color);
3435     color = getPixelColor(device, 238, 302);
3436     ok(color == 0x00000000, "proj: Pixel 238/302 has color 0x%08x, expected 0x00000000\n", color);
3437     color = getPixelColor(device, 242, 302);
3438     ok(color == 0x00FFFFFF, "proj: Pixel 242/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3439
3440     color = getPixelColor(device, 238, 388);
3441     ok(color == 0x00000000, "proj: Pixel 238/388 has color 0x%08x, expected 0x00000000\n", color);
3442     color = getPixelColor(device, 242, 388);
3443     ok(color == 0x00FFFFFF, "proj: Pixel 242/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3444     color = getPixelColor(device, 238, 392);
3445     ok(color == 0x00000000, "proj: Pixel 238/392 has color 0x%08x, expected 0x00000000\n", color);
3446     color = getPixelColor(device, 242, 392);
3447     ok(color == 0x00000000, "proj: Pixel 242/392 has color 0x%08x, expected 0x00000000\n", color);
3448
3449     color = getPixelColor(device, 478, 298);
3450     ok(color == 0x00000000, "proj: Pixel 478/298 has color 0x%08x, expected 0x00000000\n", color);
3451     color = getPixelColor(device, 482, 298);
3452     ok(color == 0x00000000, "proj: Pixel 482/298 has color 0x%08x, expected 0x00000000\n", color);
3453     color = getPixelColor(device, 478, 302);
3454     ok(color == 0x00FFFFFF, "proj: Pixel 478/302 has color 0x%08x, expected 0x00FFFFFF\n", color);
3455     color = getPixelColor(device, 482, 302);
3456     ok(color == 0x00000000, "proj: Pixel 482/302 has color 0x%08x, expected 0x00000000\n", color);
3457
3458     color = getPixelColor(device, 478, 388);
3459     ok(color == 0x00FFFFFF, "proj: Pixel 478/388 has color 0x%08x, expected 0x00FFFFFF\n", color);
3460     color = getPixelColor(device, 482, 388);
3461     ok(color == 0x00000000, "proj: Pixel 482/388 has color 0x%08x, expected 0x00000000\n", color);
3462     color = getPixelColor(device, 478, 392);
3463     ok(color == 0x00000000, "proj: Pixel 478/392 has color 0x%08x, expected 0x00000000\n", color);
3464     color = getPixelColor(device, 482, 392);
3465     ok(color == 0x00000000, "proj: Pixel 482/392 has color 0x%08x, expected 0x00000000\n", color);
3466
3467     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff203040, 0.0, 0);
3468     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3469     /* Use a smaller volume texture than the biggest possible size for memory and performance reasons
3470      * Thus watch out if sampling from texels between 0 and 1.
3471      */
3472     hr = IDirect3DDevice9_CreateVolumeTexture(device, 32, 32, 32, 1, 0, fmt, D3DPOOL_MANAGED, &volume, 0);
3473     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
3474        "IDirect3DDevice9_CreateVolumeTexture failed with %08x\n", hr);
3475     if(!volume) {
3476         skip("Failed to create a volume texture\n");
3477         goto out;
3478     }
3479
3480     hr = IDirect3DVolumeTexture9_LockBox(volume, 0, &lb, NULL, 0);
3481     ok(hr == D3D_OK, "IDirect3DVolumeTexture9_LockBox failed with %08x\n", hr);
3482     for(z = 0; z < 32; z++) {
3483         for(y = 0; y < 32; y++) {
3484             for(x = 0; x < 32; x++) {
3485                 char size = (fmt == D3DFMT_A16B16G16R16 ? 8 : 4);
3486                 void *mem = ((char *)  lb.pBits) + y * lb.RowPitch + z * lb.SlicePitch + x * size;
3487                 float r_f = (float) x / 31.0;
3488                 float g_f = (float) y / 31.0;
3489                 float b_f = (float) z / 31.0;
3490
3491                 if(fmt == D3DFMT_A16B16G16R16) {
3492                     unsigned short *mem_s = mem;
3493                     mem_s[0]  = r_f * 65535.0;
3494                     mem_s[1]  = g_f * 65535.0;
3495                     mem_s[2]  = b_f * 65535.0;
3496                     mem_s[3]  = 65535;
3497                 } else {
3498                     unsigned char *mem_c = mem;
3499                     mem_c[0]  = b_f * 255.0;
3500                     mem_c[1]  = g_f * 255.0;
3501                     mem_c[2]  = r_f * 255.0;
3502                     mem_c[3]  = 255;
3503                 }
3504             }
3505         }
3506     }
3507     hr = IDirect3DVolumeTexture9_UnlockBox(volume, 0);
3508     ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %08x\n", hr);
3509
3510     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) volume);
3511     ok(hr == D3D_OK, "IDirect3DVolumeTexture9_UnlockBox failed with %08x\n", hr);
3512
3513     hr = IDirect3DDevice9_BeginScene(device);
3514     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3515     if(SUCCEEDED(hr))
3516     {
3517         float quad1[] = {
3518             -1.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3519             -1.0,       0.0,       0.1,     1.0,    1.0,    1.0,
3520              0.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3521              0.0,       0.0,       0.1,     1.0,    1.0,    1.0
3522         };
3523         float quad2[] = {
3524             -1.0,       0.0,       0.1,     1.0,    1.0,    1.0,
3525             -1.0,       1.0,       0.1,     1.0,    1.0,    1.0,
3526              0.0,       0.0,       0.1,     1.0,    1.0,    1.0,
3527              0.0,       1.0,       0.1,     1.0,    1.0,    1.0
3528         };
3529         float quad3[] = {
3530              0.0,       0.0,       0.1,     0.0,    0.0,
3531              0.0,       1.0,       0.1,     0.0,    0.0,
3532              1.0,       0.0,       0.1,     0.0,    0.0,
3533              1.0,       1.0,       0.1,     0.0,    0.0
3534         };
3535         float quad4[] = {
3536              0.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3537              0.0,       0.0,       0.1,     1.0,    1.0,    1.0,
3538              1.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3539              1.0,       0.0,       0.1,     1.0,    1.0,    1.0
3540         };
3541         float mat[16] = {1.0, 0.0, 0.0, 0.0,
3542                          0.0, 0.0, 1.0, 0.0,
3543                          0.0, 1.0, 0.0, 0.0,
3544                          0.0, 0.0, 0.0, 1.0};
3545         hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3546         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3547
3548         /* Draw a quad with all 3 coords enabled. Nothing fancy. v and w are swapped, but have the same
3549          * values
3550          */
3551         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3552         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3553         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT3);
3554         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3555         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3556         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3557
3558         /* Now disable the w coordinate. Does that change the input, or the output. The coordinates
3559          * are swapped by the matrix. If it changes the input, the v coord will be missing(green),
3560          * otherwise the w will be missing(blue).
3561          * turns out that on nvidia cards the blue color is missing, so it is an output modification.
3562          * On ATI cards the COUNT2 is ignored, and it behaves in the same way as COUNT3.
3563          */
3564         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
3565         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3566         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
3567         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3568
3569         /* default values? Set up the identity matrix, pass in 2 vertex coords, and enable 4 */
3570         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3571         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3572         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3573         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3574         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
3575         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3576         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 5 * sizeof(float));
3577         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3578
3579         /* D3DTTFF_COUNT1. Set a NULL matrix, and count1, pass in all values as 1.0. Nvidia has count1 ==
3580          * disable. ATI extends it up to the amount of values needed for the volume texture
3581          */
3582         memset(mat, 0, sizeof(mat));
3583         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3584         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3585         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT1);
3586         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3587         hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3588         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3589         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
3590         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3591
3592         hr = IDirect3DDevice9_EndScene(device);
3593         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3594     }
3595     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3596     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3597
3598     color = getPixelColor(device, 160, 360);
3599     ok(color == 0x00ffffff, "quad 1 has color %08x, expected 0x00ffffff\n", color);
3600     color = getPixelColor(device, 160, 120);
3601     ok(color == 0x00ffff00 /* NV*/ || color == 0x00ffffff /* ATI */,
3602        "quad 2 has color %08x, expected 0x00ffff00\n", color);
3603     color = getPixelColor(device, 480, 120);
3604     ok(color == 0x000000ff, "quad 3 has color %08x, expected 0x000000ff\n", color);
3605     color = getPixelColor(device, 480, 360);
3606     ok(color == 0x00ffffff || color == 0x0000ff00, "quad 4 has color %08x, expected 0x00ffffff\n", color);
3607
3608     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff303030, 0.0, 0);
3609     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3610     hr = IDirect3DDevice9_BeginScene(device);
3611     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
3612     if(SUCCEEDED(hr))
3613     {
3614         float quad1[] = {
3615             -1.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3616             -1.0,       0.0,       0.1,     1.0,    1.0,    1.0,
3617              0.0,      -1.0,       0.1,     1.0,    1.0,    1.0,
3618              0.0,       0.0,       0.1,     1.0,    1.0,    1.0
3619         };
3620         float quad2[] = {
3621             -1.0,       0.0,       0.1,
3622             -1.0,       1.0,       0.1,
3623              0.0,       0.0,       0.1,
3624              0.0,       1.0,       0.1,
3625         };
3626         float quad3[] = {
3627              0.0,       0.0,       0.1,     1.0,
3628              0.0,       1.0,       0.1,     1.0,
3629              1.0,       0.0,       0.1,     1.0,
3630              1.0,       1.0,       0.1,     1.0
3631         };
3632         float mat[16] =  {0.0, 0.0, 0.0, 0.0,
3633                            0.0, 0.0, 0.0, 0.0,
3634                            0.0, 0.0, 0.0, 0.0,
3635                            0.0, 1.0, 0.0, 0.0};
3636         float mat2[16] = {0.0, 0.0, 0.0, 1.0,
3637                            1.0, 0.0, 0.0, 0.0,
3638                            0.0, 1.0, 0.0, 0.0,
3639                            0.0, 0.0, 1.0, 0.0};
3640         hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
3641         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3642
3643         /* Default values? 4 coords used, 3 passed. What happens to the 4th?
3644          */
3645         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat);
3646         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3647         IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4);
3648         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3649         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
3650         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3651
3652         /* None passed */
3653         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) identity);
3654         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3655         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3656         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
3657         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
3658         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3659
3660         /* 4 used, 1 passed */
3661         hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
3662         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3663         hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) mat2);
3664         ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3665         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 4 * sizeof(float));
3666         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3667
3668         hr = IDirect3DDevice9_EndScene(device);
3669         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
3670     }
3671     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3672     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3673     color = getPixelColor(device, 160, 360);
3674     ok(color == 0x0000ff00, "quad 1 has color %08x, expected 0x0000ff00\n", color);
3675     color = getPixelColor(device, 160, 120);
3676     ok(color == 0x00000000, "quad 2 has color %08x, expected 0x00000000\n", color);
3677     color = getPixelColor(device, 480, 120);
3678     ok(color == 0x00ff0000, "quad 3 has color %08x, expected 0x00ff0000\n", color);
3679     /* Quad4: unused */
3680
3681     IDirect3DVolumeTexture9_Release(volume);
3682
3683     out:
3684     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
3685     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
3686     IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
3687     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\n", hr);
3688     hr = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, (D3DMATRIX *) &identity);
3689     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed with %08x\n", hr);
3690     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
3691     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
3692     IDirect3DVertexDeclaration9_Release(decl);
3693     IDirect3DVertexDeclaration9_Release(decl2);
3694     IDirect3DVertexDeclaration9_Release(decl3);
3695 }
3696
3697 static void texdepth_test(IDirect3DDevice9 *device)
3698 {
3699     IDirect3DPixelShader9 *shader;
3700     HRESULT hr;
3701     const float texdepth_test_data1[] = { 0.25,  2.0, 0.0, 0.0};
3702     const float texdepth_test_data2[] = { 0.25,  0.5, 0.0, 0.0};
3703     const float texdepth_test_data3[] = {-1.00,  0.1, 0.0, 0.0};
3704     const float texdepth_test_data4[] = {-0.25, -0.5, 0.0, 0.0};
3705     const float texdepth_test_data5[] = { 1.00, -0.1, 0.0, 0.0};
3706     const float texdepth_test_data6[] = { 1.00,  0.5, 0.0, 0.0};
3707     const float texdepth_test_data7[] = { 0.50,  0.0, 0.0, 0.0};
3708     DWORD shader_code[] = {
3709         0xffff0104,                                                                 /* ps_1_4               */
3710         0x00000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000,     /* def c1, 0, 0, 1, 1   */
3711         0x00000001, 0x800f0005, 0xa0e40000,                                         /* mov r5, c0           */
3712         0x0000fffd,                                                                 /* phase                */
3713         0x00000057, 0x800f0005,                                                     /* texdepth r5          */
3714         0x00000001, 0x800f0000, 0xa0e40001,                                         /* mov r0, c1           */
3715         0x0000ffff                                                                  /* end                  */
3716     };
3717     DWORD color;
3718     float vertex[] = {
3719        -1.0,   -1.0,    0.0,
3720         1.0,   -1.0,    1.0,
3721        -1.0,    1.0,    0.0,
3722         1.0,    1.0,    1.0
3723     };
3724
3725     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
3726     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3727
3728     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffff00, 0.0, 0);
3729     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
3730     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
3731     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3732     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3733     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3734     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_ALWAYS);
3735     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3736     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
3737
3738     /* Fill the depth buffer with a gradient */
3739     hr = IDirect3DDevice9_BeginScene(device);
3740     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3741     if(SUCCEEDED(hr))
3742     {
3743         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3744         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3745         hr = IDirect3DDevice9_EndScene(device);
3746         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3747     }
3748
3749     /* Now perform the actual tests. Same geometry, but with the shader */
3750     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_GREATER);
3751     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3752     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, FALSE);
3753     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3754     hr = IDirect3DDevice9_SetPixelShader(device, shader);
3755     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3756
3757     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data1, 1);
3758     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3759     hr = IDirect3DDevice9_BeginScene(device);
3760     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3761     if(SUCCEEDED(hr))
3762     {
3763         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3764         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3765
3766         hr = IDirect3DDevice9_EndScene(device);
3767         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3768     }
3769
3770     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3771     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3772     color = getPixelColor(device, 158, 240);
3773     ok(color == 0x000000ff, "Pixel 158(25%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3774     color = getPixelColor(device, 162, 240);
3775     ok(color == 0x00ffffff, "Pixel 158(25%% + 2 pixel) has color %08x, expected 0x00ffffff\n", color);
3776
3777     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3778
3779     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data2, 1);
3780     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3781     hr = IDirect3DDevice9_BeginScene(device);
3782     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3783     if(SUCCEEDED(hr))
3784     {
3785         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3786         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3787
3788         hr = IDirect3DDevice9_EndScene(device);
3789         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3790     }
3791
3792     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3793     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3794     color = getPixelColor(device, 318, 240);
3795     ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3796     color = getPixelColor(device, 322, 240);
3797     ok(color == 0x00ffff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3798
3799     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3800
3801     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data3, 1);
3802     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3803     hr = IDirect3DDevice9_BeginScene(device);
3804     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3805     if(SUCCEEDED(hr))
3806     {
3807         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3808         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3809
3810         hr = IDirect3DDevice9_EndScene(device);
3811         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3812     }
3813     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3814     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3815
3816     color = getPixelColor(device, 1, 240);
3817     ok(color == 0x00ff0000, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ff0000\n", color);
3818
3819     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3820
3821     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data4, 1);
3822     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3823     hr = IDirect3DDevice9_BeginScene(device);
3824     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3825     if(SUCCEEDED(hr))
3826     {
3827         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3828         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3829
3830         hr = IDirect3DDevice9_EndScene(device);
3831         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3832     }
3833     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3834     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3835     color = getPixelColor(device, 318, 240);
3836     ok(color == 0x000000ff, "Pixel 318(50%% - 2 pixel) has color %08x, expected 0x000000ff\n", color);
3837     color = getPixelColor(device, 322, 240);
3838     ok(color == 0x0000ff00, "Pixel 322(50%% + 2 pixel) has color %08x, expected 0x0000ff00\n", color);
3839
3840     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
3841
3842     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data5, 1);
3843     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3844     hr = IDirect3DDevice9_BeginScene(device);
3845     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3846     if(SUCCEEDED(hr))
3847     {
3848         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3849         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3850
3851         hr = IDirect3DDevice9_EndScene(device);
3852         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3853     }
3854     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3855     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3856
3857     color = getPixelColor(device, 1, 240);
3858     ok(color == 0x00ffff00, "Pixel 1(0%% + 2 pixel) has color %08x, expected 0x00ffff00\n", color);
3859
3860     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3861
3862     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data6, 1);
3863     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3864     hr = IDirect3DDevice9_BeginScene(device);
3865     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3866     if(SUCCEEDED(hr))
3867     {
3868         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3869         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3870
3871         hr = IDirect3DDevice9_EndScene(device);
3872         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3873     }
3874     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3875     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3876
3877     color = getPixelColor(device, 638, 240);
3878     ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3879
3880     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
3881
3882     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, texdepth_test_data7, 1);
3883     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
3884     hr = IDirect3DDevice9_BeginScene(device);
3885     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3886     if(SUCCEEDED(hr))
3887     {
3888         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 3 * sizeof(float));
3889         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3890
3891         hr = IDirect3DDevice9_EndScene(device);
3892         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3893     }
3894     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3895     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3896
3897     color = getPixelColor(device, 638, 240);
3898     ok(color == 0x000000ff, "Pixel 638(100%% + 2 pixel) has color %08x, expected 0x000000ff\n", color);
3899
3900     /* Cleanup */
3901     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3902     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
3903     IDirect3DPixelShader9_Release(shader);
3904
3905     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
3906     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3907     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
3908     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
3909 }
3910
3911 static void texkill_test(IDirect3DDevice9 *device)
3912 {
3913     IDirect3DPixelShader9 *shader;
3914     HRESULT hr;
3915     DWORD color;
3916
3917     const float vertex[] = {
3918     /*                          bottom  top    right    left */
3919         -1.0,   -1.0,   1.0,   -0.1,    0.9,    0.9,   -0.1,
3920          1.0,   -1.0,   0.0,    0.9,   -0.1,    0.9,   -0.1,
3921         -1.0,    1.0,   1.0,   -0.1,    0.9,   -0.1,    0.9,
3922          1.0,    1.0,   0.0,    0.9,   -0.1,   -0.1,    0.9,
3923     };
3924
3925     DWORD shader_code_11[] = {
3926     0xffff0101,                                                             /* ps_1_1                     */
3927     0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 1.0, 0.0, 0.0, 1.0 */
3928     0x00000041, 0xb00f0000,                                                 /* texkill t0                 */
3929     0x00000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                 */
3930     0x0000ffff                                                              /* end                        */
3931     };
3932     DWORD shader_code_20[] = {
3933     0xffff0200,                                                             /* ps_2_0                     */
3934     0x0200001f, 0x80000000, 0xb00f0000,                                     /* dcl t0                     */
3935     0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x3f800000, 0x3f800000, /* def c0, 0.0, 0.0, 1.0, 1.0 */
3936     0x01000041, 0xb00f0000,                                                 /* texkill t0                 */
3937     0x02000001, 0x800f0800, 0xa0e40000,                                     /* mov oC0, c0                */
3938     0x0000ffff                                                              /* end                        */
3939     };
3940
3941     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
3942     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3943     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader);
3944     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
3945
3946     hr = IDirect3DDevice9_SetPixelShader(device, shader);
3947     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
3948     hr = IDirect3DDevice9_BeginScene(device);
3949     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
3950     if(SUCCEEDED(hr))
3951     {
3952         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEXCOORDSIZE4(0) | D3DFVF_TEX1);
3953         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
3954         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
3955         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
3956         hr = IDirect3DDevice9_EndScene(device);
3957         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
3958     }
3959     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
3960     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
3961     color = getPixelColor(device, 63, 46);
3962     ok(color == 0x0000ff00, "Pixel 63/46 has color %08x, expected 0x0000ff00\n", color);
3963     color = getPixelColor(device, 66, 46);
3964     ok(color == 0x0000ff00, "Pixel 66/64 has color %08x, expected 0x0000ff00\n", color);
3965     color = getPixelColor(device, 63, 49);
3966     ok(color == 0x0000ff00, "Pixel 63/49 has color %08x, expected 0x0000ff00\n", color);
3967     color = getPixelColor(device, 66, 49);
3968     ok(color == 0x00ff0000, "Pixel 66/49 has color %08x, expected 0x00ff0000\n", color);
3969
3970     color = getPixelColor(device, 578, 46);
3971     ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3972     color = getPixelColor(device, 575, 46);
3973     ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3974     color = getPixelColor(device, 578, 49);
3975     ok(color == 0x0000ff00, "Pixel 578/49 has color %08x, expected 0x0000ff00\n", color);
3976     color = getPixelColor(device, 575, 49);
3977     ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3978
3979     color = getPixelColor(device, 63, 430);
3980     ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3981     color = getPixelColor(device, 63, 433);
3982     ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3983     color = getPixelColor(device, 66, 433);
3984     ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3985     color = getPixelColor(device, 66, 430);
3986     ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3987
3988     color = getPixelColor(device, 578, 430);
3989     ok(color == 0x0000ff00, "Pixel 578/46 has color %08x, expected 0x0000ff00\n", color);
3990     color = getPixelColor(device, 578, 433);
3991     ok(color == 0x0000ff00, "Pixel 575/64 has color %08x, expected 0x0000ff00\n", color);
3992     color = getPixelColor(device, 575, 433);
3993     ok(color == 0x00ff0000, "Pixel 578/49 has color %08x, expected 0x00ff0000\n", color);
3994     color = getPixelColor(device, 575, 430);
3995     ok(color == 0x00ff0000, "Pixel 575/49 has color %08x, expected 0x00ff0000\n", color);
3996
3997     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
3998     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
3999     IDirect3DPixelShader9_Release(shader);
4000
4001     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
4002     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4003     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader);
4004     if(FAILED(hr)) {
4005         skip("Failed to create 2.0 test shader, most likely not supported\n");
4006         return;
4007     }
4008
4009     hr = IDirect3DDevice9_SetPixelShader(device, shader);
4010     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4011     hr = IDirect3DDevice9_BeginScene(device);
4012     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4013     if(SUCCEEDED(hr))
4014     {
4015         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, vertex, 7 * sizeof(float));
4016         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4017         hr = IDirect3DDevice9_EndScene(device);
4018         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4019     }
4020     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4021
4022     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4023     color = getPixelColor(device, 63, 46);
4024     ok(color == 0x00ffff00, "Pixel 63/46 has color %08x, expected 0x00ffff00\n", color);
4025     color = getPixelColor(device, 66, 46);
4026     ok(color == 0x00ffff00, "Pixel 66/64 has color %08x, expected 0x00ffff00\n", color);
4027     color = getPixelColor(device, 63, 49);
4028     ok(color == 0x00ffff00, "Pixel 63/49 has color %08x, expected 0x00ffff00\n", color);
4029     color = getPixelColor(device, 66, 49);
4030     ok(color == 0x000000ff, "Pixel 66/49 has color %08x, expected 0x000000ff\n", color);
4031
4032     color = getPixelColor(device, 578, 46);
4033     ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4034     color = getPixelColor(device, 575, 46);
4035     ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4036     color = getPixelColor(device, 578, 49);
4037     ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4038     color = getPixelColor(device, 575, 49);
4039     ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4040
4041     color = getPixelColor(device, 63, 430);
4042     ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4043     color = getPixelColor(device, 63, 433);
4044     ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4045     color = getPixelColor(device, 66, 433);
4046     ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4047     color = getPixelColor(device, 66, 430);
4048     ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4049
4050     color = getPixelColor(device, 578, 430);
4051     ok(color == 0x00ffff00, "Pixel 578/46 has color %08x, expected 0x00ffff00\n", color);
4052     color = getPixelColor(device, 578, 433);
4053     ok(color == 0x00ffff00, "Pixel 575/64 has color %08x, expected 0x00ffff00\n", color);
4054     color = getPixelColor(device, 575, 433);
4055     ok(color == 0x00ffff00, "Pixel 578/49 has color %08x, expected 0x00ffff00\n", color);
4056     color = getPixelColor(device, 575, 430);
4057     ok(color == 0x000000ff, "Pixel 575/49 has color %08x, expected 0x000000ff\n", color);
4058
4059     /* Cleanup */
4060     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4061     ok(SUCCEEDED(hr), "SetPixelShader failed (%08x)\n", hr);
4062     IDirect3DPixelShader9_Release(shader);
4063 }
4064
4065 static void x8l8v8u8_test(IDirect3DDevice9 *device)
4066 {
4067     IDirect3D9 *d3d9;
4068     HRESULT hr;
4069     IDirect3DTexture9 *texture;
4070     IDirect3DPixelShader9 *shader;
4071     IDirect3DPixelShader9 *shader2;
4072     D3DLOCKED_RECT lr;
4073     DWORD color;
4074     DWORD shader_code[] = {
4075         0xffff0101,                             /* ps_1_1       */
4076         0x00000042, 0xb00f0000,                 /* tex t0       */
4077         0x00000001, 0x800f0000, 0xb0e40000,     /* mov r0, t0   */
4078         0x0000ffff                              /* end          */
4079     };
4080     DWORD shader_code2[] = {
4081         0xffff0101,                             /* ps_1_1       */
4082         0x00000042, 0xb00f0000,                 /* tex t0       */
4083         0x00000001, 0x800f0000, 0xb0ff0000,     /* mov r0, t0.w */
4084         0x0000ffff                              /* end          */
4085     };
4086
4087     float quad[] = {
4088        -1.0,   -1.0,   0.1,     0.5,    0.5,
4089         1.0,   -1.0,   0.1,     0.5,    0.5,
4090        -1.0,    1.0,   0.1,     0.5,    0.5,
4091         1.0,    1.0,   0.1,     0.5,    0.5,
4092     };
4093
4094     memset(&lr, 0, sizeof(lr));
4095     IDirect3DDevice9_GetDirect3D(device, &d3d9);
4096     hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4097                                       0,  D3DRTYPE_TEXTURE, D3DFMT_X8L8V8U8);
4098     IDirect3D9_Release(d3d9);
4099     if(FAILED(hr)) {
4100         skip("No D3DFMT_X8L8V8U8 support\n");
4101     };
4102
4103     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
4104     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4105
4106     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8L8V8U8, D3DPOOL_MANAGED, &texture, NULL);
4107     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed (%08x)\n", hr);
4108     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
4109     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed (%08x)\n", hr);
4110     *((DWORD *) lr.pBits) = 0x11ca3141;
4111     hr = IDirect3DTexture9_UnlockRect(texture, 0);
4112     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed (%08x)\n", hr);
4113
4114     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
4115     ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4116     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code2, &shader2);
4117     ok(hr == D3D_OK, "IDirect3DDevice9_CreateShader failed (%08x)\n", hr);
4118
4119     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4120     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
4121     hr = IDirect3DDevice9_SetPixelShader(device, shader);
4122     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4123     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4124     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4125
4126     hr = IDirect3DDevice9_BeginScene(device);
4127     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4128     if(SUCCEEDED(hr))
4129     {
4130         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4131         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4132
4133         hr = IDirect3DDevice9_EndScene(device);
4134         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4135     }
4136     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4137     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4138     color = getPixelColor(device, 578, 430);
4139     ok(color == 0x008262ca || color == 0x008363ca || color == 0x008362ca,
4140        "D3DFMT_X8L8V8U8 = 0x112131ca returns color %08x, expected 0x008262ca\n", color);
4141
4142     hr = IDirect3DDevice9_SetPixelShader(device, shader2);
4143     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4144     hr = IDirect3DDevice9_BeginScene(device);
4145     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4146     if(SUCCEEDED(hr))
4147     {
4148         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4149         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4150
4151         hr = IDirect3DDevice9_EndScene(device);
4152         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
4153     }
4154     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4155     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4156     color = getPixelColor(device, 578, 430);
4157     ok(color == 0x00ffffff, "w component of D3DFMT_X8L8V8U8 = 0x11ca3141 returns color %08x\n", color);
4158
4159     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4160     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed (%08x)\n", hr);
4161     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4162     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
4163     IDirect3DPixelShader9_Release(shader);
4164     IDirect3DPixelShader9_Release(shader2);
4165     IDirect3DTexture9_Release(texture);
4166 }
4167
4168 static void autogen_mipmap_test(IDirect3DDevice9 *device)
4169 {
4170     HRESULT hr;
4171     IDirect3D9 *d3d;
4172     IDirect3DTexture9 *texture = NULL;
4173     IDirect3DSurface9 *surface;
4174     DWORD color;
4175     const RECT r1 = {256, 256, 512, 512};
4176     const RECT r2 = {512, 256, 768, 512};
4177     const RECT r3 = {256, 512, 512, 768};
4178     const RECT r4 = {512, 512, 768, 768};
4179     unsigned int x, y;
4180     D3DLOCKED_RECT lr;
4181     memset(&lr, 0, sizeof(lr));
4182
4183     IDirect3DDevice9_GetDirect3D(device, &d3d);
4184     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
4185        D3DUSAGE_AUTOGENMIPMAP,  D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8) != D3D_OK) {
4186         skip("No autogenmipmap support\n");
4187         IDirect3D9_Release(d3d);
4188         return;
4189     }
4190     IDirect3D9_Release(d3d);
4191
4192     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
4193     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4194
4195     /* Make the mipmap big, so that a smaller mipmap is used
4196      */
4197     hr = IDirect3DDevice9_CreateTexture(device, 1024, 1024, 0, D3DUSAGE_AUTOGENMIPMAP,
4198                                         D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0);
4199     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
4200
4201     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
4202     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel returned %08x\n", hr);
4203     hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
4204     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect returned %08x\n", hr);
4205     for(y = 0; y < 1024; y++) {
4206         for(x = 0; x < 1024; x++) {
4207             DWORD *dst = (DWORD *) (((BYTE *) lr.pBits) + y * lr.Pitch + x * 4);
4208             POINT pt;
4209
4210             pt.x = x;
4211             pt.y = y;
4212             if(PtInRect(&r1, pt)) {
4213                 *dst = 0xffff0000;
4214             } else if(PtInRect(&r2, pt)) {
4215                 *dst = 0xff00ff00;
4216             } else if(PtInRect(&r3, pt)) {
4217                 *dst = 0xff0000ff;
4218             } else if(PtInRect(&r4, pt)) {
4219                 *dst = 0xff000000;
4220             } else {
4221                 *dst = 0xffffffff;
4222             }
4223         }
4224     }
4225     hr = IDirect3DSurface9_UnlockRect(surface);
4226     ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect returned %08x\n", hr);
4227     IDirect3DSurface9_Release(surface);
4228
4229     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
4230     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
4231     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);
4232     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
4233
4234     hr = IDirect3DDevice9_BeginScene(device);
4235     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4236     if(SUCCEEDED(hr)) {
4237         const float quad[] =  {
4238            -0.5,   -0.5,    0.1,    0.0,    0.0,
4239            -0.5,    0.5,    0.1,    0.0,    1.0,
4240             0.5,   -0.5,    0.1,    1.0,    0.0,
4241             0.5,    0.5,    0.1,    1.0,    1.0
4242         };
4243
4244         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4245         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4246         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
4247         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4248         hr = IDirect3DDevice9_EndScene(device);
4249         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4250     }
4251     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
4252     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
4253     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
4254     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
4255     IDirect3DTexture9_Release(texture);
4256
4257     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4258     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4259     color = getPixelColor(device, 200, 200);
4260     ok(color == 0x00ffffff, "pixel 200/200 has color %08x, expected 0x00ffffff\n", color);
4261     color = getPixelColor(device, 280, 200);
4262     ok(color == 0x000000ff, "pixel 280/200 has color %08x, expected 0x000000ff\n", color);
4263     color = getPixelColor(device, 360, 200);
4264     ok(color == 0x00000000, "pixel 360/200 has color %08x, expected 0x00000000\n", color);
4265     color = getPixelColor(device, 440, 200);
4266     ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4267     color = getPixelColor(device, 200, 270);
4268     ok(color == 0x00ffffff, "pixel 200/270 has color %08x, expected 0x00ffffff\n", color);
4269     color = getPixelColor(device, 280, 270);
4270     ok(color == 0x00ff0000, "pixel 280/270 has color %08x, expected 0x00ff0000\n", color);
4271     color = getPixelColor(device, 360, 270);
4272     ok(color == 0x0000ff00, "pixel 360/270 has color %08x, expected 0x0000ff00\n", color);
4273     color = getPixelColor(device, 440, 270);
4274     ok(color == 0x00ffffff, "pixel 440/200 has color %08x, expected 0x00ffffff\n", color);
4275 }
4276
4277 static void test_constant_clamp_vs(IDirect3DDevice9 *device)
4278 {
4279     IDirect3DVertexShader9 *shader_11, *shader_11_2, *shader_20, *shader_20_2;
4280     IDirect3DVertexDeclaration9 *decl;
4281     HRESULT hr;
4282     DWORD color;
4283     DWORD shader_code_11[] =  {
4284         0xfffe0101,                                         /* vs_1_1           */
4285         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0  */
4286         0x00000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4287         0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002,     /* add oD0, r1, c2  */
4288         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0     */
4289         0x0000ffff                                          /* end              */
4290     };
4291     DWORD shader_code_11_2[] =  {
4292         0xfffe0101,                                         /* vs_1_1           */
4293         0x00000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000, /* dcl ... */
4294         0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* dcl ... */
4295         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0  */
4296         0x00000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4297         0x00000002, 0xd00f0000, 0x80e40001, 0xa0e40002,     /* add oD0, r1, c2  */
4298         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0     */
4299         0x0000ffff                                          /* end              */
4300     };
4301     DWORD shader_code_20[] =  {
4302         0xfffe0200,                                         /* vs_2_0           */
4303         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0  */
4304         0x02000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4305         0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002,     /* add oD0, r1, c2  */
4306         0x02000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0     */
4307         0x0000ffff                                          /* end              */
4308     };
4309     DWORD shader_code_20_2[] =  {
4310         0xfffe0200,                                         /* vs_2_0           */
4311         0x05000051, 0xa00f0001, 0x3fa00000, 0xbf000000, 0xbfc00000, 0x3f800000,
4312         0x05000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000,
4313         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0  */
4314         0x02000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4315         0x03000002, 0xd00f0000, 0x80e40001, 0xa0e40002,     /* add oD0, r1, c2  */
4316         0x02000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0     */
4317         0x0000ffff                                          /* end              */
4318     };
4319     static const D3DVERTEXELEMENT9 decl_elements[] = {
4320         {0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
4321         D3DDECL_END()
4322     };
4323     float quad1[] = {
4324         -1.0,   -1.0,   0.1,
4325          0.0,   -1.0,   0.1,
4326         -1.0,    0.0,   0.1,
4327          0.0,    0.0,   0.1
4328     };
4329     float quad2[] = {
4330          0.0,   -1.0,   0.1,
4331          1.0,   -1.0,   0.1,
4332          0.0,    0.0,   0.1,
4333          1.0,    0.0,   0.1
4334     };
4335     float quad3[] = {
4336          0.0,    0.0,   0.1,
4337          1.0,    0.0,   0.1,
4338          0.0,    1.0,   0.1,
4339          1.0,    1.0,   0.1
4340     };
4341     float quad4[] = {
4342         -1.0,    0.0,   0.1,
4343          0.0,    0.0,   0.1,
4344         -1.0,    1.0,   0.1,
4345          0.0,    1.0,   0.1
4346     };
4347     float test_data_c1[4] = {  1.25, -0.50, -1.50, 1.0};
4348     float test_data_c2[4] = { -0.50,  1.25,  2.00, 1.0};
4349
4350     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4351     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4352
4353     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11, &shader_11);
4354     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
4355     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_11_2, &shader_11_2);
4356     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
4357     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20, &shader_20);
4358     if(FAILED(hr)) shader_20 = NULL;
4359     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code_20_2, &shader_20_2);
4360     if(FAILED(hr)) shader_20_2 = NULL;
4361     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
4362     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
4363
4364     hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, test_data_c1, 1);
4365     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %08x\n", hr);
4366     hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 2, test_data_c2, 1);
4367     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShaderConstantF returned %08x\n", hr);
4368     hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
4369     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
4370
4371     hr = IDirect3DDevice9_BeginScene(device);
4372     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4373     if(SUCCEEDED(hr))
4374     {
4375         hr = IDirect3DDevice9_SetVertexShader(device, shader_11);
4376         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4377         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4378         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4379
4380         hr = IDirect3DDevice9_SetVertexShader(device, shader_11_2);
4381         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4382         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4383         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4384
4385         if(shader_20) {
4386             hr = IDirect3DDevice9_SetVertexShader(device, shader_20);
4387             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4388             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4389             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4390         }
4391
4392         if(shader_20_2) {
4393             hr = IDirect3DDevice9_SetVertexShader(device, shader_20_2);
4394             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4395             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4396             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4397         }
4398
4399         hr = IDirect3DDevice9_EndScene(device);
4400         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4401     }
4402     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4403     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4404
4405     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
4406     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4407     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
4408     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
4409
4410     color = getPixelColor(device, 160, 360);
4411     ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4412        "quad 1 has color %08x, expected 0x00bfbf80\n", color);
4413     color = getPixelColor(device, 480, 360);
4414     ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4415        "quad 2 has color %08x, expected 0x00bfbf80\n", color);
4416     if(shader_20) {
4417         color = getPixelColor(device, 160, 120);
4418         ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4419            "quad 3 has color %08x, expected 0x00bfbf80\n", color);
4420     }
4421     if(shader_20_2) {
4422         color = getPixelColor(device, 480, 120);
4423         ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4424            "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4425     }
4426
4427     IDirect3DVertexDeclaration9_Release(decl);
4428     if(shader_20_2) IDirect3DVertexShader9_Release(shader_20_2);
4429     if(shader_20) IDirect3DVertexShader9_Release(shader_20);
4430     IDirect3DVertexShader9_Release(shader_11_2);
4431     IDirect3DVertexShader9_Release(shader_11);
4432 }
4433
4434 static void constant_clamp_ps_test(IDirect3DDevice9 *device)
4435 {
4436     IDirect3DPixelShader9 *shader_11, *shader_12, *shader_14, *shader_20;
4437     HRESULT hr;
4438     DWORD color;
4439     DWORD shader_code_11[] =  {
4440         0xffff0101,                                         /* ps_1_1           */
4441         0x00000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4442         0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002,     /* add r0, r1, c2   */
4443         0x0000ffff                                          /* end              */
4444     };
4445     DWORD shader_code_12[] =  {
4446         0xffff0102,                                         /* ps_1_2           */
4447         0x00000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4448         0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002,     /* add r0, r1, c2   */
4449         0x0000ffff                                          /* end              */
4450     };
4451     /* Skip 1.3 shaders because we have only 4 quads(ok, could make them smaller if needed).
4452      * 1.2 and 1.4 shaders behave the same, so it's unlikely that 1.3 shaders are different.
4453      * During development of this test, 1.3 shaders were verified too
4454      */
4455     DWORD shader_code_14[] =  {
4456         0xffff0104,                                         /* ps_1_4           */
4457         /* Try to make one constant local. It gets clamped too, although the binary contains
4458          * the bigger numbers
4459          */
4460         0x00000051, 0xa00f0002, 0xbf000000, 0x3fa00000, 0x40000000, 0x3f800000, /* def c2, -0.5, 1.25, 2, 1 */
4461         0x00000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4462         0x00000002, 0x800f0000, 0x80e40001, 0xa0e40002,     /* add r0, r1, c2   */
4463         0x0000ffff                                          /* end              */
4464     };
4465     DWORD shader_code_20[] =  {
4466         0xffff0200,                                         /* ps_2_0           */
4467         0x02000001, 0x800f0001, 0xa0e40001,                 /* mov r1, c1       */
4468         0x03000002, 0x800f0000, 0x80e40001, 0xa0e40002,     /* add r0, r1, c2   */
4469         0x02000001, 0x800f0800, 0x80e40000,                 /* mov oC0, r0      */
4470         0x0000ffff                                          /* end              */
4471     };
4472     float quad1[] = {
4473         -1.0,   -1.0,   0.1,
4474          0.0,   -1.0,   0.1,
4475         -1.0,    0.0,   0.1,
4476          0.0,    0.0,   0.1
4477     };
4478     float quad2[] = {
4479          0.0,   -1.0,   0.1,
4480          1.0,   -1.0,   0.1,
4481          0.0,    0.0,   0.1,
4482          1.0,    0.0,   0.1
4483     };
4484     float quad3[] = {
4485          0.0,    0.0,   0.1,
4486          1.0,    0.0,   0.1,
4487          0.0,    1.0,   0.1,
4488          1.0,    1.0,   0.1
4489     };
4490     float quad4[] = {
4491         -1.0,    0.0,   0.1,
4492          0.0,    0.0,   0.1,
4493         -1.0,    1.0,   0.1,
4494          0.0,    1.0,   0.1
4495     };
4496     float test_data_c1[4] = {  1.25, -0.50, -1.50, 1.0};
4497     float test_data_c2[4] = { -0.50,  1.25,  2.00, 1.0};
4498
4499     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4500     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4501
4502     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4503     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4504     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4505     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4506     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4507     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4508     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_20, &shader_20);
4509     if(FAILED(hr)) shader_20 = NULL;
4510
4511     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4512     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4513     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4514     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4515     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4516     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4517
4518     hr = IDirect3DDevice9_BeginScene(device);
4519     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4520     if(SUCCEEDED(hr))
4521     {
4522         hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4523         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4524         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 3 * sizeof(float));
4525         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4526
4527         hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4528         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4529         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 3 * sizeof(float));
4530         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4531
4532         hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4533         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4534         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 3 * sizeof(float));
4535         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4536
4537         if(shader_20) {
4538             hr = IDirect3DDevice9_SetPixelShader(device, shader_20);
4539             ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4540             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 3 * sizeof(float));
4541             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4542         }
4543
4544         hr = IDirect3DDevice9_EndScene(device);
4545         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4546     }
4547     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4548     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4549
4550     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4551     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4552
4553     color = getPixelColor(device, 160, 360);
4554     ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4555        "quad 1 has color %08x, expected 0x00808000\n", color);
4556     color = getPixelColor(device, 480, 360);
4557     ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4558        "quad 2 has color %08x, expected 0x00808000\n", color);
4559     color = getPixelColor(device, 480, 120);
4560     ok(color == 0x00808000 || color == 0x007f7f00 || color == 0x00818100,
4561        "quad 3 has color %08x, expected 0x00808000\n", color);
4562     if(shader_20) {
4563         color = getPixelColor(device, 160, 120);
4564         ok(color == 0x00bfbf80 || color == 0x00bfbf7f || color == 0x00bfbf81,
4565            "quad 4 has color %08x, expected 0x00bfbf80\n", color);
4566     }
4567
4568     if(shader_20) IDirect3DPixelShader9_Release(shader_20);
4569     IDirect3DPixelShader9_Release(shader_14);
4570     IDirect3DPixelShader9_Release(shader_12);
4571     IDirect3DPixelShader9_Release(shader_11);
4572 }
4573
4574 static void dp2add_ps_test(IDirect3DDevice9 *device)
4575 {
4576     IDirect3DPixelShader9 *shader_dp2add = NULL;
4577     IDirect3DPixelShader9 *shader_dp2add_sat = NULL;
4578     HRESULT hr;
4579     DWORD color;
4580
4581     /* DP2ADD is defined as:  (src0.r * src1.r) + (src0.g * src1.g) + src2.
4582      * One D3D restriction of all shader instructions except SINCOS is that no more than 2
4583      * source tokens can be constants.  So, for this exercise, we move contents of c0 to
4584      * r0 first.
4585      * The result here for the r,g,b components should be roughly 0.5:
4586      *   (0.5 * 0.5) + (0.5 * 0.5) + 0.0 = 0.5 */
4587     static const DWORD shader_code_dp2add[] =  {
4588         0xffff0200,                                                             /* ps_2_0                       */
4589         0x05000051, 0xa00f0000, 0x3f000000, 0x3f000000, 0x3f800000, 0x00000000, /* def c0, 0.5, 0.5, 1.0, 0     */
4590
4591         0x02000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                   */
4592         0x0400005a, 0x80070000, 0x80000000, 0x80000000, 0x80ff0000,             /* dp2add r0.rgb, r0, r0, r0.a  */
4593
4594         0x02000001, 0x80080000, 0xa0aa0000,                                     /* mov r0.a, c0.b               */
4595         0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                  */
4596         0x0000ffff                                                              /* end                          */
4597     };
4598
4599     /* Test the _sat modifier, too.  Result here should be:
4600      *   DP2: (-0.5 * -0.5) + (-0.5 * -0.5) + 2.0 = 2.5
4601      *      _SAT: ==> 1.0
4602      *   ADD: (1.0 + -0.5) = 0.5
4603      */
4604     static const DWORD shader_code_dp2add_sat[] =  {
4605         0xffff0200,                                                             /* ps_2_0                           */
4606         0x05000051, 0xa00f0000, 0xbf000000, 0xbf000000, 0x3f800000, 0x40000000, /* def c0, -0.5, -0.5, 1.0, 2.0     */
4607
4608         0x02000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                       */
4609         0x0400005a, 0x80170000, 0x80000000, 0x80000000, 0x80ff0000,             /* dp2add_sat r0.rgb, r0, r0, r0.a  */
4610         0x03000002, 0x80070000, 0x80e40000, 0xa0000000,                         /* add r0.rgb, r0, c0.r             */
4611
4612         0x02000001, 0x80080000, 0xa0aa0000,                                     /* mov r0.a, c0.b                   */
4613         0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                      */
4614         0x0000ffff                                                              /* end                              */
4615     };
4616
4617     const float quad[] = {
4618         -1.0,   -1.0,   0.1,
4619          1.0,   -1.0,   0.1,
4620         -1.0,    1.0,   0.1,
4621          1.0,    1.0,   0.1
4622     };
4623
4624
4625     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
4626     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4627
4628     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add, &shader_dp2add);
4629     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4630
4631     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_dp2add_sat, &shader_dp2add_sat);
4632     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4633
4634     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
4635     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4636
4637     if (shader_dp2add) {
4638
4639         hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add);
4640         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4641
4642         hr = IDirect3DDevice9_BeginScene(device);
4643         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4644         if(SUCCEEDED(hr))
4645         {
4646             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4647             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4648
4649             hr = IDirect3DDevice9_EndScene(device);
4650             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4651         }
4652         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4653         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4654
4655         color = getPixelColor(device, 360, 240);
4656         ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4657
4658         IDirect3DPixelShader9_Release(shader_dp2add);
4659     } else {
4660         skip("dp2add shader creation failed\n");
4661     }
4662
4663     if (shader_dp2add_sat) {
4664
4665         hr = IDirect3DDevice9_SetPixelShader(device, shader_dp2add_sat);
4666         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4667
4668         hr = IDirect3DDevice9_BeginScene(device);
4669         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4670         if(SUCCEEDED(hr))
4671         {
4672             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
4673             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4674
4675             hr = IDirect3DDevice9_EndScene(device);
4676             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4677         }
4678         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4679         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4680
4681         color = getPixelColor(device, 360, 240);
4682         ok(color == 0x007f7f7f || color == 0x00808080, "dp2add pixel has color %08x, expected ~0x007f7f7f\n", color);
4683
4684         IDirect3DPixelShader9_Release(shader_dp2add_sat);
4685     } else {
4686         skip("dp2add shader creation failed\n");
4687     }
4688
4689     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4690     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4691 }
4692
4693 static void cnd_test(IDirect3DDevice9 *device)
4694 {
4695     IDirect3DPixelShader9 *shader_11, *shader_12, *shader_13, *shader_14;
4696     IDirect3DPixelShader9 *shader_11_coissue, *shader_12_coissue, *shader_13_coissue, *shader_14_coissue;
4697     HRESULT hr;
4698     DWORD color;
4699     /* ps 1.x shaders are rather picky with writemasks and source swizzles. The dp3 is
4700      * used to copy r0.r to all components of r1, then copy r1.a to c0.a. Essentially it
4701      * does a mov r0.a, r0.r, which isn't allowed as-is in 1.x pixel shaders.
4702      */
4703     DWORD shader_code_11[] =  {
4704         0xffff0101,                                                                 /* ps_1_1               */
4705         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000,     /* def c0, 1, 0, 0, 0   */
4706         0x00000040, 0xb00f0000,                                                     /* texcoord t0          */
4707         0x00000001, 0x800f0000, 0xb0e40000,                                         /* mov r0, ???(t0)      */
4708         0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000,                             /* dp3 r1, r0, c0       */
4709         0x00000001, 0x80080000, 0x80ff0001,                                         /* mov r0.a, r1.a       */
4710         0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002,                 /* cnd r0, r0.a, c1, c2 */
4711         0x0000ffff                                                                  /* end                  */
4712     };
4713     DWORD shader_code_12[] =  {
4714         0xffff0102,                                                                 /* ps_1_2               */
4715         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000,     /* def c0, 1, 0, 0, 0   */
4716         0x00000040, 0xb00f0000,                                                     /* texcoord t0          */
4717         0x00000001, 0x800f0000, 0xb0e40000,                                         /* mov r0, t0           */
4718         0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000,                             /* dp3 r1, r0, c0       */
4719         0x00000001, 0x80080000, 0x80ff0001,                                         /* mov r0.a, r1.a       */
4720         0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002,                 /* cnd r0, r0.a, c1, c2 */
4721         0x0000ffff                                                                  /* end                  */
4722     };
4723     DWORD shader_code_13[] =  {
4724         0xffff0103,                                                                 /* ps_1_3               */
4725         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000,     /* def c0, 1, 0, 0, 0   */
4726         0x00000040, 0xb00f0000,                                                     /* texcoord t0          */
4727         0x00000001, 0x800f0000, 0xb0e40000,                                         /* mov r0, t0           */
4728         0x00000008, 0x800f0001, 0x80e40000, 0xa0e40000,                             /* dp3, r1, r0, c0      */
4729         0x00000001, 0x80080000, 0x80ff0001,                                         /* mov r0.a, r1.a       */
4730         0x00000050, 0x800f0000, 0x80ff0000, 0xa0e40001, 0xa0e40002,                 /* cnd r0, r0.a, c1, c2 */
4731         0x0000ffff                                                                  /* end                  */
4732     };
4733     DWORD shader_code_14[] =  {
4734         0xffff0104,                                                                 /* ps_1_3               */
4735         0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000,     /* def c0, 0, 0, 0, 1   */
4736         0x00000040, 0x80070000, 0xb0e40000,                                         /* texcrd r0, t0        */
4737         0x00000001, 0x80080000, 0xa0ff0000,                                         /* mov r0.a, c0.a       */
4738         0x00000050, 0x800f0000, 0x80e40000, 0xa0e40001, 0xa0e40002,                 /* cnd r0, r0, c1, c2   */
4739         0x0000ffff                                                                  /* end                  */
4740     };
4741
4742     /* Special fun: The coissue flag on cnd: Apparently cnd always selects the 2nd source,
4743      * as if the src0 comparison against 0.5 always evaluates to true. The coissue flag isn't
4744      * set by the compiler, it was added manually after compilation. It isn't always allowed,
4745      * only if there's a mov r0.a, XXXX, and the cnd instruction writes to r0.xyz, otherwise
4746      * native CreatePixelShader returns an error.
4747      *
4748      * The shader attempts to test the range [-1;1] against coissued cnd, which is a bit tricky.
4749      * The input from t0 is [0;1]. 0.5 is substracted, then we have to multiply with 2. Since
4750      * constants are clamped to [-1;1], a 2.0 is constructed by adding c0.r(=1.0) to c0.r into r1.r,
4751      * then r1(2.0, 0.0, 0.0, 0.0) is passed to dp3(explained above).
4752      */
4753     DWORD shader_code_11_coissue[] =  {
4754         0xffff0101,                                                             /* ps_1_1                   */
4755         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0       */
4756         0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4757         0x00000040, 0xb00f0000,                                                 /* texcoord t0              */
4758         0x00000001, 0x800f0000, 0xb0e40000,                                     /* mov r0, t0               */
4759         0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003,                         /* sub r0, r0, c3           */
4760         0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000,                         /* add r1, c0, c0           */
4761         0x00000008, 0x800f0001, 0x80e40000, 0x80e40001,                         /* dp3, r1, r0, r1          */
4762         0x00000001, 0x80080000, 0x80ff0001,                                     /* mov r0.a, r1.a           */
4763         /* 0x40000000 = D3DSI_COISSUE */
4764         0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002,             /* cnd r0.xyz, r0.a, c1, c2 */
4765         0x0000ffff                                                              /* end                      */
4766     };
4767     DWORD shader_code_12_coissue[] =  {
4768         0xffff0102,                                                             /* ps_1_2                   */
4769         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0       */
4770         0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4771         0x00000040, 0xb00f0000,                                                 /* texcoord t0              */
4772         0x00000001, 0x800f0000, 0xb0e40000,                                     /* mov r0, t0               */
4773         0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003,                         /* sub r0, r0, c3           */
4774         0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000,                         /* add r1, c0, c0           */
4775         0x00000008, 0x800f0001, 0x80e40000, 0x80e40001,                         /* dp3, r1, r0, r1          */
4776         0x00000001, 0x80080000, 0x80ff0001,                                     /* mov r0.a, r1.a           */
4777         /* 0x40000000 = D3DSI_COISSUE */
4778         0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002,             /* cnd r0.xyz, r0.a, c1, c2 */
4779         0x0000ffff                                                              /* end                      */
4780     };
4781     DWORD shader_code_13_coissue[] =  {
4782         0xffff0103,                                                             /* ps_1_3                   */
4783         0x00000051, 0xa00f0000, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 1, 0, 0, 0       */
4784         0x00000051, 0xa00f0003, 0x3f000000, 0x3f000000, 0x3f000000, 0x00000000, /* def c3, 0.5, 0.5, 0.5, 0 */
4785         0x00000040, 0xb00f0000,                                                 /* texcoord t0              */
4786         0x00000001, 0x800f0000, 0xb0e40000,                                     /* mov r0, t0               */
4787         0x00000003, 0x800f0000, 0x80e40000, 0xa0e40003,                         /* sub r0, r0, c3           */
4788         0x00000002, 0x800f0001, 0xa0e40000, 0xa0e40000,                         /* add r1, c0, c0           */
4789         0x00000008, 0x800f0001, 0x80e40000, 0x80e40001,                         /* dp3, r1, r0, r1          */
4790         0x00000001, 0x80080000, 0x80ff0001,                                     /* mov r0.a, r1.a           */
4791         /* 0x40000000 = D3DSI_COISSUE */
4792         0x40000050, 0x80070000, 0x80ff0000, 0xa0e40001, 0xa0e40002,             /* cnd r0.xyz, r0.a, c1, c2 */
4793         0x0000ffff                                                              /* end                      */
4794     };
4795     /* ps_1_4 does not have a different cnd behavior, just pass the [0;1] texcrd result to cnd, it will
4796      * compare against 0.5
4797      */
4798     DWORD shader_code_14_coissue[] =  {
4799         0xffff0104,                                                             /* ps_1_4                   */
4800         0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1       */
4801         0x00000040, 0x80070000, 0xb0e40000,                                     /* texcrd r0, t0            */
4802         0x00000001, 0x80080000, 0xa0ff0000,                                     /* mov r0.a, c0.a           */
4803         /* 0x40000000 = D3DSI_COISSUE */
4804         0x40000050, 0x80070000, 0x80e40000, 0xa0e40001, 0xa0e40002,             /* cnd r0.xyz, r0, c1, c2   */
4805         0x0000ffff                                                              /* end                      */
4806     };
4807     float quad1[] = {
4808         -1.0,   -1.0,   0.1,     0.0,    0.0,    1.0,
4809          0.0,   -1.0,   0.1,     1.0,    0.0,    1.0,
4810         -1.0,    0.0,   0.1,     0.0,    1.0,    0.0,
4811          0.0,    0.0,   0.1,     1.0,    1.0,    0.0
4812     };
4813     float quad2[] = {
4814          0.0,   -1.0,   0.1,     0.0,    0.0,    1.0,
4815          1.0,   -1.0,   0.1,     1.0,    0.0,    1.0,
4816          0.0,    0.0,   0.1,     0.0,    1.0,    0.0,
4817          1.0,    0.0,   0.1,     1.0,    1.0,    0.0
4818     };
4819     float quad3[] = {
4820          0.0,    0.0,   0.1,     0.0,    0.0,    1.0,
4821          1.0,    0.0,   0.1,     1.0,    0.0,    1.0,
4822          0.0,    1.0,   0.1,     0.0,    1.0,    0.0,
4823          1.0,    1.0,   0.1,     1.0,    1.0,    0.0
4824     };
4825     float quad4[] = {
4826         -1.0,    0.0,   0.1,     0.0,    0.0,    1.0,
4827          0.0,    0.0,   0.1,     1.0,    0.0,    1.0,
4828         -1.0,    1.0,   0.1,     0.0,    1.0,    0.0,
4829          0.0,    1.0,   0.1,     1.0,    1.0,    0.0
4830     };
4831     float test_data_c1[4] = {  0.0, 0.0, 0.0, 0.0};
4832     float test_data_c2[4] = {  1.0, 1.0, 1.0, 1.0};
4833     float test_data_c1_coi[4] = {  0.0, 1.0, 0.0, 0.0};
4834     float test_data_c2_coi[4] = {  1.0, 0.0, 1.0, 1.0};
4835
4836     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4837     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4838
4839     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11, &shader_11);
4840     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4841     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12, &shader_12);
4842     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4843     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13, &shader_13);
4844     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4845     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14, &shader_14);
4846     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4847     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_11_coissue, &shader_11_coissue);
4848     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4849     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_12_coissue, &shader_12_coissue);
4850     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4851     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_13_coissue, &shader_13_coissue);
4852     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4853     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code_14_coissue, &shader_14_coissue);
4854     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
4855
4856     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1, 1);
4857     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4858     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2, 1);
4859     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4860     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
4861     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
4862
4863     hr = IDirect3DDevice9_BeginScene(device);
4864     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4865     if(SUCCEEDED(hr))
4866     {
4867         hr = IDirect3DDevice9_SetPixelShader(device, shader_11);
4868         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4869         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4870         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4871
4872         hr = IDirect3DDevice9_SetPixelShader(device, shader_12);
4873         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4874         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4875         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4876
4877         hr = IDirect3DDevice9_SetPixelShader(device, shader_13);
4878         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4879         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4880         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4881
4882         hr = IDirect3DDevice9_SetPixelShader(device, shader_14);
4883         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4884         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4885         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4886
4887         hr = IDirect3DDevice9_EndScene(device);
4888         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4889     }
4890     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4891     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4892
4893     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4894     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
4895
4896     /* This is the 1.4 test. Each component(r, g, b) is tested separately against 0.5 */
4897     color = getPixelColor(device, 158, 118);
4898     ok(color == 0x00ff00ff, "pixel 158, 118 has color %08x, expected 0x00ff00ff\n", color);
4899     color = getPixelColor(device, 162, 118);
4900     ok(color == 0x000000ff, "pixel 162, 118 has color %08x, expected 0x000000ff\n", color);
4901     color = getPixelColor(device, 158, 122);
4902     ok(color == 0x00ffffff, "pixel 162, 122 has color %08x, expected 0x00ffffff\n", color);
4903     color = getPixelColor(device, 162, 122);
4904     ok(color == 0x0000ffff, "pixel 162, 122 has color %08x, expected 0x0000ffff\n", color);
4905
4906     /* 1.1 shader. All 3 components get set, based on the .w comparison */
4907     color = getPixelColor(device, 158, 358);
4908     ok(color == 0x00ffffff, "pixel 158, 358 has color %08x, expected 0x00ffffff\n", color);
4909     color = getPixelColor(device, 162, 358);
4910     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4911         "pixel 162, 358 has color %08x, expected 0x00000000\n", color);
4912     color = getPixelColor(device, 158, 362);
4913     ok(color == 0x00ffffff, "pixel 158, 362 has color %08x, expected 0x00ffffff\n", color);
4914     color = getPixelColor(device, 162, 362);
4915     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4916         "pixel 162, 362 has color %08x, expected 0x00000000\n", color);
4917
4918     /* 1.2 shader */
4919     color = getPixelColor(device, 478, 358);
4920     ok(color == 0x00ffffff, "pixel 478, 358 has color %08x, expected 0x00ffffff\n", color);
4921     color = getPixelColor(device, 482, 358);
4922     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4923         "pixel 482, 358 has color %08x, expected 0x00000000\n", color);
4924     color = getPixelColor(device, 478, 362);
4925     ok(color == 0x00ffffff, "pixel 478, 362 has color %08x, expected 0x00ffffff\n", color);
4926     color = getPixelColor(device, 482, 362);
4927     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4928         "pixel 482, 362 has color %08x, expected 0x00000000\n", color);
4929
4930     /* 1.3 shader */
4931     color = getPixelColor(device, 478, 118);
4932     ok(color == 0x00ffffff, "pixel 478, 118 has color %08x, expected 0x00ffffff\n", color);
4933     color = getPixelColor(device, 482, 118);
4934     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4935         "pixel 482, 118 has color %08x, expected 0x00000000\n", color);
4936     color = getPixelColor(device, 478, 122);
4937     ok(color == 0x00ffffff, "pixel 478, 122 has color %08x, expected 0x00ffffff\n", color);
4938     color = getPixelColor(device, 482, 122);
4939     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) <= 0x01) && ((color & 0x000000ff) <= 0x01),
4940         "pixel 482, 122 has color %08x, expected 0x00000000\n", color);
4941
4942     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
4943     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
4944     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 1, test_data_c1_coi, 1);
4945     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4946     hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 2, test_data_c2_coi, 1);
4947     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF returned %08x\n", hr);
4948
4949     hr = IDirect3DDevice9_BeginScene(device);
4950     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
4951     if(SUCCEEDED(hr))
4952     {
4953         hr = IDirect3DDevice9_SetPixelShader(device, shader_11_coissue);
4954         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4955         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, 6 * sizeof(float));
4956         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4957
4958         hr = IDirect3DDevice9_SetPixelShader(device, shader_12_coissue);
4959         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4960         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, 6 * sizeof(float));
4961         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4962
4963         hr = IDirect3DDevice9_SetPixelShader(device, shader_13_coissue);
4964         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4965         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, 6 * sizeof(float));
4966         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4967
4968         hr = IDirect3DDevice9_SetPixelShader(device, shader_14_coissue);
4969         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4970         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, 6 * sizeof(float));
4971         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
4972
4973         hr = IDirect3DDevice9_EndScene(device);
4974         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
4975     }
4976     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
4977     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
4978
4979     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
4980     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
4981
4982     /* This is the 1.4 test. The coissue doesn't change the behavior here, but keep in mind
4983      * that we swapped the values in c1 and c2 to make the other tests return some color
4984      */
4985     color = getPixelColor(device, 158, 118);
4986     ok(color == 0x00ffffff, "pixel 158, 118 has color %08x, expected 0x00ffffff\n", color);
4987     color = getPixelColor(device, 162, 118);
4988     ok(color == 0x0000ffff, "pixel 162, 118 has color %08x, expected 0x0000ffff\n", color);
4989     color = getPixelColor(device, 158, 122);
4990     ok(color == 0x00ff00ff, "pixel 162, 122 has color %08x, expected 0x00ff00ff\n", color);
4991     color = getPixelColor(device, 162, 122);
4992     ok(color == 0x000000ff, "pixel 162, 122 has color %08x, expected 0x000000ff\n", color);
4993
4994     /* 1.1 shader. coissue flag changed the semantic of cnd, c1 is always selected */
4995     color = getPixelColor(device, 158, 358);
4996     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
4997         "pixel 158, 358 has color %08x, expected 0x0000ff00\n", color);
4998     color = getPixelColor(device, 162, 358);
4999     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5000         "pixel 162, 358 has color %08x, expected 0x0000ff00\n", color);
5001     color = getPixelColor(device, 158, 362);
5002     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5003         "pixel 158, 362 has color %08x, expected 0x0000ff00\n", color);
5004     color = getPixelColor(device, 162, 362);
5005     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5006         "pixel 162, 362 has color %08x, expected 0x0000ff00\n", color);
5007
5008     /* 1.2 shader */
5009     color = getPixelColor(device, 478, 358);
5010     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5011         "pixel 478, 358 has color %08x, expected 0x0000ff00\n", color);
5012     color = getPixelColor(device, 482, 358);
5013     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5014         "pixel 482, 358 has color %08x, expected 0x0000ff00\n", color);
5015     color = getPixelColor(device, 478, 362);
5016     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5017         "pixel 478, 362 has color %08x, expected 0x0000ff00\n", color);
5018     color = getPixelColor(device, 482, 362);
5019     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5020         "pixel 482, 362 has color %08x, expected 0x0000ff00\n", color);
5021
5022     /* 1.3 shader */
5023     color = getPixelColor(device, 478, 118);
5024     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5025         "pixel 478, 118 has color %08x, expected 0x0000ff00\n", color);
5026     color = getPixelColor(device, 482, 118);
5027     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5028         "pixel 482, 118 has color %08x, expected 0x0000ff00\n", color);
5029     color = getPixelColor(device, 478, 122);
5030     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5031         "pixel 478, 122 has color %08x, expected 0x0000ff00\n", color);
5032     color = getPixelColor(device, 482, 122);
5033     ok( (((color & 0x00ff0000) >> 16) <= 0x01) && (((color & 0x0000ff00) >> 8) == 0xff) && ((color & 0x000000ff) <= 0x01),
5034         "pixel 482, 122 has color %08x, expected 0x0000ff00\n", color);
5035
5036     IDirect3DPixelShader9_Release(shader_14_coissue);
5037     IDirect3DPixelShader9_Release(shader_13_coissue);
5038     IDirect3DPixelShader9_Release(shader_12_coissue);
5039     IDirect3DPixelShader9_Release(shader_11_coissue);
5040     IDirect3DPixelShader9_Release(shader_14);
5041     IDirect3DPixelShader9_Release(shader_13);
5042     IDirect3DPixelShader9_Release(shader_12);
5043     IDirect3DPixelShader9_Release(shader_11);
5044 }
5045
5046 static void nested_loop_test(IDirect3DDevice9 *device) {
5047     const DWORD shader_code[] = {
5048         0xffff0300,                                                             /* ps_3_0               */
5049         0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x3f800000, /* def c0, 0, 0, 0, 1   */
5050         0x05000051, 0xa00f0001, 0x3d000000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1/32, 0, 0, 0*/
5051         0x05000030, 0xf00f0000, 0x00000004, 0x00000000, 0x00000002, 0x00000000, /* defi i0, 4, 0, 2, 0  */
5052         0x02000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0           */
5053         0x0200001b, 0xf0e40800, 0xf0e40000,                                     /* loop aL, i0          */
5054         0x0200001b, 0xf0e40800, 0xf0e40000,                                     /* loop aL, i0          */
5055         0x03000002, 0x800f0000, 0x80e40000, 0xa0e40001,                         /* add r0, r0, c1       */
5056         0x0000001d,                                                             /* endloop              */
5057         0x0000001d,                                                             /* endloop              */
5058         0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0          */
5059         0x0000ffff                                                              /* end                  */
5060     };
5061     IDirect3DPixelShader9 *shader;
5062     HRESULT hr;
5063     DWORD color;
5064     const float quad[] = {
5065         -1.0,   -1.0,   0.1,
5066          1.0,   -1.0,   0.1,
5067         -1.0,    1.0,   0.1,
5068          1.0,    1.0,   0.1
5069     };
5070
5071     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
5072     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed with %08x\n", hr);
5073     hr = IDirect3DDevice9_SetPixelShader(device, shader);
5074     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %08x\n", hr);
5075     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5076     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
5077     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x0000ff00, 0.0, 0);
5078     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5079
5080     hr = IDirect3DDevice9_BeginScene(device);
5081     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5082     if(SUCCEEDED(hr))
5083     {
5084         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
5085         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5086         hr = IDirect3DDevice9_EndScene(device);
5087         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5088     }
5089     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5090     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5091
5092     color = getPixelColor(device, 360, 240);
5093     ok(color == 0x007f0000 || color == 0x00800000 || color == 0x00810000,
5094        "Nested loop test returned color 0x%08x, expected 0x00800000\n", color);
5095
5096     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5097     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed with %08x\n", hr);
5098     IDirect3DPixelShader9_Release(shader);
5099 }
5100
5101 struct varying_test_struct
5102 {
5103     const DWORD             *shader_code;
5104     IDirect3DPixelShader9   *shader;
5105     DWORD                   color, color_rhw;
5106     const char              *name;
5107     BOOL                    todo, todo_rhw;
5108 };
5109
5110 struct hugeVertex
5111 {
5112     float pos_x,        pos_y,      pos_z,      rhw;
5113     float weight_1,     weight_2,   weight_3,   weight_4;
5114     float index_1,      index_2,    index_3,    index_4;
5115     float normal_1,     normal_2,   normal_3,   normal_4;
5116     float fog_1,        fog_2,      fog_3,      fog_4;
5117     float texcoord_1,   texcoord_2, texcoord_3, texcoord_4;
5118     float tangent_1,    tangent_2,  tangent_3,  tangent_4;
5119     float binormal_1,   binormal_2, binormal_3, binormal_4;
5120     float depth_1,      depth_2,    depth_3,    depth_4;
5121     DWORD diffuse, specular;
5122 };
5123
5124 static void fixed_function_varying_test(IDirect3DDevice9 *device) {
5125     /* dcl_position: fails to compile */
5126     const DWORD blendweight_code[] = {
5127         0xffff0300,                             /* ps_3_0                   */
5128         0x0200001f, 0x80000001, 0x900f0000,     /* dcl_blendweight, v0      */
5129         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5130         0x0000ffff                              /* end                      */
5131     };
5132     const DWORD blendindices_code[] = {
5133         0xffff0300,                             /* ps_3_0                   */
5134         0x0200001f, 0x80000002, 0x900f0000,     /* dcl_blendindices, v0     */
5135         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5136         0x0000ffff                              /* end                      */
5137     };
5138     const DWORD normal_code[] = {
5139         0xffff0300,                             /* ps_3_0                   */
5140         0x0200001f, 0x80000003, 0x900f0000,     /* dcl_normal, v0           */
5141         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5142         0x0000ffff                              /* end                      */
5143     };
5144     /* psize: fails? */
5145     const DWORD texcoord0_code[] = {
5146         0xffff0300,                             /* ps_3_0                   */
5147         0x0200001f, 0x80000005, 0x900f0000,     /* dcl_texcoord0, v0        */
5148         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5149         0x0000ffff                              /* end                      */
5150     };
5151     const DWORD tangent_code[] = {
5152         0xffff0300,                             /* ps_3_0                   */
5153         0x0200001f, 0x80000006, 0x900f0000,     /* dcl_tangent, v0          */
5154         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5155         0x0000ffff                              /* end                      */
5156     };
5157     const DWORD binormal_code[] = {
5158         0xffff0300,                             /* ps_3_0                   */
5159         0x0200001f, 0x80000007, 0x900f0000,     /* dcl_binormal, v0         */
5160         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5161         0x0000ffff                              /* end                      */
5162     };
5163     /* tessfactor: fails */
5164     /* positiont: fails */
5165     const DWORD color_code[] = {
5166         0xffff0300,                             /* ps_3_0                   */
5167         0x0200001f, 0x8000000a, 0x900f0000,     /* dcl_color0, v0           */
5168         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5169         0x0000ffff                              /* end                      */
5170     };
5171     const DWORD fog_code[] = {
5172         0xffff0300,                             /* ps_3_0                   */
5173         0x0200001f, 0x8000000b, 0x900f0000,     /* dcl_fog, v0              */
5174         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5175         0x0000ffff                              /* end                      */
5176     };
5177     const DWORD depth_code[] = {
5178         0xffff0300,                             /* ps_3_0                   */
5179         0x0200001f, 0x8000000c, 0x900f0000,     /* dcl_depth, v0            */
5180         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5181         0x0000ffff                              /* end                      */
5182     };
5183     const DWORD specular_code[] = {
5184         0xffff0300,                             /* ps_3_0                   */
5185         0x0200001f, 0x8001000a, 0x900f0000,     /* dcl_color1, v0           */
5186         0x02000001, 0x800f0800, 0x90e40000,     /* mov oC0, v0              */
5187         0x0000ffff                              /* end                      */
5188     };
5189     /* sample: fails */
5190
5191     struct varying_test_struct tests[] = {
5192        {blendweight_code,       NULL,       0x00000000,     0x00191919,     "blendweight"   ,   FALSE,  TRUE  },
5193        {blendindices_code,      NULL,       0x00000000,     0x00000000,     "blendindices"  ,   FALSE,  FALSE },
5194        {normal_code,            NULL,       0x00000000,     0x004c4c4c,     "normal"        ,   FALSE,  TRUE  },
5195        /* Why does dx not forward the texcoord? */
5196        {texcoord0_code,         NULL,       0x00000000,     0x00808c8c,     "texcoord0"     ,   FALSE,  FALSE },
5197        {tangent_code,           NULL,       0x00000000,     0x00999999,     "tangent"       ,   FALSE,  TRUE  },
5198        {binormal_code,          NULL,       0x00000000,     0x00b2b2b2,     "binormal"      ,   FALSE,  TRUE  },
5199        {color_code,             NULL,       0x00e6e6e6,     0x00e6e6e6,     "color"         ,   FALSE,  FALSE },
5200        {fog_code,               NULL,       0x00000000,     0x00666666,     "fog"           ,   FALSE,  TRUE  },
5201        {depth_code,             NULL,       0x00000000,     0x00cccccc,     "depth"         ,   FALSE,  TRUE  },
5202        {specular_code,          NULL,       0x004488ff,     0x004488ff,     "specular"      ,   FALSE,  FALSE }
5203     };
5204     /* Declare a monster vertex type :-) */
5205     static const D3DVERTEXELEMENT9 decl_elements[] = {
5206         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
5207         {0,  16,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT,    0},
5208         {0,  32,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES,   0},
5209         {0,  48,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,         0},
5210         {0,  64,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG,            0},
5211         {0,  80,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
5212         {0,  96,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT,        0},
5213         {0, 112,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL,       0},
5214         {0, 128,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH,          0},
5215         {0, 144,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
5216         {0, 148,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          1},
5217         D3DDECL_END()
5218     };
5219     static const D3DVERTEXELEMENT9 decl_elements2[] = {
5220         {0,   0,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,      0},
5221         {0,  16,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT,    0},
5222         {0,  32,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDINDICES,   0},
5223         {0,  48,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,         0},
5224         {0,  64,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_FOG,            0},
5225         {0,  80,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
5226         {0,  96,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TANGENT,        0},
5227         {0, 112,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BINORMAL,       0},
5228         {0, 128,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_DEPTH,          0},
5229         {0, 144,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
5230         {0, 148,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          1},
5231         D3DDECL_END()
5232     };
5233     struct hugeVertex data[4] = {
5234         {
5235             -1.0,   -1.0,   0.1,    1.0,
5236              0.1,    0.1,   0.1,    0.1,
5237              0.2,    0.2,   0.2,    0.2,
5238              0.3,    0.3,   0.3,    0.3,
5239              0.4,    0.4,   0.4,    0.4,
5240              0.50,   0.55,  0.55,   0.55,
5241              0.6,    0.6,   0.6,    0.7,
5242              0.7,    0.7,   0.7,    0.6,
5243              0.8,    0.8,   0.8,    0.8,
5244              0xe6e6e6e6, /* 0.9 * 256 */
5245              0x224488ff  /* Nothing special */
5246         },
5247         {
5248              1.0,   -1.0,   0.1,    1.0,
5249              0.1,    0.1,   0.1,    0.1,
5250              0.2,    0.2,   0.2,    0.2,
5251              0.3,    0.3,   0.3,    0.3,
5252              0.4,    0.4,   0.4,    0.4,
5253              0.50,   0.55,  0.55,   0.55,
5254              0.6,    0.6,   0.6,    0.7,
5255              0.7,    0.7,   0.7,    0.6,
5256              0.8,    0.8,   0.8,    0.8,
5257              0xe6e6e6e6, /* 0.9 * 256 */
5258              0x224488ff /* Nothing special */
5259         },
5260         {
5261             -1.0,    1.0,   0.1,    1.0,
5262              0.1,    0.1,   0.1,    0.1,
5263              0.2,    0.2,   0.2,    0.2,
5264              0.3,    0.3,   0.3,    0.3,
5265              0.4,    0.4,   0.4,    0.4,
5266              0.50,   0.55,  0.55,   0.55,
5267              0.6,    0.6,   0.6,    0.7,
5268              0.7,    0.7,   0.7,    0.6,
5269              0.8,    0.8,   0.8,    0.8,
5270              0xe6e6e6e6, /* 0.9 * 256 */
5271              0x224488ff /* Nothing special */
5272         },
5273         {
5274              1.0,    1.0,   0.1,    1.0,
5275              0.1,    0.1,   0.1,    0.1,
5276              0.2,    0.2,   0.2,    0.2,
5277              0.3,    0.3,   0.3,    0.3,
5278              0.4,    0.4,   0.4,    0.4,
5279              0.50,   0.55,  0.55,   0.55,
5280              0.6,    0.6,   0.6,    0.7,
5281              0.7,    0.7,   0.7,    0.6,
5282              0.8,    0.8,   0.8,    0.8,
5283              0xe6e6e6e6, /* 0.9 * 256 */
5284              0x224488ff /* Nothing special */
5285         },
5286     };
5287     struct hugeVertex data2[4];
5288     IDirect3DVertexDeclaration9 *decl;
5289     IDirect3DVertexDeclaration9 *decl2;
5290     HRESULT hr;
5291     unsigned int i;
5292     DWORD color, r, g, b, r_e, g_e, b_e;
5293     BOOL drawok;
5294
5295     memcpy(data2, data, sizeof(data2));
5296     data2[0].pos_x = 0;     data2[0].pos_y = 0;
5297     data2[1].pos_x = 640;   data2[1].pos_y = 0;
5298     data2[2].pos_x = 0;     data2[2].pos_y = 480;
5299     data2[3].pos_x = 640;   data2[3].pos_y = 480;
5300
5301     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &decl);
5302     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
5303     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements2, &decl2);
5304     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
5305     hr = IDirect3DDevice9_SetVertexDeclaration(device, decl);
5306     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
5307
5308     for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5309     {
5310         hr = IDirect3DDevice9_CreatePixelShader(device, tests[i].shader_code, &tests[i].shader);
5311         ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed for shader %s, hr = %08x\n",
5312            tests[i].name, hr);
5313     }
5314
5315     for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5316     {
5317         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5318         ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5319
5320         IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5321         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5322
5323         hr = IDirect3DDevice9_BeginScene(device);
5324         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5325         drawok = FALSE;
5326         if(SUCCEEDED(hr))
5327         {
5328             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data, sizeof(data[0]));
5329             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed (%08x)\n", hr);
5330             drawok = SUCCEEDED(hr);
5331             hr = IDirect3DDevice9_EndScene(device);
5332             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5333         }
5334         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5335         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5336
5337         /* Some drivers reject the combination of ps_3_0 and fixed function vertex processing. Accept
5338          * the failure and do not check the color if it failed
5339          */
5340         if(!drawok) {
5341             continue;
5342         }
5343
5344         color = getPixelColor(device, 360, 240);
5345         r = color & 0x00ff0000 >> 16;
5346         g = color & 0x0000ff00 >>  8;
5347         b = color & 0x000000ff;
5348         r_e = tests[i].color & 0x00ff0000 >> 16;
5349         g_e = tests[i].color & 0x0000ff00 >>  8;
5350         b_e = tests[i].color & 0x000000ff;
5351
5352         if(tests[i].todo) {
5353             todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5354                          "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5355                          tests[i].name, color, tests[i].color);
5356         } else {
5357             ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5358                "Test %s returned color 0x%08x, expected 0x%08x\n",
5359                tests[i].name, color, tests[i].color);
5360         }
5361     }
5362
5363     hr = IDirect3DDevice9_SetVertexDeclaration(device, decl2);
5364     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
5365     for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5366     {
5367         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5368         ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
5369
5370         IDirect3DDevice9_SetPixelShader(device, tests[i].shader);
5371         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5372
5373         hr = IDirect3DDevice9_BeginScene(device);
5374         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5375         if(SUCCEEDED(hr))
5376         {
5377             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, data2, sizeof(data2[0]));
5378             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5379             hr = IDirect3DDevice9_EndScene(device);
5380             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5381         }
5382         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5383         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5384
5385         color = getPixelColor(device, 360, 240);
5386         r = color & 0x00ff0000 >> 16;
5387         g = color & 0x0000ff00 >>  8;
5388         b = color & 0x000000ff;
5389         r_e = tests[i].color_rhw & 0x00ff0000 >> 16;
5390         g_e = tests[i].color_rhw & 0x0000ff00 >>  8;
5391         b_e = tests[i].color_rhw & 0x000000ff;
5392
5393         if(tests[i].todo_rhw) {
5394             /* This isn't a weekend's job to fix, ignore the problem for now. Needs a replacement
5395              * pipeline
5396              */
5397             todo_wine ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5398                          "Test %s returned color 0x%08x, expected 0x%08x(todo)\n",
5399                          tests[i].name, color, tests[i].color_rhw);
5400         } else {
5401             ok(abs(r - r_e) <= 1 && abs(g - g_e) <= 1 && abs(b - b_e) <= 1,
5402                "Test %s returned color 0x%08x, expected 0x%08x\n",
5403                tests[i].name, color, tests[i].color_rhw);
5404         }
5405     }
5406
5407     for(i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
5408     {
5409         IDirect3DPixelShader9_Release(tests[i].shader);
5410     }
5411
5412     IDirect3DVertexDeclaration9_Release(decl2);
5413     IDirect3DVertexDeclaration9_Release(decl);
5414 }
5415
5416 static void vshader_version_varying_test(IDirect3DDevice9 *device) {
5417     static const DWORD ps_code[] = {
5418     0xffff0300,                                                             /* ps_3_0                       */
5419     0x05000030, 0xf00f0000, 0x00000003, 0x00000003, 0x00000001, 0x00000000, /* defi i0, 3, 3, 1, 0          */
5420     0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0   */
5421     0x0200001f, 0x8001000a, 0x900f0003,                                     /* dcl_color1 v3                */
5422     0x0200001f, 0x8000000b, 0x900f0004,                                     /* dcl_fog v4                   */
5423     0x0200001f, 0x80030005, 0x900f0005,                                     /* dcl_texcoord3 v5             */
5424     0x0200001f, 0x80000003, 0x900f0006,                                     /* dcl_normal v6                */
5425     0x0200001f, 0x80000006, 0x900f0007,                                     /* dcl_tangent v7               */
5426     0x0200001f, 0x80000001, 0x900f0008,                                     /* dcl_blendweight v8           */
5427     0x0200001f, 0x8000000c, 0x900f0009,                                     /* dcl_depth v9                 */
5428
5429     0x02000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                   */
5430     0x0200001b, 0xf0e40800, 0xf0e40000,                                     /* loop aL, i0                  */
5431     0x04000002, 0x800f0000, 0x80e40000, 0x90e42000, 0xf0e40800,             /* add r0, r0, v0[aL]           */
5432     0x0000001d,                                                             /* endloop                      */
5433     0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                  */
5434     0x0000ffff                                                              /* end                          */
5435     };
5436     static const DWORD vs_1_code[] = {
5437     0xfffe0101,                                                             /* vs_1_1                       */
5438     0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
5439     0x00000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0   */
5440     0x00000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0   */
5441     0x00000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0   */
5442     0x00000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0   */
5443     0x00000001, 0xd00f0000, 0xa0e40002,                                     /* mov oD0, c2                  */
5444     0x00000001, 0xd00f0001, 0xa0e40000,                                     /* mov oD1, c0                  */
5445     0x00000001, 0xc00f0001, 0xa0550001,                                     /* mov oFog, c1.g               */
5446     0x00000001, 0xe00f0000, 0xa0e40003,                                     /* mov oT0, c3                  */
5447     0x00000001, 0xe00f0001, 0xa0e40003,                                     /* mov oT1, c3                  */
5448     0x00000001, 0xe00f0002, 0xa0e40003,                                     /* mov oT2, c3                  */
5449     0x00000001, 0xe00f0003, 0xa0e40002,                                     /* mov oT3, c2                  */
5450     0x00000001, 0xe00f0004, 0xa0e40003,                                     /* mov oT4, c3                  */
5451     0x00000001, 0xe00f0005, 0xa0e40003,                                     /* mov oT5, c3                  */
5452     0x00000001, 0xe00f0006, 0xa0e40003,                                     /* mov oT6, c3                  */
5453     0x00000001, 0xe00f0007, 0xa0e40003,                                     /* mov oT7, c3                  */
5454     0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
5455     0x0000ffff
5456     };
5457     DWORD vs_2_code[] = {
5458     0xfffe0200,                                                             /* vs_2_0                       */
5459     0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
5460     0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0   */
5461     0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0   */
5462     0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0   */
5463     0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0   */
5464     0x02000001, 0xd00f0000, 0xa0e40002,                                     /* mov oD0, c2                  */
5465     0x02000001, 0xd00f0001, 0xa0e40000,                                     /* mov oD1, c0                  */
5466     0x02000001, 0xc00f0001, 0xa0550001,                                     /* mov oFog, c1.g               */
5467     0x02000001, 0xe00f0000, 0xa0e40003,                                     /* mov oT0, c3                  */
5468     0x02000001, 0xe00f0001, 0xa0e40003,                                     /* mov oT1, c3                  */
5469     0x02000001, 0xe00f0002, 0xa0e40003,                                     /* mov oT2, c3                  */
5470     0x02000001, 0xe00f0003, 0xa0e40002,                                     /* mov oT3, c2                  */
5471     0x02000001, 0xe00f0004, 0xa0e40003,                                     /* mov oT4, c3                  */
5472     0x02000001, 0xe00f0005, 0xa0e40003,                                     /* mov oT5, c3                  */
5473     0x02000001, 0xe00f0006, 0xa0e40003,                                     /* mov oT6, c3                  */
5474     0x02000001, 0xe00f0007, 0xa0e40003,                                     /* mov oT7, c3                  */
5475     0x02000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
5476     0x0000ffff                                                              /* end                          */
5477     };
5478     /* TODO: Define normal, tangent, blendweight and depth here */
5479     static const DWORD vs_3_code[] = {
5480     0xfffe0300,                                                             /* vs_3_0                       */
5481     0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
5482     0x0200001f, 0x8001000a, 0xe00f0009,                                     /* dcl_color1 o9                */
5483     0x0200001f, 0x8000000b, 0xe00f0002,                                     /* dcl_fog o2                   */
5484     0x0200001f, 0x80030005, 0xe00f0005,                                     /* dcl_texcoord3 o5             */
5485     0x0200001f, 0x80000000, 0xe00f000b,                                     /* dcl_position o11             */
5486     0x05000051, 0xa00f0000, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.1, 0.0, 0.0, 0.0   */
5487     0x05000051, 0xa00f0001, 0x00000000, 0x3e4ccccd, 0x00000000, 0x00000000, /* def c1, 0.0, 0.2, 0.0, 0.0   */
5488     0x05000051, 0xa00f0002, 0x00000000, 0x00000000, 0x3ecccccd, 0x00000000, /* def c2, 0.0, 0.0, 0.4, 0.0   */
5489     0x05000051, 0xa00f0003, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c3, 1.0, 1.0, 1.0, 1.0   */
5490     0x02000001, 0xe00f0009, 0xa0e40000,                                     /* mov o9, c0                   */
5491     0x02000001, 0xe00f0002, 0xa0e40001,                                     /* mov o2, c1                   */
5492     0x02000001, 0xe00f0005, 0xa0e40002,                                     /* mov o5, c2                   */
5493     0x02000001, 0xe00f000b, 0x90e40000,                                     /* mov o11, v0                  */
5494     0x0000ffff                                                              /* end                          */
5495     };
5496     float quad1[] =  {
5497         -1.0,   -1.0,   0.1,
5498          0.0,   -1.0,   0.1,
5499         -1.0,    0.0,   0.1,
5500          0.0,    0.0,   0.1
5501     };
5502     float quad2[] =  {
5503          0.0,   -1.0,   0.1,
5504          1.0,   -1.0,   0.1,
5505          0.0,    0.0,   0.1,
5506          1.0,    0.0,   0.1
5507     };
5508     float quad3[] =  {
5509         -1.0,    0.0,   0.1,
5510          0.0,    0.0,   0.1,
5511         -1.0,    1.0,   0.1,
5512          0.0,    1.0,   0.1
5513     };
5514
5515     HRESULT hr;
5516     DWORD color;
5517     IDirect3DPixelShader9 *pixelshader = NULL;
5518     IDirect3DVertexShader9 *vs_1_shader = NULL;
5519     IDirect3DVertexShader9 *vs_2_shader = NULL;
5520     IDirect3DVertexShader9 *vs_3_shader = NULL;
5521
5522     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff110000, 0.0, 0);
5523
5524     hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &pixelshader);
5525     ok(hr == D3D_OK, "IDirect3DDevice_CreatePixelShader returned %08x\n", hr);
5526     hr = IDirect3DDevice9_CreateVertexShader(device, vs_1_code, &vs_1_shader);
5527     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5528     hr = IDirect3DDevice9_CreateVertexShader(device, vs_2_code, &vs_2_shader);
5529     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5530     hr = IDirect3DDevice9_CreateVertexShader(device, vs_3_code, &vs_3_shader);
5531     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5532     hr = IDirect3DDevice9_SetPixelShader(device, pixelshader);
5533     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5534     IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5535
5536     hr = IDirect3DDevice9_BeginScene(device);
5537     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5538     if(SUCCEEDED(hr))
5539     {
5540         hr = IDirect3DDevice9_SetVertexShader(device, vs_1_shader);
5541         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5542         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5543         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5544
5545         hr = IDirect3DDevice9_SetVertexShader(device, vs_2_shader);
5546         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5547         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,  quad2, sizeof(float) * 3);
5548         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5549
5550         hr = IDirect3DDevice9_SetVertexShader(device, vs_3_shader);
5551         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5552         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5553         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5554
5555         hr = IDirect3DDevice9_EndScene(device);
5556         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5557     }
5558     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5559     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5560
5561     color = getPixelColor(device, 160, 120);
5562     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x1a, 0x34, 0x67), 1),
5563        "vs_3_0 returned color 0x%08x, expected 0x00193366\n", color);
5564     color = getPixelColor(device, 160, 360);
5565     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x4d, 0x00, 0x67), 1),
5566        "vs_1_1 returned color 0x%08x, expected 0x004c0066\n", color);
5567     color = getPixelColor(device, 480, 360);
5568     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x4d, 0x00, 0x67), 1),
5569        "vs_2_0 returned color 0x%08x, expected 0x004c0066\n", color);
5570
5571     /* cleanup */
5572     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5573     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5574     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5575     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5576     if(pixelshader) IDirect3DPixelShader9_Release(pixelshader);
5577     if(vs_1_shader) IDirect3DVertexShader9_Release(vs_1_shader);
5578     if(vs_2_shader) IDirect3DVertexShader9_Release(vs_2_shader);
5579     if(vs_3_shader) IDirect3DVertexShader9_Release(vs_3_shader);
5580 }
5581
5582 static void pshader_version_varying_test(IDirect3DDevice9 *device) {
5583     static const DWORD vs_code[] = {
5584     0xfffe0300,                                                             /* vs_3_0                       */
5585     0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
5586     0x0200001f, 0x80000000, 0xe00f0000,                                     /* dcl_position o0              */
5587     0x0200001f, 0x8000000a, 0xe00f0001,                                     /* dcl_color0 o1                */
5588     0x0200001f, 0x80000005, 0xe00f0002,                                     /* dcl_texcoord0 o2             */
5589     0x0200001f, 0x8000000b, 0xe00f0003,                                     /* dcl_fog o3                   */
5590     0x0200001f, 0x80000003, 0xe00f0004,                                     /* dcl_normal o4                */
5591     0x0200001f, 0x8000000c, 0xe00f0005,                                     /* dcl_depth o5                 */
5592     0x0200001f, 0x80000006, 0xe00f0006,                                     /* dcl_tangent o6               */
5593     0x0200001f, 0x80000001, 0xe00f0007,                                     /* dcl_blendweight o7           */
5594     0x05000051, 0xa00f0001, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, /* def c1, 0.1, 0.0, 0.0, 0.0   */
5595     0x05000051, 0xa00f0002, 0x00000000, 0x3e4ccccd, 0x00000000, 0x3f800000, /* def c2, 0.0, 0.2, 0.0, 1.0   */
5596     0x05000051, 0xa00f0003, 0x3ecccccd, 0x3f59999a, 0x3f666666, 0x00000000, /* def c3, 0.4, 0.85,0.9, 0.0   */
5597     0x05000051, 0xa00f0000, 0x3f800000, 0x3f800000, 0x3f800000, 0x3f800000, /* def c0, 1.0, 1.0, 1.0, 1.0   */
5598
5599     0x02000001, 0xe00f0000, 0x90e40000,                                     /* mov o0, v0                   */
5600     0x02000001, 0xe00f0001, 0xa0e40001,                                     /* mov o1, c1                   */
5601     0x02000001, 0xe00f0002, 0xa0e40002,                                     /* mov o2, c2                   */
5602     0x02000001, 0xe00f0003, 0xa0e40003,                                     /* mov o3, c3                   */
5603     0x02000001, 0xe00f0004, 0xa0e40000,                                     /* mov o4, c0                   */
5604     0x02000001, 0xe00f0005, 0xa0e40000,                                     /* mov o5, c0                   */
5605     0x02000001, 0xe00f0006, 0xa0e40000,                                     /* mov o6, c0                   */
5606     0x02000001, 0xe00f0007, 0xa0e40000,                                     /* mov o7, c0                   */
5607     0x0000ffff                                                              /* end                          */
5608     };
5609     static const DWORD ps_1_code[] = {
5610     0xffff0104,                                                             /* ps_1_4                       */
5611     0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0   */
5612     0x00000040, 0x80070001, 0xb0e40000,                                     /* texcrd r1.xyz, t0            */
5613     0x00000001, 0x80080001, 0xa0ff0000,                                     /* mov r1.a, c0.a               */
5614     0x00000002, 0x800f0000, 0x90e40000, 0x80e40001,                         /* add r0, v0, r1               */
5615     0x0000ffff                                                              /* end                          */
5616     };
5617     static const DWORD ps_2_code[] = {
5618     0xffff0200,                                                             /* ps_2_0                       */
5619     0x0200001f, 0x80000000, 0xb00f0000,                                     /* dcl t0                       */
5620     0x0200001f, 0x80000000, 0x900f0000,                                     /* dcl v0                       */
5621     0x0200001f, 0x80000000, 0x900f0001,                                     /* dcl v1                       */
5622
5623     0x02000001, 0x800f0000, 0x90e40000,                                     /* mov r0, v0                   */
5624     0x03000002, 0x800f0000, 0x80e40000,0xb0e40000,                          /* add r0, r0, t0               */
5625     0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                  */
5626     0x0000ffff                                                              /* end                          */
5627     };
5628     static const DWORD ps_3_code[] = {
5629     0xffff0300,                                                             /* ps_3_0                       */
5630     0x0200001f, 0x80000005, 0x900f0000,                                     /* dcl_texcoord0 v0             */
5631     0x0200001f, 0x8000000a, 0x900f0001,                                     /* dcl_color0 v1                */
5632     0x0200001f, 0x8000000b, 0x900f0002,                                     /* dcl_fog v2                   */
5633
5634     0x02000001, 0x800f0000, 0x90e40000,                                     /* mov r0, v0                   */
5635     0x03000002, 0x800f0000, 0x80e40000, 0x90e40001,                         /* add r0, r0, v1               */
5636     0x03000002, 0x800f0000, 0x80e40000, 0x90e40002,                         /* mov r0, r0, v2               */
5637     0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                  */
5638     0x0000ffff                                                              /* end                          */
5639     };
5640
5641     float quad1[] =  {
5642         -1.0,   -1.0,   0.1,
5643          0.0,   -1.0,   0.1,
5644         -1.0,    0.0,   0.1,
5645          0.0,    0.0,   0.1
5646     };
5647     float quad2[] =  {
5648          0.0,   -1.0,   0.1,
5649          1.0,   -1.0,   0.1,
5650          0.0,    0.0,   0.1,
5651          1.0,    0.0,   0.1
5652     };
5653     float quad3[] =  {
5654         -1.0,    0.0,   0.1,
5655          0.0,    0.0,   0.1,
5656         -1.0,    1.0,   0.1,
5657          0.0,    1.0,   0.1
5658     };
5659     float quad4[] =  {
5660          0.0,    0.0,   0.1,
5661          1.0,    0.0,   0.1,
5662          0.0,    1.0,   0.1,
5663          1.0,    1.0,   0.1
5664     };
5665
5666     HRESULT hr;
5667     DWORD color;
5668     IDirect3DVertexShader9 *vertexshader = NULL;
5669     IDirect3DPixelShader9 *ps_1_shader = NULL;
5670     IDirect3DPixelShader9 *ps_2_shader = NULL;
5671     IDirect3DPixelShader9 *ps_3_shader = NULL;
5672     IDirect3DTexture9 *texture = NULL;
5673     D3DLOCKED_RECT lr;
5674     unsigned int x, y;
5675
5676     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
5677
5678     hr = IDirect3DDevice9_CreateTexture(device, 512,  512, 1, 0, D3DFMT_A16B16G16R16, D3DPOOL_MANAGED, &texture, NULL);
5679     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr);
5680     if(FAILED(hr)) {
5681         skip("D3DFMT_A16B16G16R16 textures not supported\n");
5682         return;
5683     }
5684     hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
5685     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect returned %08x\n", hr);
5686     for(y = 0; y < 512; y++) {
5687         for(x = 0; x < 512; x++) {
5688             double r_f = (double) x / (double) 512;
5689             double g_f = (double) y / (double) 512;
5690             unsigned short *dst = (unsigned short *) (((unsigned char *) lr.pBits) + y * lr.Pitch + x * 8);
5691             unsigned short r = (unsigned short) (r_f * 65535.0);
5692             unsigned short g = (unsigned short) (g_f * 65535.0);
5693             dst[0] = r;
5694             dst[1] = g;
5695             dst[2] = 0;
5696             dst[3] = 65535;
5697         }
5698     }
5699     hr = IDirect3DTexture9_UnlockRect(texture, 0);
5700     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect returned %08x\n", hr);
5701
5702     hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vertexshader);
5703     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5704     hr = IDirect3DDevice9_CreatePixelShader(device, ps_1_code, &ps_1_shader);
5705     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5706     hr = IDirect3DDevice9_CreatePixelShader(device, ps_2_code, &ps_2_shader);
5707     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5708     hr = IDirect3DDevice9_CreatePixelShader(device, ps_3_code, &ps_3_shader);
5709     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
5710     hr = IDirect3DDevice9_SetVertexShader(device, vertexshader);
5711     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5712     IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5713
5714     hr = IDirect3DDevice9_BeginScene(device);
5715     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5716     if(SUCCEEDED(hr))
5717     {
5718         hr = IDirect3DDevice9_SetPixelShader(device, ps_1_shader);
5719         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5720         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5721         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5722
5723         hr = IDirect3DDevice9_SetPixelShader(device, ps_2_shader);
5724         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5725         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,  quad2, sizeof(float) * 3);
5726         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5727
5728         hr = IDirect3DDevice9_SetPixelShader(device, ps_3_shader);
5729         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5730         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5731         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5732
5733         hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5734         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5735         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
5736         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
5737         hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
5738         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
5739         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
5740         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
5741         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5742         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5743
5744         hr = IDirect3DDevice9_EndScene(device);
5745         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5746     }
5747     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5748     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5749
5750     color = getPixelColor(device, 160, 120);
5751     ok((color & 0x00ff0000) >= 0x00790000 && (color & 0x00ff0000) <= 0x00810000 &&
5752        (color & 0x0000ff00) == 0x0000ff00 &&
5753        (color & 0x000000ff) >= 0x000000e4 && (color & 0x000000ff) <= 0x000000e6,
5754        "ps_3_0 returned color 0x%08x, expected 0x0080ffe5\n", color);
5755     color = getPixelColor(device, 160, 360);
5756     ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5757        (color & 0x0000ff00) >= 0x00003300 && (color & 0x0000ff00) <= 0x00003400 &&
5758        (color & 0x000000ff) == 0x00000000,
5759        "ps_1_4 returned color 0x%08x, expected 0x00203300\n", color);
5760     color = getPixelColor(device, 480, 360);
5761     ok((color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5762        (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5763        (color & 0x000000ff) == 0x00000000,
5764        "ps_2_0 returned color 0x%08x, expected 0x00203300\n", color);
5765     color = getPixelColor(device, 480, 160);
5766     ok( color == 0x00ffffff /* Nvidia driver garbage with HW vp */ || (
5767        (color & 0x00ff0000) >= 0x00190000 && (color & 0x00ff0000) <= 0x00210000 &&
5768        (color & 0x0000ff00) >= 0x00003200 && (color & 0x0000ff00) <= 0x00003400 &&
5769        (color & 0x000000ff) == 0x00000000),
5770        "fixed function fragment processing returned color 0x%08x, expected 0x00203300\n", color);
5771
5772     /* cleanup */
5773     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
5774     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr);
5775     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
5776     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
5777     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5778     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5779     if(vertexshader) IDirect3DVertexShader9_Release(vertexshader);
5780     if(ps_1_shader) IDirect3DPixelShader9_Release(ps_1_shader);
5781     if(ps_2_shader) IDirect3DPixelShader9_Release(ps_2_shader);
5782     if(ps_3_shader) IDirect3DPixelShader9_Release(ps_3_shader);
5783     if(texture) IDirect3DTexture9_Release(texture);
5784 }
5785
5786 static void test_compare_instructions(IDirect3DDevice9 *device)
5787 {
5788     DWORD shader_sge_vec_code[] = {
5789         0xfffe0101,                                         /* vs_1_1                   */
5790         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0          */
5791         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0             */
5792         0x00000001, 0x800f0000, 0xa0e40000,                 /* mov r0, c0               */
5793         0x0000000d, 0xd00f0000, 0x80e40000, 0xa0e40001,     /* sge oD0, r0, c1          */
5794         0x0000ffff                                          /* end                      */
5795     };
5796     DWORD shader_slt_vec_code[] = {
5797         0xfffe0101,                                         /* vs_1_1                   */
5798         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0          */
5799         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0             */
5800         0x00000001, 0x800f0000, 0xa0e40000,                 /* mov r0, c0               */
5801         0x0000000c, 0xd00f0000, 0x80e40000, 0xa0e40001,     /* slt oD0, r0, c1          */
5802         0x0000ffff                                          /* end                      */
5803     };
5804     DWORD shader_sge_scalar_code[] = {
5805         0xfffe0101,                                         /* vs_1_1                   */
5806         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0          */
5807         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0             */
5808         0x00000001, 0x800f0000, 0xa0e40000,                 /* mov r0, c0               */
5809         0x0000000d, 0xd0010000, 0x80000000, 0xa0550001,     /* slt oD0.r, r0.r, c1.b    */
5810         0x0000000d, 0xd0020000, 0x80550000, 0xa0aa0001,     /* slt oD0.g, r0.g, c1.r    */
5811         0x0000000d, 0xd0040000, 0x80aa0000, 0xa0000001,     /* slt oD0.b, r0.b, c1.g    */
5812         0x0000ffff                                          /* end                      */
5813     };
5814     DWORD shader_slt_scalar_code[] = {
5815         0xfffe0101,                                         /* vs_1_1                   */
5816         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0          */
5817         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0             */
5818         0x00000001, 0x800f0000, 0xa0e40000,                 /* mov r0, c0               */
5819         0x0000000c, 0xd0010000, 0x80000000, 0xa0aa0001,     /* slt oD0.r, r0.r, c1.b    */
5820         0x0000000c, 0xd0020000, 0x80550000, 0xa0000001,     /* slt oD0.g, r0.g, c1.r    */
5821         0x0000000c, 0xd0040000, 0x80aa0000, 0xa0550001,     /* slt oD0.b, r0.b, c1.g    */
5822         0x0000ffff                                          /* end                      */
5823     };
5824     IDirect3DVertexShader9 *shader_sge_vec;
5825     IDirect3DVertexShader9 *shader_slt_vec;
5826     IDirect3DVertexShader9 *shader_sge_scalar;
5827     IDirect3DVertexShader9 *shader_slt_scalar;
5828     HRESULT hr, color;
5829     float quad1[] =  {
5830         -1.0,   -1.0,   0.1,
5831          0.0,   -1.0,   0.1,
5832         -1.0,    0.0,   0.1,
5833          0.0,    0.0,   0.1
5834     };
5835     float quad2[] =  {
5836          0.0,   -1.0,   0.1,
5837          1.0,   -1.0,   0.1,
5838          0.0,    0.0,   0.1,
5839          1.0,    0.0,   0.1
5840     };
5841     float quad3[] =  {
5842         -1.0,    0.0,   0.1,
5843          0.0,    0.0,   0.1,
5844         -1.0,    1.0,   0.1,
5845          0.0,    1.0,   0.1
5846     };
5847     float quad4[] =  {
5848          0.0,    0.0,   0.1,
5849          1.0,    0.0,   0.1,
5850          0.0,    1.0,   0.1,
5851          1.0,    1.0,   0.1
5852     };
5853     const float const0[4] = {0.8, 0.2, 0.2, 0.2};
5854     const float const1[4] = {0.2, 0.8, 0.2, 0.2};
5855
5856     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
5857
5858     hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_vec_code, &shader_sge_vec);
5859     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5860     hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_vec_code, &shader_slt_vec);
5861     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5862     hr = IDirect3DDevice9_CreateVertexShader(device, shader_sge_scalar_code, &shader_sge_scalar);
5863     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5864     hr = IDirect3DDevice9_CreateVertexShader(device, shader_slt_scalar_code, &shader_slt_scalar);
5865     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
5866     hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5867     ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5868     hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 1, const1, 1);
5869     ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5870     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
5871     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetFVF failed (%08x)\n", hr);
5872
5873     hr = IDirect3DDevice9_BeginScene(device);
5874     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
5875     if(SUCCEEDED(hr))
5876     {
5877         hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_vec);
5878         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5879         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 3);
5880         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5881
5882         hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_vec);
5883         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5884         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,  quad2, sizeof(float) * 3);
5885         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5886
5887         hr = IDirect3DDevice9_SetVertexShader(device, shader_sge_scalar);
5888         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5889         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 3);
5890         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5891
5892         hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, const0, 1);
5893         ok(SUCCEEDED(hr), "SetVertexShaderConstantF failed (%08x)\n", hr);
5894
5895         hr = IDirect3DDevice9_SetVertexShader(device, shader_slt_scalar);
5896         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5897         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 3);
5898         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
5899
5900         hr = IDirect3DDevice9_EndScene(device);
5901         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
5902     }
5903
5904     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
5905     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
5906     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
5907     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
5908
5909     color = getPixelColor(device, 160, 360);
5910     ok(color == 0x00FF00FF, "Compare test: Quad 1(sge vec) returned color 0x%08x, expected 0x00FF00FF\n", color);
5911     color = getPixelColor(device, 480, 360);
5912     ok(color == 0x0000FF00, "Compare test: Quad 2(slt vec) returned color 0x%08x, expected 0x0000FF00\n", color);
5913     color = getPixelColor(device, 160, 120);
5914     ok(color == 0x00FFFFFF, "Compare test: Quad 3(sge scalar) returned color 0x%08x, expected 0x00FFFFFF\n", color);
5915     color = getPixelColor(device, 480, 160);
5916     ok(color == 0x000000ff, "Compare test: Quad 4(slt scalar) returned color 0x%08x, expected 0x000000ff\n", color);
5917
5918     IDirect3DVertexShader9_Release(shader_sge_vec);
5919     IDirect3DVertexShader9_Release(shader_slt_vec);
5920     IDirect3DVertexShader9_Release(shader_sge_scalar);
5921     IDirect3DVertexShader9_Release(shader_slt_scalar);
5922 }
5923
5924 static void test_vshader_input(IDirect3DDevice9 *device)
5925 {
5926     DWORD swapped_shader_code_3[] = {
5927         0xfffe0300,                                         /* vs_3_0               */
5928         0x0200001f, 0x80000000, 0xe00f0000,                 /* dcl_position o0      */
5929         0x0200001f, 0x8000000a, 0xe00f0001,                 /* dcl_color o1         */
5930         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5931         0x0200001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord0 v1     */
5932         0x0200001f, 0x80010005, 0x900f0002,                 /* dcl_texcoord1 v2     */
5933         0x02000001, 0xe00f0000, 0x90e40000,                 /* mov o0, v0           */
5934         0x02000001, 0x800f0001, 0x90e40001,                 /* mov r1, v1           */
5935         0x03000002, 0xe00f0001, 0x80e40001, 0x91e40002,     /* sub o1, r1, v2       */
5936         0x0000ffff                                          /* end                  */
5937     };
5938     DWORD swapped_shader_code_1[] = {
5939         0xfffe0101,                                         /* vs_1_1               */
5940         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5941         0x0000001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord0 v1     */
5942         0x0000001f, 0x80010005, 0x900f0002,                 /* dcl_texcoord1 v2     */
5943         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov o0, v0           */
5944         0x00000001, 0x800f0001, 0x90e40001,                 /* mov r1, v1           */
5945         0x00000002, 0xd00f0000, 0x80e40001, 0x91e40002,     /* sub o1, r1, v2       */
5946         0x0000ffff                                          /* end                  */
5947     };
5948     DWORD swapped_shader_code_2[] = {
5949         0xfffe0200,                                         /* vs_2_0               */
5950         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5951         0x0200001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord0 v1     */
5952         0x0200001f, 0x80010005, 0x900f0002,                 /* dcl_texcoord1 v2     */
5953         0x02000001, 0xc00f0000, 0x90e40000,                 /* mov o0, v0           */
5954         0x02000001, 0x800f0001, 0x90e40001,                 /* mov r1, v1           */
5955         0x03000002, 0xd00f0000, 0x80e40001, 0x91e40002,     /* sub o1, r1, v2       */
5956         0x0000ffff                                          /* end                  */
5957     };
5958     DWORD texcoord_color_shader_code_3[] = {
5959         0xfffe0300,                                         /* vs_3_0               */
5960         0x0200001f, 0x80000000, 0xe00f0000,                 /* dcl_position o0      */
5961         0x0200001f, 0x8000000a, 0xe00f0001,                 /* dcl_color o1         */
5962         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5963         0x0200001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord v1      */
5964         0x02000001, 0xe00f0000, 0x90e40000,                 /* mov o0, v0           */
5965         0x02000001, 0xe00f0001, 0x90e40001,                 /* mov o1, v1           */
5966         0x0000ffff                                          /* end                  */
5967     };
5968     DWORD texcoord_color_shader_code_2[] = {
5969         0xfffe0200,                                         /* vs_2_0               */
5970         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5971         0x0200001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord v1      */
5972         0x02000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0         */
5973         0x02000001, 0xd00f0000, 0x90e40001,                 /* mov oD0, v1          */
5974         0x0000ffff                                          /* end                  */
5975     };
5976     DWORD texcoord_color_shader_code_1[] = {
5977         0xfffe0101,                                         /* vs_1_1               */
5978         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5979         0x0000001f, 0x80000005, 0x900f0001,                 /* dcl_texcoord v1      */
5980         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0         */
5981         0x00000001, 0xd00f0000, 0x90e40001,                 /* mov oD0, v1          */
5982         0x0000ffff                                          /* end                  */
5983     };
5984     DWORD color_color_shader_code_3[] = {
5985         0xfffe0300,                                         /* vs_3_0               */
5986         0x0200001f, 0x80000000, 0xe00f0000,                 /* dcl_position o0      */
5987         0x0200001f, 0x8000000a, 0xe00f0001,                 /* dcl_color o1         */
5988         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5989         0x0200001f, 0x8000000a, 0x900f0001,                 /* dcl_color v1         */
5990         0x02000001, 0xe00f0000, 0x90e40000,                 /* mov o0, v0           */
5991         0x03000005, 0xe00f0001, 0xa0e40000, 0x90e40001,     /* mul o1, c0, v1       */
5992         0x0000ffff                                          /* end                  */
5993     };
5994     DWORD color_color_shader_code_2[] = {
5995         0xfffe0200,                                         /* vs_2_0               */
5996         0x0200001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
5997         0x0200001f, 0x8000000a, 0x900f0001,                 /* dcl_color v1         */
5998         0x02000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0         */
5999         0x03000005, 0xd00f0000, 0xa0e40000, 0x90e40001,     /* mul oD0, c0, v1       */
6000         0x0000ffff                                          /* end                  */
6001     };
6002     DWORD color_color_shader_code_1[] = {
6003         0xfffe0101,                                         /* vs_1_1               */
6004         0x0000001f, 0x80000000, 0x900f0000,                 /* dcl_position v0      */
6005         0x0000001f, 0x8000000a, 0x900f0001,                 /* dcl_color v1         */
6006         0x00000001, 0xc00f0000, 0x90e40000,                 /* mov oPos, v0         */
6007         0x00000005, 0xd00f0000, 0xa0e40000, 0x90e40001,     /* mul oD0, c0, v1       */
6008         0x0000ffff                                          /* end                  */
6009     };
6010     IDirect3DVertexShader9 *swapped_shader, *texcoord_color_shader, *color_color_shader;
6011     HRESULT hr;
6012     DWORD color;
6013     float quad1[] =  {
6014         -1.0,   -1.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6015          0.0,   -1.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6016         -1.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6017          0.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6018     };
6019     float quad2[] =  {
6020          0.0,   -1.0,   0.1,    1.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6021          1.0,   -1.0,   0.1,    1.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6022          0.0,    0.0,   0.1,    1.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6023          1.0,    0.0,   0.1,    1.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6024     };
6025     float quad3[] =  {
6026         -1.0,    0.0,   0.1,   -1.0,    0.0,    0.0,    0.0,    1.0,    -1.0,   0.0,    0.0,
6027          0.0,    0.0,   0.1,   -1.0,    0.0,    0.0,    0.0,    1.0,     0.0,   0.0,    0.0,
6028         -1.0,    1.0,   0.1,   -1.0,    0.0,    0.0,    0.0,    0.0,    -1.0,   1.0,    0.0,
6029          0.0,    1.0,   0.1,   -1.0,    0.0,    0.0,    0.0,   -1.0,     0.0,   0.0,    0.0,
6030     };
6031     float quad4[] =  {
6032          0.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6033          1.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6034          0.0,    1.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6035          1.0,    1.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.5,    0.0,
6036     };
6037     static const D3DVERTEXELEMENT9 decl_elements_twotexcrd[] = {
6038         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6039         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
6040         {0,  28,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       1},
6041         D3DDECL_END()
6042     };
6043     static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_rightorder[] = {
6044         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6045         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       1},
6046         {0,  28,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
6047         D3DDECL_END()
6048     };
6049     static const D3DVERTEXELEMENT9 decl_elements_onetexcrd[] = {
6050         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6051         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
6052         D3DDECL_END()
6053     };
6054     static const D3DVERTEXELEMENT9 decl_elements_twotexcrd_wrongidx[] = {
6055         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6056         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       1},
6057         {0,  28,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       2},
6058         D3DDECL_END()
6059     };
6060     static const D3DVERTEXELEMENT9 decl_elements_texcoord_color[] = {
6061         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6062         {0,  12,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD,       0},
6063         D3DDECL_END()
6064     };
6065     static const D3DVERTEXELEMENT9 decl_elements_color_color[] = {
6066         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6067         {0,  12,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6068         D3DDECL_END()
6069     };
6070     static const D3DVERTEXELEMENT9 decl_elements_color_ubyte[] = {
6071         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6072         {0,  12,  D3DDECLTYPE_UBYTE4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6073         D3DDECL_END()
6074     };
6075     static const D3DVERTEXELEMENT9 decl_elements_color_float[] = {
6076         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6077         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6078         D3DDECL_END()
6079     };
6080     IDirect3DVertexDeclaration9 *decl_twotexcrd, *decl_onetexcrd, *decl_twotex_wrongidx, *decl_twotexcrd_rightorder;
6081     IDirect3DVertexDeclaration9 *decl_texcoord_color, *decl_color_color, *decl_color_ubyte, *decl_color_float;
6082     unsigned int i;
6083     float normalize[4] = {1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0};
6084     float no_normalize[4] = {1.0, 1.0, 1.0, 1.0};
6085
6086     struct vertex quad1_color[] =  {
6087        {-1.0,   -1.0,   0.1,    0x00ff8040},
6088        { 0.0,   -1.0,   0.1,    0x00ff8040},
6089        {-1.0,    0.0,   0.1,    0x00ff8040},
6090        { 0.0,    0.0,   0.1,    0x00ff8040}
6091     };
6092     struct vertex quad2_color[] =  {
6093        { 0.0,   -1.0,   0.1,    0x00ff8040},
6094        { 1.0,   -1.0,   0.1,    0x00ff8040},
6095        { 0.0,    0.0,   0.1,    0x00ff8040},
6096        { 1.0,    0.0,   0.1,    0x00ff8040}
6097     };
6098     struct vertex quad3_color[] =  {
6099        {-1.0,    0.0,   0.1,    0x00ff8040},
6100        { 0.0,    0.0,   0.1,    0x00ff8040},
6101        {-1.0,    1.0,   0.1,    0x00ff8040},
6102        { 0.0,    1.0,   0.1,    0x00ff8040}
6103     };
6104     float quad4_color[] =  {
6105          0.0,    0.0,   0.1,    1.0,    1.0,    0.0,    0.0,
6106          1.0,    0.0,   0.1,    1.0,    1.0,    0.0,    1.0,
6107          0.0,    1.0,   0.1,    1.0,    1.0,    0.0,    0.0,
6108          1.0,    1.0,   0.1,    1.0,    1.0,    0.0,    1.0,
6109     };
6110
6111     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd, &decl_twotexcrd);
6112     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6113     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_onetexcrd, &decl_onetexcrd);
6114     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6115     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_wrongidx, &decl_twotex_wrongidx);
6116     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6117     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_twotexcrd_rightorder, &decl_twotexcrd_rightorder);
6118     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6119
6120     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_texcoord_color, &decl_texcoord_color);
6121     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6122     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_color, &decl_color_color);
6123     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6124     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_ubyte, &decl_color_ubyte);
6125     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6126     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_color_float, &decl_color_float);
6127     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexDeclaration returned %08x\n", hr);
6128
6129     for(i = 1; i <= 3; i++) {
6130         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
6131         if(i == 3) {
6132             hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_3, &swapped_shader);
6133             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6134         } else if(i == 2){
6135             hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_2, &swapped_shader);
6136             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6137         } else if(i == 1) {
6138             hr = IDirect3DDevice9_CreateVertexShader(device, swapped_shader_code_1, &swapped_shader);
6139             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6140         }
6141
6142         hr = IDirect3DDevice9_BeginScene(device);
6143         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6144         if(SUCCEEDED(hr))
6145         {
6146             hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6147             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6148
6149             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6150             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6151             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(float) * 11);
6152             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6153
6154             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6155             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6156             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(float) * 11);
6157             if(i == 3 || i == 2) {
6158                 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6159             } else if(i == 1) {
6160                 /* Succeeds or fails, depending on SW or HW vertex processing */
6161                 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6162             }
6163
6164             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd_rightorder);
6165             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6166             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(float) * 11);
6167             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6168
6169             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotex_wrongidx);
6170             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6171             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(float) * 11);
6172             if(i == 3 || i == 2) {
6173                 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6174             } else if(i == 1) {
6175                 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = 1\n", hr);
6176             }
6177
6178             hr = IDirect3DDevice9_EndScene(device);
6179             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6180         }
6181
6182         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6183         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6184
6185         if(i == 3 || i == 2) {
6186             color = getPixelColor(device, 160, 360);
6187             ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x80), 1),
6188                "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6189
6190             /* The last value of the read but undefined stream is used, it is 0x00. The defined input is vec4(1, 0, 0, 0) */
6191             color = getPixelColor(device, 480, 360);
6192             ok(color == 0x00FFFF00 || color ==0x00FF0000,
6193                "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6194             color = getPixelColor(device, 160, 120);
6195             /* Same as above, accept both the last used value and 0.0 for the undefined streams */
6196             ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x80), 1) || color == D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x00),
6197                "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6198
6199             color = getPixelColor(device, 480, 160);
6200             ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6201         } else if(i == 1) {
6202             color = getPixelColor(device, 160, 360);
6203             ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x80), 1),
6204                "Input test: Quad 1(2crd) returned color 0x%08x, expected 0x00FFFF80\n", color);
6205             color = getPixelColor(device, 480, 360);
6206             /* Accept the clear color as well in this case, since SW VP returns an error */
6207             ok(color == 0x00FFFF00 || color == 0x00FF0000, "Input test: Quad 2(1crd) returned color 0x%08x, expected 0x00FFFF00\n", color);
6208             color = getPixelColor(device, 160, 120);
6209             ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x80), 1) || color == D3DCOLOR_ARGB(0x00, 0xff, 0x00, 0x00),
6210                "Input test: Quad 3(2crd-wrongidx) returned color 0x%08x, expected 0x00FF0080\n", color);
6211             color = getPixelColor(device, 480, 160);
6212             ok(color == 0x00000000, "Input test: Quad 4(2crd-rightorder) returned color 0x%08x, expected 0x00000000\n", color);
6213         }
6214
6215         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff808080, 0.0, 0);
6216         ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6217
6218         /* Now find out if the whole streams are re-read, or just the last active value for the
6219          * vertices is used.
6220          */
6221         hr = IDirect3DDevice9_BeginScene(device);
6222         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6223         if(SUCCEEDED(hr))
6224         {
6225             float quad1_modified[] =  {
6226                 -1.0,   -1.0,   0.1,    1.0,    0.0,    1.0,    0.0,   -1.0,     0.0,   0.0,    0.0,
6227                  0.0,   -1.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,    -1.0,   0.0,    0.0,
6228                 -1.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,    0.0,     0.0,  -1.0,    0.0,
6229                  0.0,    0.0,   0.1,    1.0,    0.0,    1.0,    0.0,   -1.0,    -1.0,  -1.0,    0.0,
6230             };
6231             float quad2_modified[] =  {
6232                  0.0,   -1.0,   0.1,    0.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6233                  1.0,   -1.0,   0.1,    0.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6234                  0.0,    0.0,   0.1,    0.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6235                  1.0,    0.0,   0.1,    0.0,    0.0,    0.0,    0.0,    0.0,     0.0,   0.0,    0.0,
6236             };
6237
6238             hr = IDirect3DDevice9_SetVertexShader(device, swapped_shader);
6239             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6240
6241             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_twotexcrd);
6242             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6243             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 3, quad1_modified, sizeof(float) * 11);
6244             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6245
6246             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_onetexcrd);
6247             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6248             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_modified, sizeof(float) * 11);
6249             if(i == 3 || i == 2) {
6250                 ok(hr == D3D_OK, "DrawPrimitiveUP returned (%08x) i = %d\n", hr, i);
6251             } else if(i == 1) {
6252                 /* Succeeds or fails, depending on SW or HW vertex processing */
6253                 ok(hr == D3DERR_INVALIDCALL || hr == D3D_OK, "DrawPrimitiveUP returned (%08x), i = 1\n", hr);
6254             }
6255
6256             hr = IDirect3DDevice9_EndScene(device);
6257             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6258         }
6259         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6260         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6261
6262         color = getPixelColor(device, 480, 350);
6263         /* vs_1_1 may fail, accept the clear color. Some drivers also set the undefined streams to 0, accept that
6264          * as well.
6265          *
6266          * NOTE: This test fails on the reference rasterizer. In the refrast, the 4 vertices have different colors,
6267          * i.e., the whole old stream is read, and not just the last used attribute. Some games require that this
6268          * does *not* happen, otherwise they can crash because of a read from a bad pointer, so do not accept the
6269          * refrast's result.
6270          *
6271          * A test app for this behavior is Half Life 2 Episode 2 in dxlevel 95, and related games(Portal, TF2).
6272          */
6273         ok(color == 0x000000FF || color == 0x00808080 || color == 0x00000000,
6274            "Input test: Quad 2(different colors) returned color 0x%08x, expected 0x000000FF, 0x00808080 or 0x00000000\n", color);
6275         color = getPixelColor(device, 160, 120);
6276
6277         IDirect3DDevice9_SetVertexShader(device, NULL);
6278         IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6279
6280         IDirect3DVertexShader9_Release(swapped_shader);
6281     }
6282
6283     for(i = 1; i <= 3; i++) {
6284         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
6285         if(i == 3) {
6286             hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_3, &texcoord_color_shader);
6287             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6288             hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_3, &color_color_shader);
6289             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6290         } else if(i == 2){
6291             hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_2, &texcoord_color_shader);
6292             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6293             hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_2, &color_color_shader);
6294             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6295         } else if(i == 1) {
6296             hr = IDirect3DDevice9_CreateVertexShader(device, texcoord_color_shader_code_1, &texcoord_color_shader);
6297             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6298             hr = IDirect3DDevice9_CreateVertexShader(device, color_color_shader_code_1, &color_color_shader);
6299             ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6300         }
6301
6302         hr = IDirect3DDevice9_BeginScene(device);
6303         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6304         if(SUCCEEDED(hr))
6305         {
6306             hr = IDirect3DDevice9_SetVertexShader(device, texcoord_color_shader);
6307             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6308             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_texcoord_color);
6309             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6310             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1_color, sizeof(quad1_color[0]));
6311             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6312
6313             hr = IDirect3DDevice9_SetVertexShader(device, color_color_shader);
6314             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6315
6316             hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, normalize, 1);
6317             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6318             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_ubyte);
6319             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6320             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2_color, sizeof(quad2_color[0]));
6321             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6322
6323             hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, no_normalize, 1);
6324             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6325             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_color);
6326             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6327             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3_color, sizeof(quad3_color[0]));
6328             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6329
6330             hr = IDirect3DDevice9_SetVertexDeclaration(device, decl_color_float);
6331             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration returned %08x\n", hr);
6332             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4_color, sizeof(float) * 7);
6333             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6334
6335             hr = IDirect3DDevice9_EndScene(device);
6336             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6337         }
6338         IDirect3DDevice9_SetVertexShader(device, NULL);
6339         IDirect3DDevice9_SetVertexDeclaration(device, NULL);
6340
6341         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6342         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6343
6344         color = getPixelColor(device, 160, 360);
6345         ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x80, 0x40), 1),
6346            "Input test: Quad 1(color-texcoord) returned color 0x%08x, expected 0x00ff8040\n", color);
6347         color = getPixelColor(device, 480, 360);
6348         ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x40, 0x80, 0xff), 1),
6349            "Input test: Quad 2(color-ubyte) returned color 0x%08x, expected 0x004080ff\n", color);
6350         color = getPixelColor(device, 160, 120);
6351         ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0x80, 0x40), 1),
6352            "Input test: Quad 3(color-color) returned color 0x%08x, expected 0x00ff8040\n", color);
6353         color = getPixelColor(device, 480, 160);
6354         ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xff, 0xff, 0x00), 1),
6355            "Input test: Quad 4(color-float) returned color 0x%08x, expected 0x00FFFF00\n", color);
6356
6357         IDirect3DVertexShader9_Release(texcoord_color_shader);
6358         IDirect3DVertexShader9_Release(color_color_shader);
6359     }
6360
6361     IDirect3DVertexDeclaration9_Release(decl_twotexcrd);
6362     IDirect3DVertexDeclaration9_Release(decl_onetexcrd);
6363     IDirect3DVertexDeclaration9_Release(decl_twotex_wrongidx);
6364     IDirect3DVertexDeclaration9_Release(decl_twotexcrd_rightorder);
6365
6366     IDirect3DVertexDeclaration9_Release(decl_texcoord_color);
6367     IDirect3DVertexDeclaration9_Release(decl_color_color);
6368     IDirect3DVertexDeclaration9_Release(decl_color_ubyte);
6369     IDirect3DVertexDeclaration9_Release(decl_color_float);
6370 }
6371
6372 static void srgbtexture_test(IDirect3DDevice9 *device)
6373 {
6374     /* Fill a texture with 0x7f (~ .5), and then turn on the D3DSAMP_SRGBTEXTURE
6375      * texture stage state to render a quad using that texture.  The resulting
6376      * color components should be 0x36 (~ 0.21), per this formula:
6377      *    linear_color = ((srgb_color + 0.055) / 1.055) ^ 2.4
6378      * This is true where srgb_color > 0.04045.
6379      */
6380     IDirect3D9 *d3d = NULL;
6381     HRESULT hr;
6382     LPDIRECT3DTEXTURE9 texture = NULL;
6383     LPDIRECT3DSURFACE9 surface = NULL;
6384     D3DLOCKED_RECT lr;
6385     DWORD color;
6386     float quad[] = {
6387         -1.0,       1.0,       0.0,     0.0,    0.0,
6388          1.0,       1.0,       0.0,     1.0,    0.0,
6389         -1.0,      -1.0,       0.0,     0.0,    1.0,
6390          1.0,      -1.0,       0.0,     1.0,    1.0,
6391     };
6392
6393
6394     memset(&lr, 0, sizeof(lr));
6395     IDirect3DDevice9_GetDirect3D(device, &d3d);
6396     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6397                                     D3DUSAGE_QUERY_SRGBREAD, D3DRTYPE_TEXTURE,
6398                                     D3DFMT_A8R8G8B8) != D3D_OK) {
6399         skip("D3DFMT_A8R8G8B8 textures with SRGBREAD not supported\n");
6400         goto out;
6401     }
6402
6403     hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, 0,
6404                                         D3DFMT_A8R8G8B8, D3DPOOL_MANAGED,
6405                                         &texture, NULL);
6406     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
6407     if(!texture) {
6408         skip("Failed to create A8R8G8B8 texture with SRGBREAD\n");
6409         goto out;
6410     }
6411     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
6412     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
6413
6414     fill_surface(surface, 0xff7f7f7f);
6415     IDirect3DSurface9_Release(surface);
6416
6417     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6418     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6419     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
6420     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
6421
6422     hr = IDirect3DDevice9_BeginScene(device);
6423     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
6424     if(SUCCEEDED(hr))
6425     {
6426         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, TRUE);
6427         ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
6428
6429         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6430         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
6431
6432
6433         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 5 * sizeof(float));
6434         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with %08x\n", hr);
6435
6436         hr = IDirect3DDevice9_EndScene(device);
6437         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
6438     }
6439
6440     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6441     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
6442     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_SRGBTEXTURE, FALSE);
6443     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed with %08x\n", hr);
6444
6445     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6446     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6447
6448     color = getPixelColor(device, 320, 240);
6449     ok(color == 0x00363636 || color == 0x00373737, "srgb quad has color %08x, expected 0x00363636\n", color);
6450
6451 out:
6452     if(texture) IDirect3DTexture9_Release(texture);
6453     IDirect3D9_Release(d3d);
6454 }
6455
6456 static void shademode_test(IDirect3DDevice9 *device)
6457 {
6458     /* Render a quad and try all of the different fixed function shading models. */
6459     HRESULT hr;
6460     DWORD color0, color1;
6461     DWORD color0_gouraud = 0, color1_gouraud = 0;
6462     DWORD shademode = D3DSHADE_FLAT;
6463     DWORD primtype = D3DPT_TRIANGLESTRIP;
6464     LPVOID data = NULL;
6465     LPDIRECT3DVERTEXBUFFER9 vb_strip = NULL;
6466     LPDIRECT3DVERTEXBUFFER9 vb_list = NULL;
6467     UINT i, j;
6468     struct vertex quad_strip[] =
6469     {
6470         {-1.0f, -1.0f,  0.0f, 0xffff0000  },
6471         {-1.0f,  1.0f,  0.0f, 0xff00ff00  },
6472         { 1.0f, -1.0f,  0.0f, 0xff0000ff  },
6473         { 1.0f,  1.0f,  0.0f, 0xffffffff  }
6474     };
6475     struct vertex quad_list[] =
6476     {
6477         {-1.0f, -1.0f,  0.0f, 0xffff0000  },
6478         {-1.0f,  1.0f,  0.0f, 0xff00ff00  },
6479         { 1.0f, -1.0f,  0.0f, 0xff0000ff  },
6480
6481         {-1.0f,  1.0f,  0.0f, 0xff00ff00  },
6482         { 1.0f, -1.0f,  0.0f, 0xff0000ff  },
6483         { 1.0f,  1.0f,  0.0f, 0xffffffff  }
6484     };
6485
6486     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_strip),
6487                                              0, 0, D3DPOOL_MANAGED, &vb_strip, NULL);
6488     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
6489     if (FAILED(hr)) goto bail;
6490
6491     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad_list),
6492                                              0, 0, D3DPOOL_MANAGED, &vb_list, NULL);
6493     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
6494     if (FAILED(hr)) goto bail;
6495
6496     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6497     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6498
6499     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6500     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
6501
6502     hr = IDirect3DVertexBuffer9_Lock(vb_strip, 0, sizeof(quad_strip), &data, 0);
6503     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
6504     memcpy(data, quad_strip, sizeof(quad_strip));
6505     hr = IDirect3DVertexBuffer9_Unlock(vb_strip);
6506     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
6507
6508     hr = IDirect3DVertexBuffer9_Lock(vb_list, 0, sizeof(quad_list), &data, 0);
6509     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
6510     memcpy(data, quad_list, sizeof(quad_list));
6511     hr = IDirect3DVertexBuffer9_Unlock(vb_list);
6512     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
6513
6514     /* Try it first with a TRIANGLESTRIP.  Do it with different geometry because
6515      * the color fixups we have to do for FLAT shading will be dependent on that. */
6516     hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_strip, 0, sizeof(quad_strip[0]));
6517     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6518
6519     /* First loop uses a TRIANGLESTRIP geometry, 2nd uses a TRIANGLELIST */
6520     for (j=0; j<2; j++) {
6521
6522         /* Inner loop just changes the D3DRS_SHADEMODE */
6523         for (i=0; i<3; i++) {
6524             hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6525             ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6526
6527             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, shademode);
6528             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6529
6530             hr = IDirect3DDevice9_BeginScene(device);
6531             ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
6532             if(SUCCEEDED(hr))
6533             {
6534                 hr = IDirect3DDevice9_DrawPrimitive(device, primtype, 0, 2);
6535                 ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed with %08x\n", hr);
6536
6537                 hr = IDirect3DDevice9_EndScene(device);
6538                 ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
6539             }
6540
6541             hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6542             ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6543
6544             /* Sample two spots from the output */
6545             color0 = getPixelColor(device, 100, 100); /* Inside first triangle */
6546             color1 = getPixelColor(device, 500, 350); /* Inside second triangle */
6547             switch(shademode) {
6548                 case D3DSHADE_FLAT:
6549                     /* Should take the color of the first vertex of each triangle */
6550                     todo_wine ok(color0 == 0x00ff0000, "FLAT shading has color0 %08x, expected 0x00ff0000 (todo)\n", color0);
6551                     todo_wine ok(color1 == 0x0000ff00, "FLAT shading has color1 %08x, expected 0x0000ff00 (todo)\n", color1);
6552                     shademode = D3DSHADE_GOURAUD;
6553                     break;
6554                 case D3DSHADE_GOURAUD:
6555                     /* Should be an interpolated blend */
6556
6557                     ok(color_match(color0, D3DCOLOR_ARGB(0x00, 0x0d, 0xca, 0x28), 2),
6558                        "GOURAUD shading has color0 %08x, expected 0x00dca28\n", color0);
6559                     ok(color_match(color1, D3DCOLOR_ARGB(0x00, 0x0d, 0x45, 0xc7), 2),
6560                        "GOURAUD shading has color1 %08x, expected 0x000d45c7\n", color1);
6561
6562                     color0_gouraud = color0;
6563                     color1_gouraud = color1;
6564
6565                     shademode = D3DSHADE_PHONG;
6566                     break;
6567                 case D3DSHADE_PHONG:
6568                     /* Should be the same as GOURAUD, since no hardware implements this */
6569                     ok(color_match(color0, D3DCOLOR_ARGB(0x00, 0x0d, 0xca, 0x28), 2),
6570                        "PHONG shading has color0 %08x, expected 0x000dca28\n", color0);
6571                     ok(color_match(color1, D3DCOLOR_ARGB(0x00, 0x0d, 0x45, 0xc7), 2),
6572                        "PHONG shading has color1 %08x, expected 0x000d45c7\n", color1);
6573
6574                     ok(color0 == color0_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6575                             color0_gouraud, color0);
6576                     ok(color1 == color1_gouraud, "difference between GOURAUD and PHONG shading detected: %08x %08x\n",
6577                             color1_gouraud, color1);
6578                     break;
6579             }
6580         }
6581         /* Now, do it all over again with a TRIANGLELIST */
6582         hr = IDirect3DDevice9_SetStreamSource(device, 0, vb_list, 0, sizeof(quad_list[0]));
6583         ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6584         primtype = D3DPT_TRIANGLELIST;
6585         shademode = D3DSHADE_FLAT;
6586     }
6587
6588 bail:
6589     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
6590     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
6591     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
6592     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6593
6594     if (vb_strip)
6595         IDirect3DVertexBuffer9_Release(vb_strip);
6596     if (vb_list)
6597         IDirect3DVertexBuffer9_Release(vb_list);
6598 }
6599
6600
6601 static void fog_srgbwrite_test(IDirect3DDevice9 *device)
6602 {
6603     /* Draw a black quad, half fogged with white fog -> grey color. Enable sRGB writing.
6604      * if sRGB writing is applied before fogging, the 0.0 will be multiplied with ~ 12.92, so still
6605      * stay 0.0. After that the fog gives 0.5. If sRGB writing is applied after fogging, the
6606      * 0.5 will run through the alternative path(0^5 ^ 0.41666 * 1.055 - 0.055), resulting in approx.
6607      * 0.73
6608      *
6609      * At the time of this writing, wined3d could not apply sRGB correction to fixed function rendering,
6610      * so use shaders for this task
6611      */
6612     IDirect3DPixelShader9 *pshader;
6613     IDirect3DVertexShader9 *vshader;
6614     IDirect3D9 *d3d;
6615     DWORD vshader_code[] = {
6616         0xfffe0101,                                                             /* vs_1_1                       */
6617         0x0000001f, 0x80000000, 0x900f0000,                                     /* dcl_position v0              */
6618         0x00000051, 0xa00f0000, 0x3f000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.5, 0.0, 0.0, 0.0   */
6619         0x00000001, 0xc00f0000, 0x90e40000,                                     /* mov oPos, v0                 */
6620         0x00000001, 0xc00f0001, 0xa0000000,                                     /* mov oFog, c0.x               */
6621         0x0000ffff                                                              /* end                          */
6622     };
6623     DWORD pshader_code[] = {
6624         0xffff0101,                                                             /* ps_1_1                       */
6625         0x00000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0   */
6626         0x00000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                   */
6627         0x0000ffff                                                              /* end                          */
6628     };
6629     const float quad[] = {
6630        -1.0,   -1.0,    0.1,
6631         1.0,   -1.0,    0.1,
6632        -1.0,    1.0,    0.1,
6633         1.0,    1.0,    0.1
6634     };
6635     HRESULT hr;
6636     DWORD color;
6637
6638     IDirect3DDevice9_GetDirect3D(device, &d3d);
6639     /* Ask for srgb writing on D3DRTYPE_TEXTURE. Some Windows drivers do not report it on surfaces.
6640      * For some not entirely understood reasons D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE
6641      * passes on surfaces, while asking for SRGBWRITE alone fails. Textures advertize srgb writing
6642      * alone as well, so use that since it is not the point of this test to show how CheckDeviceFormat
6643      * works
6644      */
6645     if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8,
6646                                     D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBWRITE,
6647                                     D3DRTYPE_TEXTURE, D3DFMT_A8R8G8B8) != D3D_OK) {
6648         skip("No SRGBWRITEENABLE support on D3DFMT_X8R8G8B8\n");
6649         IDirect3D9_Release(d3d);
6650         return;
6651     }
6652     IDirect3D9_Release(d3d);
6653
6654     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffff00, 0.0, 0);
6655     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
6656
6657     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE);
6658     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6659     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, D3DFOG_NONE);
6660     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6661     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR);
6662     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6663     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, 0xffffffff);
6664     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6665     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, TRUE);
6666     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6667
6668     hr = IDirect3DDevice9_CreateVertexShader(device, vshader_code, &vshader);
6669     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned %08x\n", hr);
6670     hr = IDirect3DDevice9_CreatePixelShader(device, pshader_code, &pshader);
6671     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader returned %08x\n", hr);
6672     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
6673     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr);
6674     hr = IDirect3DDevice9_SetVertexShader(device, vshader);
6675     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6676     hr = IDirect3DDevice9_SetPixelShader(device, pshader);
6677     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
6678
6679     hr = IDirect3DDevice9_BeginScene(device);
6680     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
6681     if(SUCCEEDED(hr)) {
6682         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 3);
6683         ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
6684
6685         hr = IDirect3DDevice9_EndScene(device);
6686         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
6687     }
6688
6689     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
6690     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexShader returned %08x\n", hr);
6691     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
6692     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader returned %08x\n", hr);
6693     IDirect3DPixelShader9_Release(pshader);
6694     IDirect3DVertexShader9_Release(vshader);
6695
6696     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, FALSE);
6697     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6698     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRGBWRITEENABLE, FALSE);
6699     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6700
6701     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6702     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
6703     color = getPixelColor(device, 160, 360);
6704     ok(color == 0x00808080 || color == 0x007f7f7f || color == 0x00818181,
6705        "Fog with D3DRS_SRGBWRITEENABLE returned color 0x%08x, expected 0x00808080\n", color);
6706 }
6707
6708 static void alpha_test(IDirect3DDevice9 *device)
6709 {
6710     HRESULT hr;
6711     IDirect3DTexture9 *offscreenTexture;
6712     IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
6713     DWORD color;
6714
6715     struct vertex quad1[] =
6716     {
6717         {-1.0f, -1.0f,   0.1f,                          0x4000ff00},
6718         {-1.0f,  0.0f,   0.1f,                          0x4000ff00},
6719         { 1.0f, -1.0f,   0.1f,                          0x4000ff00},
6720         { 1.0f,  0.0f,   0.1f,                          0x4000ff00},
6721     };
6722     struct vertex quad2[] =
6723     {
6724         {-1.0f,  0.0f,   0.1f,                          0xc00000ff},
6725         {-1.0f,  1.0f,   0.1f,                          0xc00000ff},
6726         { 1.0f,  0.0f,   0.1f,                          0xc00000ff},
6727         { 1.0f,  1.0f,   0.1f,                          0xc00000ff},
6728     };
6729     static const float composite_quad[][5] = {
6730         { 0.0f, -1.0f, 0.1f, 0.0f, 1.0f},
6731         { 0.0f,  1.0f, 0.1f, 0.0f, 0.0f},
6732         { 1.0f, -1.0f, 0.1f, 1.0f, 1.0f},
6733         { 1.0f,  1.0f, 0.1f, 1.0f, 0.0f},
6734     };
6735
6736     /* Clear the render target with alpha = 0.5 */
6737     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6738     ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6739
6740     hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
6741     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %#08x\n", hr);
6742
6743     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
6744     ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6745     if(!backbuffer) {
6746         goto out;
6747     }
6748
6749     hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
6750     ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
6751     if(!offscreen) {
6752         goto out;
6753     }
6754
6755     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
6756     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6757
6758     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
6759     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
6760     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
6761     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
6762     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
6763     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
6764     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
6765     ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
6766     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
6767     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
6768
6769     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
6770     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6771     if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
6772
6773         /* Draw two quads, one with src alpha blending, one with dest alpha blending. */
6774         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6775         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6776         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6777         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6778         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6779         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6780
6781         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6782         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6783         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6784         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6785         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6786         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6787
6788         /* Switch to the offscreen buffer, and redo the testing. The offscreen render target
6789          * doesn't have an alpha channel. DESTALPHA and INVDESTALPHA "don't work" on render
6790          * targets without alpha channel, they give essentially ZERO and ONE blend factors. */
6791         hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
6792         ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6793         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80ff0000, 0.0, 0);
6794         ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6795
6796         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
6797         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6798         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
6799         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6800         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
6801         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6802
6803         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_DESTALPHA);
6804         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6805         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVDESTALPHA);
6806         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6807         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
6808         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6809
6810         hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
6811         ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
6812
6813         /* Render the offscreen texture onto the frame buffer to be able to compare it regularly.
6814          * Disable alpha blending for the final composition
6815          */
6816         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
6817         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
6818         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
6819         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %#08x\n", hr);
6820
6821         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
6822         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6823         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, composite_quad, sizeof(float) * 5);
6824         ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
6825         hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
6826         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = %08x\n", hr);
6827
6828         hr = IDirect3DDevice9_EndScene(device);
6829         ok(hr == D3D_OK, "IDirect3DDevice7_EndScene failed, hr = %08x\n", hr);
6830     }
6831
6832     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
6833
6834     color = getPixelColor(device, 160, 360);
6835     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xbf, 0x40, 0x00), 1),
6836        "SRCALPHA on frame buffer returned color %08x, expected 0x00bf4000\n", color);
6837
6838     color = getPixelColor(device, 160, 120);
6839     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x7f, 0x00, 0x80), 2),
6840        "DSTALPHA on frame buffer returned color %08x, expected 0x007f0080\n", color);
6841
6842     color = getPixelColor(device, 480, 360);
6843     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0xbf, 0x40, 0x00), 1),
6844        "SRCALPHA on texture returned color %08x, expected 0x00bf4000\n", color);
6845
6846     color = getPixelColor(device, 480, 120);
6847     ok(color_match(color, D3DCOLOR_ARGB(0x00, 0x00, 0x00, 0xff), 1),
6848        "DSTALPHA on texture returned color %08x, expected 0x000000ff\n", color);
6849
6850     out:
6851     /* restore things */
6852     if(backbuffer) {
6853         IDirect3DSurface9_Release(backbuffer);
6854     }
6855     if(offscreenTexture) {
6856         IDirect3DTexture9_Release(offscreenTexture);
6857     }
6858     if(offscreen) {
6859         IDirect3DSurface9_Release(offscreen);
6860     }
6861 }
6862
6863 struct vertex_shortcolor {
6864     float x, y, z;
6865     unsigned short r, g, b, a;
6866 };
6867 struct vertex_floatcolor {
6868     float x, y, z;
6869     float r, g, b, a;
6870 };
6871
6872 static void fixed_function_decl_test(IDirect3DDevice9 *device)
6873 {
6874     HRESULT hr;
6875     BOOL s_ok, ub_ok, f_ok;
6876     DWORD color, size, i;
6877     void *data;
6878     static const D3DVERTEXELEMENT9 decl_elements_d3dcolor[] = {
6879         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6880         {0,  12,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6881         D3DDECL_END()
6882     };
6883     static const D3DVERTEXELEMENT9 decl_elements_d3dcolor_2streams[] = {
6884         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6885         {1,   0,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6886         D3DDECL_END()
6887     };
6888     static const D3DVERTEXELEMENT9 decl_elements_ubyte4n[] = {
6889         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6890         {0,  12,  D3DDECLTYPE_UBYTE4N,  D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6891         D3DDECL_END()
6892     };
6893     static const D3DVERTEXELEMENT9 decl_elements_ubyte4n_2streams[] = {
6894         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6895         {1,   0,  D3DDECLTYPE_UBYTE4N,  D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6896         D3DDECL_END()
6897     };
6898     static const D3DVERTEXELEMENT9 decl_elements_short4[] = {
6899         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6900         {0,  12,  D3DDECLTYPE_USHORT4N, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6901         D3DDECL_END()
6902     };
6903     static const D3DVERTEXELEMENT9 decl_elements_float[] = {
6904         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
6905         {0,  12,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6906         D3DDECL_END()
6907     };
6908     static const D3DVERTEXELEMENT9 decl_elements_positiont[] = {
6909         {0,   0,  D3DDECLTYPE_FLOAT4,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT,      0},
6910         {0,  16,  D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
6911         D3DDECL_END()
6912     };
6913     IDirect3DVertexDeclaration9 *dcl_float = NULL, *dcl_short = NULL, *dcl_ubyte = NULL, *dcl_color = NULL;
6914     IDirect3DVertexDeclaration9 *dcl_color_2 = NULL, *dcl_ubyte_2 = NULL, *dcl_positiont;
6915     IDirect3DVertexBuffer9 *vb, *vb2;
6916     struct vertex quad1[] =                             /* D3DCOLOR */
6917     {
6918         {-1.0f, -1.0f,   0.1f,                          0x00ffff00},
6919         {-1.0f,  0.0f,   0.1f,                          0x00ffff00},
6920         { 0.0f, -1.0f,   0.1f,                          0x00ffff00},
6921         { 0.0f,  0.0f,   0.1f,                          0x00ffff00},
6922     };
6923     struct vertex quad2[] =                             /* UBYTE4N */
6924     {
6925         {-1.0f,  0.0f,   0.1f,                          0x00ffff00},
6926         {-1.0f,  1.0f,   0.1f,                          0x00ffff00},
6927         { 0.0f,  0.0f,   0.1f,                          0x00ffff00},
6928         { 0.0f,  1.0f,   0.1f,                          0x00ffff00},
6929     };
6930     struct vertex_shortcolor quad3[] =                  /* short */
6931     {
6932         { 0.0f, -1.0f,   0.1f,                          0x0000, 0x0000, 0xffff, 0xffff},
6933         { 0.0f,  0.0f,   0.1f,                          0x0000, 0x0000, 0xffff, 0xffff},
6934         { 1.0f, -1.0f,   0.1f,                          0x0000, 0x0000, 0xffff, 0xffff},
6935         { 1.0f,  0.0f,   0.1f,                          0x0000, 0x0000, 0xffff, 0xffff},
6936     };
6937     struct vertex_floatcolor quad4[] =
6938     {
6939         { 0.0f,  0.0f,   0.1f,                          1.0, 0.0, 0.0, 0.0},
6940         { 0.0f,  1.0f,   0.1f,                          1.0, 0.0, 0.0, 0.0},
6941         { 1.0f,  0.0f,   0.1f,                          1.0, 0.0, 0.0, 0.0},
6942         { 1.0f,  1.0f,   0.1f,                          1.0, 0.0, 0.0, 0.0},
6943     };
6944     DWORD colors[] = {
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         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6953         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6954         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6955         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6956         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6957         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6958         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6959         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6960         0x00ff0000,   0x0000ff00,     0x000000ff,   0x00ffffff,
6961     };
6962     float quads[] = {
6963         -1.0,   -1.0,     0.1,
6964         -1.0,    0.0,     0.1,
6965          0.0,   -1.0,     0.1,
6966          0.0,    0.0,     0.1,
6967
6968          0.0,   -1.0,     0.1,
6969          0.0,    0.0,     0.1,
6970          1.0,   -1.0,     0.1,
6971          1.0,    0.0,     0.1,
6972
6973          0.0,    0.0,     0.1,
6974          0.0,    1.0,     0.1,
6975          1.0,    0.0,     0.1,
6976          1.0,    1.0,     0.1,
6977
6978         -1.0,    0.0,     0.1,
6979         -1.0,    1.0,     0.1,
6980          0.0,    0.0,     0.1,
6981          0.0,    1.0,     0.1
6982     };
6983     struct tvertex quad_transformed[] = {
6984        {  90,    110,     0.1,      2.0,        0x00ffff00},
6985        { 570,    110,     0.1,      2.0,        0x00ffff00},
6986        {  90,    300,     0.1,      2.0,        0x00ffff00},
6987        { 570,    300,     0.1,      2.0,        0x00ffff00}
6988     };
6989     D3DCAPS9 caps;
6990
6991     memset(&caps, 0, sizeof(caps));
6992     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
6993     ok(hr == D3D_OK, "GetDeviceCaps failed, hr = %08x\n", hr);
6994
6995     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
6996     ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
6997
6998     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor, &dcl_color);
6999     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7000     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_short4, &dcl_short);
7001     ok(SUCCEEDED(hr) || hr == E_FAIL, "CreateVertexDeclaration failed (%08x)\n", hr);
7002     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_float, &dcl_float);
7003     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7004     if(caps.DeclTypes & D3DDTCAPS_UBYTE4N) {
7005         hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n_2streams, &dcl_ubyte_2);
7006         ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7007         hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_ubyte4n, &dcl_ubyte);
7008         ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7009     } else {
7010         trace("D3DDTCAPS_UBYTE4N not supported\n");
7011         dcl_ubyte_2 = NULL;
7012         dcl_ubyte = NULL;
7013     }
7014     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_d3dcolor_2streams, &dcl_color_2);
7015     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7016     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements_positiont, &dcl_positiont);
7017     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%08x)\n", hr);
7018
7019     size = max(sizeof(quad1), max(sizeof(quad2), max(sizeof(quad3), max(sizeof(quad4), sizeof(quads)))));
7020     hr = IDirect3DDevice9_CreateVertexBuffer(device, size,
7021                                              0, 0, D3DPOOL_MANAGED, &vb, NULL);
7022     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
7023
7024     hr = IDirect3DDevice9_BeginScene(device);
7025     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7026     f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7027     if(SUCCEEDED(hr)) {
7028         if(dcl_color) {
7029             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7030             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7031             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
7032             ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7033         }
7034
7035         /* Tests with non-standard fixed function types fail on the refrast. The ATI driver partially
7036          * accepts them, the nvidia driver accepts them all. All those differences even though we're
7037          * using software vertex processing. Doh!
7038          */
7039         if(dcl_ubyte) {
7040             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7041             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7042             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
7043             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7044             ub_ok = SUCCEEDED(hr);
7045         }
7046
7047         if(dcl_short) {
7048             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7049             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7050             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad3, sizeof(quad3[0]));
7051             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7052             s_ok = SUCCEEDED(hr);
7053         }
7054
7055         if(dcl_float) {
7056             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7057             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7058             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad4, sizeof(quad4[0]));
7059             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
7060             f_ok = SUCCEEDED(hr);
7061         }
7062
7063         hr = IDirect3DDevice9_EndScene(device);
7064         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7065     }
7066
7067     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7068     if(dcl_short) {
7069         color = getPixelColor(device, 480, 360);
7070         ok(color == 0x000000ff || !s_ok,
7071            "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7072     }
7073     if(dcl_ubyte) {
7074         color = getPixelColor(device, 160, 120);
7075         ok(color == 0x0000ffff || !ub_ok,
7076            "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7077     }
7078     if(dcl_color) {
7079         color = getPixelColor(device, 160, 360);
7080         ok(color == 0x00ffff00,
7081            "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7082     }
7083     if(dcl_float) {
7084         color = getPixelColor(device, 480, 120);
7085         ok(color == 0x00ff0000 || !f_ok,
7086            "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7087     }
7088
7089     /* The following test with vertex buffers doesn't serve to find out new information from windows.
7090      * It is a plain regression test because wined3d uses different codepaths for attribute conversion
7091      * with vertex buffers. It makes sure that the vertex buffer one works, while the above tests
7092      * whether the immediate mode code works
7093      */
7094     f_ok = FALSE; s_ok = FALSE; ub_ok = FALSE;
7095     hr = IDirect3DDevice9_BeginScene(device);
7096     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7097     if(SUCCEEDED(hr)) {
7098         if(dcl_color) {
7099             hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad1), &data, 0);
7100             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7101             memcpy(data, quad1, sizeof(quad1));
7102             hr = IDirect3DVertexBuffer9_Unlock(vb);
7103             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7104             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color);
7105             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7106             hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad1[0]));
7107             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7108             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7109             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7110         }
7111
7112         if(dcl_ubyte) {
7113             hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad2), &data, 0);
7114             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7115             memcpy(data, quad2, sizeof(quad2));
7116             hr = IDirect3DVertexBuffer9_Unlock(vb);
7117             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7118             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte);
7119             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7120             hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad2[0]));
7121             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7122             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7123             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7124                "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7125             ub_ok = SUCCEEDED(hr);
7126         }
7127
7128         if(dcl_short) {
7129             hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad3), &data, 0);
7130             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7131             memcpy(data, quad3, sizeof(quad3));
7132             hr = IDirect3DVertexBuffer9_Unlock(vb);
7133             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7134             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_short);
7135             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7136             hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad3[0]));
7137             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7138             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7139             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7140                "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7141             s_ok = SUCCEEDED(hr);
7142         }
7143
7144         if(dcl_float) {
7145             hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad4), &data, 0);
7146             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7147             memcpy(data, quad4, sizeof(quad4));
7148             hr = IDirect3DVertexBuffer9_Unlock(vb);
7149             ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7150             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_float);
7151             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7152             hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad4[0]));
7153             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7154             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7155             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7156                "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7157             f_ok = SUCCEEDED(hr);
7158         }
7159
7160         hr = IDirect3DDevice9_EndScene(device);
7161         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %#08x\n", hr);
7162     }
7163
7164     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7165     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7166     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7167     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed (%08x)\n", hr);
7168
7169     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7170     if(dcl_short) {
7171         color = getPixelColor(device, 480, 360);
7172         ok(color == 0x000000ff || !s_ok,
7173            "D3DDECLTYPE_USHORT4N returned color %08x, expected 0x000000ff\n", color);
7174     }
7175     if(dcl_ubyte) {
7176         color = getPixelColor(device, 160, 120);
7177         ok(color == 0x0000ffff || !ub_ok,
7178            "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x0000ffff\n", color);
7179     }
7180     if(dcl_color) {
7181         color = getPixelColor(device, 160, 360);
7182         ok(color == 0x00ffff00,
7183            "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ffff00\n", color);
7184     }
7185     if(dcl_float) {
7186         color = getPixelColor(device, 480, 120);
7187         ok(color == 0x00ff0000 || !f_ok,
7188            "D3DDECLTYPE_FLOAT4 returned color %08x, expected 0x00ff0000\n", color);
7189     }
7190
7191     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7192     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
7193
7194     hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad_transformed), &data, 0);
7195     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7196     memcpy(data, quad_transformed, sizeof(quad_transformed));
7197     hr = IDirect3DVertexBuffer9_Unlock(vb);
7198     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7199
7200     hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_positiont);
7201     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7202
7203     hr = IDirect3DDevice9_BeginScene(device);
7204     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7205     if(SUCCEEDED(hr)) {
7206         hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(quad_transformed[0]));
7207         ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7208         hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7209         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7210
7211         hr = IDirect3DDevice9_EndScene(device);
7212         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7213     }
7214
7215     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7216     color = getPixelColor(device, 88, 108);
7217     ok(color == 0x000000ff,
7218        "pixel 88/108 has color %08x, expected 0x000000ff\n", color);
7219     color = getPixelColor(device, 92, 108);
7220     ok(color == 0x000000ff,
7221        "pixel 92/108 has color %08x, expected 0x000000ff\n", color);
7222     color = getPixelColor(device, 88, 112);
7223     ok(color == 0x000000ff,
7224        "pixel 88/112 has color %08x, expected 0x000000ff\n", color);
7225     color = getPixelColor(device, 92, 112);
7226     ok(color == 0x00ffff00,
7227        "pixel 92/112 has color %08x, expected 0x00ffff00\n", color);
7228
7229     color = getPixelColor(device, 568, 108);
7230     ok(color == 0x000000ff,
7231        "pixel 568/108 has color %08x, expected 0x000000ff\n", color);
7232     color = getPixelColor(device, 572, 108);
7233     ok(color == 0x000000ff,
7234        "pixel 572/108 has color %08x, expected 0x000000ff\n", color);
7235     color = getPixelColor(device, 568, 112);
7236     ok(color == 0x00ffff00,
7237        "pixel 568/112 has color %08x, expected 0x00ffff00\n", color);
7238     color = getPixelColor(device, 572, 112);
7239     ok(color == 0x000000ff,
7240        "pixel 572/112 has color %08x, expected 0x000000ff\n", color);
7241
7242     color = getPixelColor(device, 88, 298);
7243     ok(color == 0x000000ff,
7244        "pixel 88/298 has color %08x, expected 0x000000ff\n", color);
7245     color = getPixelColor(device, 92, 298);
7246     ok(color == 0x00ffff00,
7247        "pixel 92/298 has color %08x, expected 0x00ffff00\n", color);
7248     color = getPixelColor(device, 88, 302);
7249     ok(color == 0x000000ff,
7250        "pixel 88/302 has color %08x, expected 0x000000ff\n", color);
7251     color = getPixelColor(device, 92, 302);
7252     ok(color == 0x000000ff,
7253        "pixel 92/302 has color %08x, expected 0x000000ff\n", color);
7254
7255     color = getPixelColor(device, 568, 298);
7256     ok(color == 0x00ffff00,
7257        "pixel 568/298 has color %08x, expected 0x00ffff00\n", color);
7258     color = getPixelColor(device, 572, 298);
7259     ok(color == 0x000000ff,
7260        "pixel 572/298 has color %08x, expected 0x000000ff\n", color);
7261     color = getPixelColor(device, 568, 302);
7262     ok(color == 0x000000ff,
7263        "pixel 568/302 has color %08x, expected 0x000000ff\n", color);
7264     color = getPixelColor(device, 572, 302);
7265     ok(color == 0x000000ff,
7266        "pixel 572/302 has color %08x, expected 0x000000ff\n", color);
7267
7268     /* This test is pointless without those two declarations: */
7269     if((!dcl_color_2) || (!dcl_ubyte_2)) {
7270         skip("color-ubyte switching test declarations aren't supported\n");
7271         goto out;
7272     }
7273
7274     hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quads), &data, 0);
7275     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7276     memcpy(data, quads, sizeof(quads));
7277     hr = IDirect3DVertexBuffer9_Unlock(vb);
7278     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7279     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(colors),
7280                                              0, 0, D3DPOOL_MANAGED, &vb2, NULL);
7281     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
7282     hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(colors), &data, 0);
7283     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
7284     memcpy(data, colors, sizeof(colors));
7285     hr = IDirect3DVertexBuffer9_Unlock(vb2);
7286     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed (%08x)\n", hr);
7287
7288     for(i = 0; i < 2; i++) {
7289         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
7290         ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
7291
7292         hr = IDirect3DDevice9_SetStreamSource(device, 0, vb, 0, sizeof(float) * 3);
7293         ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7294         if(i == 0) {
7295             hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 0, sizeof(DWORD) * 4);
7296         } else {
7297             hr = IDirect3DDevice9_SetStreamSource(device, 1, vb2, 8, sizeof(DWORD) * 4);
7298         }
7299         ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7300
7301         hr = IDirect3DDevice9_BeginScene(device);
7302         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
7303         ub_ok = FALSE;
7304         if(SUCCEEDED(hr)) {
7305             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7306             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7307             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 0, 2);
7308             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7309                "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7310             ub_ok = SUCCEEDED(hr);
7311
7312             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_color_2);
7313             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7314             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 4, 2);
7315             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7316
7317             hr = IDirect3DDevice9_SetVertexDeclaration(device, dcl_ubyte_2);
7318             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x\n", hr);
7319             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 8, 2);
7320             ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL,
7321                "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7322             ub_ok = (SUCCEEDED(hr) && ub_ok);
7323
7324             hr = IDirect3DDevice9_EndScene(device);
7325             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
7326         }
7327
7328         IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7329         if(i == 0) {
7330             color = getPixelColor(device, 480, 360);
7331             ok(color == 0x00ff0000,
7332                "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x00ff0000\n", color);
7333             color = getPixelColor(device, 160, 120);
7334             ok(color == 0x00ffffff,
7335                 "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7336             color = getPixelColor(device, 160, 360);
7337             ok(color == 0x000000ff || !ub_ok,
7338                "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7339             color = getPixelColor(device, 480, 120);
7340             ok(color == 0x000000ff || !ub_ok,
7341                "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x000000ff\n", color);
7342         } else {
7343             color = getPixelColor(device, 480, 360);
7344             ok(color == 0x000000ff,
7345                "D3DDECLTYPE_D3DCOLOR returned color %08x, expected 0x000000ff\n", color);
7346             color = getPixelColor(device, 160, 120);
7347             ok(color == 0x00ffffff,
7348                "Unused quad returned color %08x, expected 0x00ffffff\n", color);
7349             color = getPixelColor(device, 160, 360);
7350             ok(color == 0x00ff0000 || !ub_ok,
7351                "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7352             color = getPixelColor(device, 480, 120);
7353             ok(color == 0x00ff0000 || !ub_ok,
7354                "D3DDECLTYPE_UBYTE4N returned color %08x, expected 0x00ff0000\n", color);
7355         }
7356     }
7357
7358     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7359     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7360     hr = IDirect3DDevice9_SetStreamSource(device, 1, NULL, 0, 0);
7361     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x\n", hr);
7362     IDirect3DVertexBuffer9_Release(vb2);
7363
7364     out:
7365     IDirect3DVertexBuffer9_Release(vb);
7366     if(dcl_float) IDirect3DVertexDeclaration9_Release(dcl_float);
7367     if(dcl_short) IDirect3DVertexDeclaration9_Release(dcl_short);
7368     if(dcl_ubyte) IDirect3DVertexDeclaration9_Release(dcl_ubyte);
7369     if(dcl_color) IDirect3DVertexDeclaration9_Release(dcl_color);
7370     if(dcl_color_2) IDirect3DVertexDeclaration9_Release(dcl_color_2);
7371     if(dcl_ubyte_2) IDirect3DVertexDeclaration9_Release(dcl_ubyte_2);
7372     if(dcl_positiont) IDirect3DVertexDeclaration9_Release(dcl_positiont);
7373 }
7374
7375 struct vertex_float16color {
7376     float x, y, z;
7377     DWORD c1, c2;
7378 };
7379
7380 static void test_vshader_float16(IDirect3DDevice9 *device)
7381 {
7382     HRESULT hr;
7383     DWORD color;
7384     void *data;
7385     static const D3DVERTEXELEMENT9 decl_elements[] = {
7386         {0,   0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION,       0},
7387         {0,  12,  D3DDECLTYPE_FLOAT16_4,D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR,          0},
7388         D3DDECL_END()
7389     };
7390     IDirect3DVertexDeclaration9 *vdecl = NULL;
7391     IDirect3DVertexBuffer9 *buffer = NULL;
7392     IDirect3DVertexShader9 *shader;
7393     DWORD shader_code[] = {
7394         0xfffe0101, 0x0000001f, 0x80000000, 0x900f0000, 0x0000001f, 0x8000000a,
7395         0x900f0001, 0x00000001, 0xc00f0000, 0x90e40000, 0x00000001, 0xd00f0000,
7396         0x90e40001, 0x0000ffff
7397     };
7398     struct vertex_float16color quad[] = {
7399         { -1.0,   -1.0,     0.1,        0x3c000000, 0x00000000 }, /* green */
7400         { -1.0,    0.0,     0.1,        0x3c000000, 0x00000000 },
7401         {  0.0,   -1.0,     0.1,        0x3c000000, 0x00000000 },
7402         {  0.0,    0.0,     0.1,        0x3c000000, 0x00000000 },
7403
7404         {  0.0,   -1.0,     0.1,        0x00003c00, 0x00000000 }, /* red */
7405         {  0.0,    0.0,     0.1,        0x00003c00, 0x00000000 },
7406         {  1.0,   -1.0,     0.1,        0x00003c00, 0x00000000 },
7407         {  1.0,    0.0,     0.1,        0x00003c00, 0x00000000 },
7408
7409         {  0.0,    0.0,     0.1,        0x00000000, 0x00003c00 }, /* blue */
7410         {  0.0,    1.0,     0.1,        0x00000000, 0x00003c00 },
7411         {  1.0,    0.0,     0.1,        0x00000000, 0x00003c00 },
7412         {  1.0,    1.0,     0.1,        0x00000000, 0x00003c00 },
7413
7414         { -1.0,    0.0,     0.1,        0x00000000, 0x3c000000 }, /* alpha */
7415         { -1.0,    1.0,     0.1,        0x00000000, 0x3c000000 },
7416         {  0.0,    0.0,     0.1,        0x00000000, 0x3c000000 },
7417         {  0.0,    1.0,     0.1,        0x00000000, 0x3c000000 },
7418     };
7419
7420     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7421     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7422
7423     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vdecl);
7424     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%08x\n", hr);
7425     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
7426     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%08x\n", hr);
7427     hr = IDirect3DDevice9_SetVertexShader(device, shader);
7428     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
7429
7430     hr = IDirect3DDevice9_BeginScene(device);
7431     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7432     if(SUCCEEDED(hr)) {
7433         hr = IDirect3DDevice9_SetVertexDeclaration(device, vdecl);
7434         ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7435         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad +  0, sizeof(quad[0]));
7436         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7437         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad +  4, sizeof(quad[0]));
7438         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7439         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad +  8, sizeof(quad[0]));
7440         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7441         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad + 12, sizeof(quad[0]));
7442         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7443
7444         hr = IDirect3DDevice9_EndScene(device);
7445         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
7446     }
7447     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7448     color = getPixelColor(device, 480, 360);
7449     ok(color == 0x00ff0000,
7450        "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7451     color = getPixelColor(device, 160, 120);
7452     ok(color == 0x00000000,
7453        "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7454     color = getPixelColor(device, 160, 360);
7455     ok(color == 0x0000ff00,
7456        "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7457     color = getPixelColor(device, 480, 120);
7458     ok(color == 0x000000ff,
7459        "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7460
7461     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff102030, 0.0, 0);
7462     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7463
7464     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0,
7465                                              D3DPOOL_MANAGED, &buffer, NULL);
7466     ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexBuffer failed, hr=%08x\n", hr);
7467     hr = IDirect3DVertexBuffer9_Lock(buffer, 0, sizeof(quad), &data, 0);
7468     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed, hr=%08x\n", hr);
7469     memcpy(data, quad, sizeof(quad));
7470     hr = IDirect3DVertexBuffer9_Unlock(buffer);
7471     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed, hr=%08x\n", hr);
7472     hr = IDirect3DDevice9_SetStreamSource(device, 0, buffer, 0, sizeof(quad[0]));
7473     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%08x\n", hr);
7474
7475     hr = IDirect3DDevice9_BeginScene(device);
7476     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed (%08x)\n", hr);
7477     if(SUCCEEDED(hr)) {
7478             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP,  0, 2);
7479             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7480             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP,  4, 2);
7481             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7482             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP,  8, 2);
7483             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7484             hr = IDirect3DDevice9_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, 12, 2);
7485             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitive failed, hr = %#08x\n", hr);
7486
7487             hr = IDirect3DDevice9_EndScene(device);
7488             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
7489     }
7490
7491     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7492     color = getPixelColor(device, 480, 360);
7493     ok(color == 0x00ff0000,
7494        "Input 0x00003c00, 0x00000000 returned color %08x, expected 0x00ff0000\n", color);
7495     color = getPixelColor(device, 160, 120);
7496     ok(color == 0x00000000,
7497        "Input 0x00000000, 0x3c000000 returned color %08x, expected 0x00000000\n", color);
7498     color = getPixelColor(device, 160, 360);
7499     ok(color == 0x0000ff00,
7500        "Input 0x3c000000, 0x00000000 returned color %08x, expected 0x0000ff00\n", color);
7501     color = getPixelColor(device, 480, 120);
7502     ok(color == 0x000000ff,
7503        "Input 0x00000000, 0x00003c00 returned color %08x, expected 0x000000ff\n", color);
7504
7505     hr = IDirect3DDevice9_SetStreamSource(device, 0, NULL, 0, 0);
7506     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed, hr=%08x\n", hr);
7507     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
7508     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7509     IDirect3DDevice9_SetVertexShader(device, NULL);
7510     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
7511
7512     IDirect3DVertexDeclaration9_Release(vdecl);
7513     IDirect3DVertexShader9_Release(shader);
7514     IDirect3DVertexBuffer9_Release(buffer);
7515 }
7516
7517 static void conditional_np2_repeat_test(IDirect3DDevice9 *device)
7518 {
7519     D3DCAPS9 caps;
7520     IDirect3DTexture9 *texture;
7521     HRESULT hr;
7522     D3DLOCKED_RECT rect;
7523     unsigned int x, y;
7524     DWORD *dst, color;
7525     const float quad[] = {
7526         -1.0,   -1.0,   0.1,   -0.2,   -0.2,
7527          1.0,   -1.0,   0.1,    1.2,   -0.2,
7528         -1.0,    1.0,   0.1,   -0.2,    1.2,
7529          1.0,    1.0,   0.1,    1.2,    1.2
7530     };
7531     memset(&caps, 0, sizeof(caps));
7532
7533     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7534     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
7535     if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7536         /* NP2 conditional requires the POW2 flag. Check that while we're at it */
7537         ok((caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) == 0,
7538            "Card has conditional NP2 support without power of two restriction set\n");
7539         skip("Card has unconditional pow2 support, skipping conditional NP2 tests\n");
7540         return;
7541     } else if(!(caps.TextureCaps & D3DPTEXTURECAPS_POW2)) {
7542         skip("No conditional NP2 support, skipping conditional NP2 tests\n");
7543         return;
7544     }
7545
7546     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
7547     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7548
7549     hr = IDirect3DDevice9_CreateTexture(device, 10, 10, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
7550     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%08x\n", hr);
7551
7552     memset(&rect, 0, sizeof(rect));
7553     hr = IDirect3DTexture9_LockRect(texture, 0, &rect, NULL, 0);
7554     ok(hr == D3D_OK, "IDirect3DTexture9_LockRect failed hr=%08x\n", hr);
7555     for(y = 0; y < 10; y++) {
7556         for(x = 0; x < 10; x++) {
7557             dst = (DWORD *) ((BYTE *) rect.pBits + y * rect.Pitch + x * sizeof(DWORD));
7558             if(x == 0 || x == 9 || y == 0 || y == 9) {
7559                 *dst = 0x00ff0000;
7560             } else {
7561                 *dst = 0x000000ff;
7562             }
7563         }
7564     }
7565     hr = IDirect3DTexture9_UnlockRect(texture, 0);
7566     ok(hr == D3D_OK, "IDirect3DTexture9_UnlockRect failed hr=%08x\n", hr);
7567
7568     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7569     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%08x\n", hr);
7570     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
7571     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%08x\n", hr);
7572     hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);
7573     ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState failed hr=%08x\n", hr);
7574     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7575     ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed, hr=%08x\n", hr);
7576
7577     hr = IDirect3DDevice9_BeginScene(device);
7578     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7579     if(SUCCEEDED(hr)) {
7580         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
7581         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7582
7583         hr = IDirect3DDevice9_EndScene(device);
7584         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
7585     }
7586
7587     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7588
7589     color = getPixelColor(device,    1,  1);
7590     ok(color == 0x00ff0000, "NP2: Pixel   1,  1 has color %08x, expected 0x00ff0000\n", color);
7591     color = getPixelColor(device, 639, 479);
7592     ok(color == 0x00ff0000, "NP2: Pixel 639, 479 has color %08x, expected 0x00ff0000\n", color);
7593
7594     color = getPixelColor(device, 135, 101);
7595     ok(color == 0x00ff0000, "NP2: Pixel 135, 101 has color %08x, expected 0x00ff0000\n", color);
7596     color = getPixelColor(device, 140, 101);
7597     ok(color == 0x00ff0000, "NP2: Pixel 140, 101 has color %08x, expected 0x00ff0000\n", color);
7598     color = getPixelColor(device, 135, 105);
7599     ok(color == 0x00ff0000, "NP2: Pixel 135, 105 has color %08x, expected 0x00ff0000\n", color);
7600     color = getPixelColor(device, 140, 105);
7601     ok(color == 0x000000ff, "NP2: Pixel 140, 105 has color %08x, expected 0x000000ff\n", color);
7602
7603     color = getPixelColor(device, 135, 376);
7604     ok(color == 0x00ff0000, "NP2: Pixel 135, 376 has color %08x, expected 0x00ff0000\n", color);
7605     color = getPixelColor(device, 140, 376);
7606     ok(color == 0x000000ff, "NP2: Pixel 140, 376 has color %08x, expected 0x000000ff\n", color);
7607     color = getPixelColor(device, 135, 379);
7608     ok(color == 0x00ff0000, "NP2: Pixel 135, 379 has color %08x, expected 0x00ff0000\n", color);
7609     color = getPixelColor(device, 140, 379);
7610     ok(color == 0x00ff0000, "NP2: Pixel 140, 379 has color %08x, expected 0x00ff0000\n", color);
7611
7612     color = getPixelColor(device, 500, 101);
7613     ok(color == 0x00ff0000, "NP2: Pixel 500, 101 has color %08x, expected 0x00ff0000\n", color);
7614     color = getPixelColor(device, 504, 101);
7615     ok(color == 0x00ff0000, "NP2: Pixel 504, 101 has color %08x, expected 0x00ff0000\n", color);
7616     color = getPixelColor(device, 500, 105);
7617     ok(color == 0x000000ff, "NP2: Pixel 500, 105 has color %08x, expected 0x000000ff\n", color);
7618     color = getPixelColor(device, 504, 105);
7619     ok(color == 0x00ff0000, "NP2: Pixel 504, 105 has color %08x, expected 0x00ff0000\n", color);
7620
7621     color = getPixelColor(device, 500, 376);
7622     ok(color == 0x000000ff, "NP2: Pixel 500, 376 has color %08x, expected 0x000000ff\n", color);
7623     color = getPixelColor(device, 504, 376);
7624     ok(color == 0x00ff0000, "NP2: Pixel 504, 376 has color %08x, expected 0x00ff0000\n", color);
7625     color = getPixelColor(device, 500, 380);
7626     ok(color == 0x00ff0000, "NP2: Pixel 500, 380 has color %08x, expected 0x00ff0000\n", color);
7627     color = getPixelColor(device, 504, 380);
7628     ok(color == 0x00ff0000, "NP2: Pixel 504, 380 has color %08x, expected 0x00ff0000\n", color);
7629
7630     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7631     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed hr=%08x\n", hr);
7632     IDirect3DTexture9_Release(texture);
7633 }
7634
7635 static void vFace_register_test(IDirect3DDevice9 *device)
7636 {
7637     HRESULT hr;
7638     DWORD color;
7639     const DWORD shader_code[] = {
7640         0xffff0300,                                                             /* ps_3_0                     */
7641         0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0.0, 1.0, 0.0, 0.0 */
7642         0x05000051, 0xa00f0001, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c1, 1.0, 0.0, 0.0, 0.0 */
7643         0x0200001f, 0x80000000, 0x900f1001,                                     /* dcl vFace                  */
7644         0x02000001, 0x800f0001, 0xa0e40001,                                     /* mov r1, c1                 */
7645         0x04000058, 0x800f0000, 0x90e41001, 0xa0e40000, 0x80e40001,             /* cmp r0, vFace, c0, r1      */
7646         0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                */
7647         0x0000ffff                                                              /* END                        */
7648     };
7649     IDirect3DPixelShader9 *shader;
7650     IDirect3DTexture9 *texture;
7651     IDirect3DSurface9 *surface, *backbuffer;
7652     const float quad[] = {
7653         -1.0,   -1.0,   0.1,
7654          1.0,   -1.0,   0.1,
7655         -1.0,    0.0,   0.1,
7656
7657          1.0,   -1.0,   0.1,
7658          1.0,    0.0,   0.1,
7659         -1.0,    0.0,   0.1,
7660
7661         -1.0,    0.0,   0.1,
7662         -1.0,    1.0,   0.1,
7663          1.0,    0.0,   0.1,
7664
7665          1.0,    0.0,   0.1,
7666         -1.0,    1.0,   0.1,
7667          1.0,    1.0,   0.1,
7668     };
7669     const float blit[] = {
7670          0.0,   -1.0,   0.1,    0.0,    0.0,
7671          1.0,   -1.0,   0.1,    1.0,    0.0,
7672          0.0,    1.0,   0.1,    0.0,    1.0,
7673          1.0,    1.0,   0.1,    1.0,    1.0,
7674     };
7675
7676     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
7677     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
7678     hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL);
7679     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed hr=%08x\n", hr);
7680     hr = IDirect3DTexture9_GetSurfaceLevel(texture, 0, &surface);
7681     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed hr=%08x\n", hr);
7682     hr = IDirect3DDevice9_SetPixelShader(device, shader);
7683     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
7684     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
7685     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
7686     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
7687     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%08x\n", hr);
7688
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
7692     hr = IDirect3DDevice9_BeginScene(device);
7693     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
7694     if(SUCCEEDED(hr)) {
7695         /* First, draw to the texture and the back buffer to test both offscreen and onscreen cases */
7696         hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
7697         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
7698         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
7699         ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
7700         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7701         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7702         hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
7703         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
7704         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLELIST, 4, quad, sizeof(float) * 3);
7705         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7706
7707         /* Blit the texture onto the back buffer to make it visible */
7708         hr = IDirect3DDevice9_SetPixelShader(device, NULL);
7709         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
7710         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture);
7711         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
7712         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7713         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%08x\n", hr);
7714         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7715         ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed, hr=%08x\n", hr);
7716         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
7717         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
7718
7719         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, blit, sizeof(float) * 5);
7720         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
7721
7722         hr = IDirect3DDevice9_EndScene(device);
7723         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
7724     }
7725
7726     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7727     color = getPixelColor(device, 160, 360);
7728     ok(color == 0x00ff0000, "vFace: Onscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7729     color = getPixelColor(device, 160, 120);
7730     ok(color == 0x0000ff00, "vFace: Onscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7731     color = getPixelColor(device, 480, 360);
7732     ok(color == 0x0000ff00, "vFace: Offscreen rendered back facing quad has color 0x%08x, expected 0x0000ff00\n", color);
7733     color = getPixelColor(device, 480, 120);
7734     ok(color == 0x00ff0000, "vFace: Offscreen rendered front facing quad has color 0x%08x, expected 0x00ff0000\n", color);
7735
7736     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
7737     IDirect3DDevice9_SetTexture(device, 0, NULL);
7738     IDirect3DPixelShader9_Release(shader);
7739     IDirect3DSurface9_Release(surface);
7740     IDirect3DSurface9_Release(backbuffer);
7741     IDirect3DTexture9_Release(texture);
7742 }
7743
7744 static void fixed_function_bumpmap_test(IDirect3DDevice9 *device)
7745 {
7746     HRESULT hr;
7747     DWORD color;
7748     int i;
7749     D3DCAPS9 caps;
7750     BOOL L6V5U5_supported = FALSE;
7751     IDirect3DTexture9 *tex1, *tex2;
7752     D3DLOCKED_RECT locked_rect;
7753
7754     static const float quad[][7] = {
7755         {-128.0f/640.0f, -128.0f/480.0f, 0.1f, 0.0f, 0.0f, 0.0f, 0.0f},
7756         {-128.0f/640.0f,  128.0f/480.0f, 0.1f, 0.0f, 1.0f, 0.0f, 1.0f},
7757         { 128.0f/640.0f, -128.0f/480.0f, 0.1f, 1.0f, 0.0f, 1.0f, 0.0f},
7758         { 128.0f/640.0f,  128.0f/480.0f, 0.1f, 1.0f, 1.0f, 1.0f, 1.0f},
7759     };
7760
7761     static const D3DVERTEXELEMENT9 decl_elements[] = {
7762         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
7763         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
7764         {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1},
7765         D3DDECL_END()
7766     };
7767
7768     /* use asymmetric matrix to test loading */
7769     float bumpenvmat[4] = {0.0,0.5,-0.5,0.0};
7770     float scale, offset;
7771
7772     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
7773     IDirect3DTexture9           *texture            = NULL;
7774
7775     memset(&caps, 0, sizeof(caps));
7776     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
7777     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
7778     if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)) {
7779         skip("D3DTEXOPCAPS_BUMPENVMAP not set, skipping bumpmap tests\n");
7780         return;
7781     } else {
7782         /* This check is disabled, some Windows drivers do not handle D3DUSAGE_QUERY_LEGACYBUMPMAP properly.
7783          * They report that it is not supported, but after that bump mapping works properly. So just test
7784          * if the format is generally supported, and check the BUMPENVMAP flag
7785          */
7786         IDirect3D9 *d3d9;
7787
7788         IDirect3DDevice9_GetDirect3D(device, &d3d9);
7789         hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7790                                           D3DRTYPE_TEXTURE, D3DFMT_L6V5U5);
7791         L6V5U5_supported = SUCCEEDED(hr);
7792         hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
7793                                           D3DRTYPE_TEXTURE, D3DFMT_V8U8);
7794         IDirect3D9_Release(d3d9);
7795         if(FAILED(hr)) {
7796             skip("D3DFMT_V8U8 not supported for legacy bump mapping\n");
7797             return;
7798         }
7799     }
7800
7801     /* Generate the textures */
7802     generate_bumpmap_textures(device);
7803
7804     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT00, *(LPDWORD)&bumpenvmat[0]);
7805     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7806     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT01, *(LPDWORD)&bumpenvmat[1]);
7807     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7808     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT10, *(LPDWORD)&bumpenvmat[2]);
7809     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7810     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVMAT11, *(LPDWORD)&bumpenvmat[3]);
7811     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7812
7813     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAP);
7814     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7815     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
7816     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7817     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
7818     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7819
7820     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
7821     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7822     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
7823     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7824     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_CURRENT);
7825     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7826
7827     hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
7828     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7829
7830     hr = IDirect3DDevice9_SetVertexShader(device, NULL);
7831     ok(SUCCEEDED(hr), "SetVertexShader failed (%08x)\n", hr);
7832
7833     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
7834     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed (%08x)\n", hr);
7835
7836
7837     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
7838     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (0x%08x)\n", hr);
7839     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
7840     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (0x%08x)\n", hr);
7841
7842     hr = IDirect3DDevice9_BeginScene(device);
7843     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7844
7845     hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7846     ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7847
7848     hr = IDirect3DDevice9_EndScene(device);
7849     ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7850
7851     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7852     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7853
7854     /* on MacOS(10.5.4, radeon X1600), the white dots are have color 0x00fbfbfb rather than 0x00ffffff. This is
7855      * kinda strange since no calculations are done on the sampled colors, only on the texture coordinates.
7856      * But since testing the color match is not the purpose of the test don't be too picky
7857      */
7858     color = getPixelColor(device, 320-32, 240);
7859     ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7860     color = getPixelColor(device, 320+32, 240);
7861     ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7862     color = getPixelColor(device, 320, 240-32);
7863     ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7864     color = getPixelColor(device, 320, 240+32);
7865     ok(color_match(color, 0x00ffffff, 4), "bumpmap failed: Got color 0x%08x, expected 0x00ffffff.\n", color);
7866     color = getPixelColor(device, 320, 240);
7867     ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7868     color = getPixelColor(device, 320+32, 240+32);
7869     ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7870     color = getPixelColor(device, 320-32, 240+32);
7871     ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7872     color = getPixelColor(device, 320+32, 240-32);
7873     ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7874     color = getPixelColor(device, 320-32, 240-32);
7875     ok(color_match(color, 0x00000000, 4), "bumpmap failed: Got color 0x%08x, expected 0x00000000.\n", color);
7876
7877     for(i = 0; i < 2; i++) {
7878         hr = IDirect3DDevice9_GetTexture(device, i, (IDirect3DBaseTexture9 **) &texture);
7879         ok(SUCCEEDED(hr), "IDirect3DDevice9_GetTexture failed (0x%08x)\n", hr);
7880         IDirect3DTexture9_Release(texture); /* For the GetTexture */
7881         hr = IDirect3DDevice9_SetTexture(device, i, NULL);
7882         ok(SUCCEEDED(hr), "SetTexture failed (0x%08x)\n", hr);
7883         IDirect3DTexture9_Release(texture); /* To destroy it */
7884     }
7885
7886     if(!(caps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAPLUMINANCE)) {
7887         skip("D3DTOP_BUMPENVMAPLUMINANCE not supported, skipping\n");
7888         goto cleanup;
7889     }
7890     if(L6V5U5_supported == FALSE) {
7891         skip("L6V5U5_supported not supported, skipping D3DTOP_BUMPENVMAPLUMINANCE test\n");
7892         goto cleanup;
7893     }
7894
7895     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00000000, 0.0, 0x8);
7896     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
7897     /* This test only tests the luminance part. The bumpmapping part was already tested above and
7898      * would only make this test more complicated
7899      */
7900     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_L6V5U5, D3DPOOL_MANAGED, &tex1, NULL);
7901     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
7902     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &tex2, NULL);
7903     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
7904
7905     memset(&locked_rect, 0, sizeof(locked_rect));
7906     hr = IDirect3DTexture9_LockRect(tex1, 0, &locked_rect, NULL, 0);
7907     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
7908     *((DWORD *)locked_rect.pBits) = 0x4000; /* L = 0.25, V = 0.0, U = 0.0 */
7909     hr = IDirect3DTexture9_UnlockRect(tex1, 0);
7910     ok(SUCCEEDED(hr), "UnlockRect failed with 0x%08x\n", hr);
7911
7912     memset(&locked_rect, 0, sizeof(locked_rect));
7913     hr = IDirect3DTexture9_LockRect(tex2, 0, &locked_rect, NULL, 0);
7914     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
7915     *((DWORD *)locked_rect.pBits) = 0x00ff80c0;
7916     hr = IDirect3DTexture9_UnlockRect(tex2, 0);
7917     ok(SUCCEEDED(hr), "UnlockRect failed with 0x%08x\n", hr);
7918
7919     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
7920     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7921     hr = IDirect3DDevice9_SetTexture(device, 1, (IDirect3DBaseTexture9 *) tex2);
7922     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7923
7924     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_BUMPENVMAPLUMINANCE);
7925     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7926     scale = 2.0;
7927     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7928     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7929     offset = 0.1;
7930     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7931     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7932
7933     hr = IDirect3DDevice9_BeginScene(device);
7934     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7935     if(SUCCEEDED(hr)) {
7936         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7937         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7938         hr = IDirect3DDevice9_EndScene(device);
7939         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7940     }
7941
7942     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7943     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7944     color = getPixelColor(device, 320, 240);
7945     /* red:   1.0  * (0.25 * 2.0 + 0.1) = 1.0  * 0.6 = 0.6  = 0x99
7946      * green: 0.5  * (0.25 * 2.0 + 0.1) = 0.5  * 0.6 = 0.3  = 0x4c
7947      * green: 0.75 * (0.25 * 2.0 + 0.1) = 0.75 * 0.6 = 0.45 = 0x72
7948      */
7949     ok(color_match(color, 0x00994c72, 5), "bumpmap failed: Got color 0x%08x, expected 0x00994c72.\n", color);
7950
7951     /* Check a result scale factor > 1.0 */
7952     scale = 10;
7953     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7954     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7955     offset = 10;
7956     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7957     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7958
7959     hr = IDirect3DDevice9_BeginScene(device);
7960     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7961     if(SUCCEEDED(hr)) {
7962         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7963         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7964         hr = IDirect3DDevice9_EndScene(device);
7965         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7966     }
7967     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7968     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7969     color = getPixelColor(device, 320, 240);
7970     ok(color_match(color, 0x00ff80c0, 1), "bumpmap failed: Got color 0x%08x, expected 0x00ff80c0.\n", color);
7971
7972     /* Check clamping in the scale factor calculation */
7973     scale = 1000;
7974     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLSCALE, *((DWORD *)&scale));
7975     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7976     offset = -1;
7977     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_BUMPENVLOFFSET, *((DWORD *)&offset));
7978     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
7979
7980     hr = IDirect3DDevice9_BeginScene(device);
7981     ok(SUCCEEDED(hr), "BeginScene failed (0x%08x)\n", hr);
7982     if(SUCCEEDED(hr)) {
7983         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0]));
7984         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (0x%08x)\n", hr);
7985         hr = IDirect3DDevice9_EndScene(device);
7986         ok(SUCCEEDED(hr), "EndScene failed (0x%08x)\n", hr);
7987     }
7988     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
7989     ok(SUCCEEDED(hr), "Present failed (0x%08x)\n", hr);
7990     color = getPixelColor(device, 320, 240);
7991     ok(color_match(color, 0x00ff80c0, 1), "bumpmap failed: Got color 0x%08x, expected 0x00ff80c0.\n", color);
7992
7993     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
7994     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7995     hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
7996     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture failed (%08x)\n", hr);
7997
7998     IDirect3DTexture9_Release(tex1);
7999     IDirect3DTexture9_Release(tex2);
8000
8001 cleanup:
8002     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
8003     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
8004     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_MODULATE);
8005     ok(SUCCEEDED(hr), "SetTextureStageState failed (%08x)\n", hr);
8006
8007     hr = IDirect3DDevice9_SetVertexDeclaration(device, NULL);
8008     ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%08x)\n", hr);
8009     IDirect3DVertexDeclaration9_Release(vertex_declaration);
8010 }
8011
8012 static void stencil_cull_test(IDirect3DDevice9 *device) {
8013     HRESULT hr;
8014     IDirect3DSurface9 *depthstencil = NULL;
8015     D3DSURFACE_DESC desc;
8016     float quad1[] = {
8017         -1.0,   -1.0,   0.1,
8018          0.0,   -1.0,   0.1,
8019         -1.0,    0.0,   0.1,
8020          0.0,    0.0,   0.1,
8021     };
8022     float quad2[] = {
8023          0.0,   -1.0,   0.1,
8024          1.0,   -1.0,   0.1,
8025          0.0,    0.0,   0.1,
8026          1.0,    0.0,   0.1,
8027     };
8028     float quad3[] = {
8029         0.0,    0.0,   0.1,
8030         1.0,    0.0,   0.1,
8031         0.0,    1.0,   0.1,
8032         1.0,    1.0,   0.1,
8033     };
8034     float quad4[] = {
8035         -1.0,    0.0,   0.1,
8036          0.0,    0.0,   0.1,
8037         -1.0,    1.0,   0.1,
8038          0.0,    1.0,   0.1,
8039     };
8040     struct vertex painter[] = {
8041        {-1.0,   -1.0,   0.0,    0x00000000},
8042        { 1.0,   -1.0,   0.0,    0x00000000},
8043        {-1.0,    1.0,   0.0,    0x00000000},
8044        { 1.0,    1.0,   0.0,    0x00000000},
8045     };
8046     WORD indices_cw[]  = {0, 1, 3};
8047     WORD indices_ccw[] = {0, 2, 3};
8048     unsigned int i;
8049     DWORD color;
8050
8051     IDirect3DDevice9_GetDepthStencilSurface(device, &depthstencil);
8052     if(depthstencil == NULL) {
8053         skip("No depth stencil buffer\n");
8054         return;
8055     }
8056     hr = IDirect3DSurface9_GetDesc(depthstencil, &desc);
8057     ok(hr == D3D_OK, "IDirect3DSurface9_GetDesc failed with %08x\n", hr);
8058     IDirect3DSurface9_Release(depthstencil);
8059     if(desc.Format != D3DFMT_D24S8 && desc.Format != D3DFMT_D24X4S4) {
8060         skip("No 4 or 8 bit stencil surface\n");
8061         return;
8062     }
8063
8064     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_STENCIL, 0x00ff0000, 0.0, 0x8);
8065     ok(hr == D3D_OK, "IDirect3DDevice9_Clear returned %08x\n", hr);
8066     IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8067
8068     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_INCR);
8069     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8070     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR);
8071     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8072     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);
8073     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8074     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, 0x3);
8075     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8076
8077     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_REPLACE);
8078     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8079     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_DECR);
8080     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8081     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CCW_STENCILPASS, D3DSTENCILOP_INCR);
8082     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8083
8084     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, TRUE);
8085     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8086     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
8087     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8088
8089     /* First pass: Fill the stencil buffer with some values... */
8090     hr = IDirect3DDevice9_BeginScene(device);
8091     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
8092     if(SUCCEEDED(hr))
8093     {
8094         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
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, quad1, sizeof(float) * 3);
8098         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8099                 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad1, sizeof(float) * 3);
8100
8101         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, TRUE);
8102         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8103         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
8104         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8105         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8106                 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
8107         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8108                 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad2, sizeof(float) * 3);
8109
8110         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CW);
8111         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8112         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8113                 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
8114         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8115                 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad3, sizeof(float) * 3);
8116
8117         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_CCW);
8118         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8119         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8120                 1 /*PrimCount */, indices_cw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
8121         hr = IDirect3DDevice9_DrawIndexedPrimitiveUP(device, D3DPT_TRIANGLELIST, 0 /* MinIndex */, 4 /* NumVerts */,
8122                 1 /*PrimCount */, indices_ccw, D3DFMT_INDEX16, quad4, sizeof(float) * 3);
8123
8124         hr = IDirect3DDevice9_EndScene(device);
8125         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
8126     }
8127
8128     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8129     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP);
8130     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8131     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
8132     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8133     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);
8134     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8135     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TWOSIDEDSTENCILMODE, FALSE);
8136     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8137     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_CULLMODE, D3DCULL_NONE);
8138     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8139     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILFUNC, D3DCMP_EQUAL);
8140     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8141
8142     /* 2nd pass: Make the stencil values visible */
8143     hr = IDirect3DDevice9_BeginScene(device);
8144     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene returned %08x\n", hr);
8145     if(SUCCEEDED(hr))
8146     {
8147         IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8148         for(i = 0; i < 16; i++) {
8149             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILREF, i);
8150             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8151
8152             painter[0].diffuse = (i * 16); /* Creates shades of blue */
8153             painter[1].diffuse = (i * 16);
8154             painter[2].diffuse = (i * 16);
8155             painter[3].diffuse = (i * 16);
8156             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, painter, sizeof(painter[0]));
8157             ok(hr == D3D_OK, "DrawPrimitiveUP failed (%08x)\n", hr);
8158         }
8159         hr = IDirect3DDevice9_EndScene(device);
8160         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene returned %08x\n", hr);
8161     }
8162
8163     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8164     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
8165
8166     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_STENCILENABLE, FALSE);
8167     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8168
8169     color = getPixelColor(device, 160, 420);
8170     ok(color == 0x00000030, "CCW triangle, twoside FALSE, cull cw, replace, has color 0x%08x, expected 0x00000030\n", color);
8171     color = getPixelColor(device, 160, 300);
8172     ok(color == 0x00000080, "CW triangle, twoside FALSE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8173
8174     color = getPixelColor(device, 480, 420);
8175     ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull off, incr, has color 0x%08x, expected 0x00000090\n", color);
8176     color = getPixelColor(device, 480, 300);
8177     ok(color == 0x00000030, "CW triangle, twoside TRUE, cull off, replace, has color 0x%08x, expected 0x00000030\n", color);
8178
8179     color = getPixelColor(device, 160, 180);
8180     ok(color == 0x00000080, "CCW triangle, twoside TRUE, cull ccw, culled, has color 0x%08x, expected 0x00000080\n", color);
8181     color = getPixelColor(device, 160, 60);
8182     ok(color == 0x00000030, "CW triangle, twoside TRUE, cull ccw, replace, has color 0x%08x, expected 0x00000030\n", color);
8183
8184     color = getPixelColor(device, 480, 180);
8185     ok(color == 0x00000090, "CCW triangle, twoside TRUE, cull cw, incr, has color 0x%08x, expected 0x00000090\n", color);
8186     color = getPixelColor(device, 480, 60);
8187     ok(color == 0x00000080, "CW triangle, twoside TRUE, cull cw, culled, has color 0x%08x, expected 0x00000080\n", color);
8188 }
8189
8190 static void vpos_register_test(IDirect3DDevice9 *device)
8191 {
8192     HRESULT hr;
8193     DWORD color;
8194     const DWORD shader_code[] = {
8195     0xffff0300,                                                             /* ps_3_0                     */
8196     0x0200001f, 0x80000000, 0x90031000,                                     /* dcl vPos.xy                */
8197     0x03000002, 0x80030000, 0x90541000, 0xa1fe0000,                         /* sub r0.xy, vPos.xy, c0.zw  */
8198     0x02000001, 0x800f0001, 0xa0e40000,                                     /* mov r1, c0                 */
8199     0x02000001, 0x80080002, 0xa0550000,                                     /* mov r2.a, c0.y             */
8200     0x02000001, 0x80010002, 0xa0550000,                                     /* mov r2.r, c0.y             */
8201     0x04000058, 0x80020002, 0x80000000, 0x80000001, 0x80550001,             /* cmp r2.g, r0.x, r1.x, r1.y */
8202     0x04000058, 0x80040002, 0x80550000, 0x80000001, 0x80550001,             /* cmp r2.b, r0.y, r1.x, r1.y */
8203     0x02000001, 0x800f0800, 0x80e40002,                                     /* mov oC0, r2                */
8204     0x0000ffff                                                              /* end                        */
8205     };
8206     const DWORD shader_frac_code[] = {
8207     0xffff0300,                                                             /* ps_3_0                     */
8208     0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, /* def c0, 0.0, 0.0, 0.0, 0.0 */
8209     0x0200001f, 0x80000000, 0x90031000,                                     /* dcl vPos.xy                */
8210     0x02000001, 0x800f0000, 0xa0e40000,                                     /* mov r0, c0                 */
8211     0x02000013, 0x80030000, 0x90541000,                                     /* frc r0.xy, vPos.xy         */
8212     0x02000001, 0x800f0800, 0x80e40000,                                     /* mov oC0, r0                */
8213     0x0000ffff                                                              /* end                        */
8214     };
8215     IDirect3DPixelShader9 *shader, *shader_frac;
8216     IDirect3DSurface9 *surface = NULL, *backbuffer;
8217     const float quad[] = {
8218         -1.0,   -1.0,   0.1,    0.0,    0.0,
8219          1.0,   -1.0,   0.1,    1.0,    0.0,
8220         -1.0,    1.0,   0.1,    0.0,    1.0,
8221          1.0,    1.0,   0.1,    1.0,    1.0,
8222     };
8223     D3DLOCKED_RECT lr;
8224     float constant[4] = {1.0, 0.0, 320, 240};
8225     DWORD *pos;
8226
8227     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8228     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8229     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &shader);
8230     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
8231     hr = IDirect3DDevice9_CreatePixelShader(device, shader_frac_code, &shader_frac);
8232     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed hr=%08x\n", hr);
8233     hr = IDirect3DDevice9_SetPixelShader(device, shader);
8234     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8235     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8236     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
8237     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8238     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed hr=%08x\n", hr);
8239
8240     hr = IDirect3DDevice9_BeginScene(device);
8241     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8242     if(SUCCEEDED(hr)) {
8243         hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8244         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%08x\n", hr);
8245         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8246         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8247         hr = IDirect3DDevice9_EndScene(device);
8248         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8249     }
8250
8251     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8252     /* This has to be pixel exact */
8253     color = getPixelColor(device, 319, 239);
8254     ok(color == 0x00000000, "vPos: Pixel 319,239 has color 0x%08x, expected 0x00000000\n", color);
8255     color = getPixelColor(device, 320, 239);
8256     ok(color == 0x0000ff00, "vPos: Pixel 320,239 has color 0x%08x, expected 0x0000ff00\n", color);
8257     color = getPixelColor(device, 319, 240);
8258     ok(color == 0x000000ff, "vPos: Pixel 319,240 has color 0x%08x, expected 0x000000ff\n", color);
8259     color = getPixelColor(device, 320, 240);
8260     ok(color == 0x0000ffff, "vPos: Pixel 320,240 has color 0x%08x, expected 0x0000ffff\n", color);
8261
8262     hr = IDirect3DDevice9_CreateRenderTarget(device, 32, 32, D3DFMT_X8R8G8B8, 0, 0, TRUE,
8263                                              &surface, NULL);
8264     ok(hr == D3D_OK, "IDirect3DDevice9_CreateRenderTarget failed hr=%08x\n", hr);
8265     hr = IDirect3DDevice9_BeginScene(device);
8266     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8267     if(SUCCEEDED(hr)) {
8268         constant[2] = 16; constant[3] = 16;
8269         hr = IDirect3DDevice9_SetPixelShaderConstantF(device, 0, constant, 1);
8270         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShaderConstantF failed hr=%08x\n", hr);
8271         hr = IDirect3DDevice9_SetRenderTarget(device, 0, surface);
8272         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8273         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8274         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8275         hr = IDirect3DDevice9_EndScene(device);
8276         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8277     }
8278     hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8279     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%08x\n", hr);
8280
8281     pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8282     color = *pos & 0x00ffffff;
8283     ok(color == 0x00000000, "Pixel 14/14 has color 0x%08x, expected 0x00000000\n", color);
8284     pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 18 * sizeof(DWORD));
8285     color = *pos & 0x00ffffff;
8286     ok(color == 0x0000ff00, "Pixel 14/18 has color 0x%08x, expected 0x0000ff00\n", color);
8287     pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 14 * sizeof(DWORD));
8288     color = *pos & 0x00ffffff;
8289     ok(color == 0x000000ff, "Pixel 18/14 has color 0x%08x, expected 0x000000ff\n", color);
8290     pos = (DWORD *) (((BYTE *) lr.pBits) + 18 * lr.Pitch + 18 * sizeof(DWORD));
8291     color = *pos & 0x00ffffff;
8292     ok(color == 0x0000ffff, "Pixel 18/18 has color 0x%08x, expected 0x0000ffff\n", color);
8293
8294     hr = IDirect3DSurface9_UnlockRect(surface);
8295     ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%08x\n", hr);
8296
8297     /* Test the fraction value of vPos. This is tested with the offscreen target and not the backbuffer to
8298      * have full control over the multisampling setting inside this test
8299      */
8300     hr = IDirect3DDevice9_SetPixelShader(device, shader_frac);
8301     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8302     hr = IDirect3DDevice9_BeginScene(device);
8303     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8304     if(SUCCEEDED(hr)) {
8305         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
8306         ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8307         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
8308         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8309         hr = IDirect3DDevice9_EndScene(device);
8310         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8311     }
8312     hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8313     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8314
8315     hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, D3DLOCK_READONLY);
8316     ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr=%08x\n", hr);
8317
8318     pos = (DWORD *) (((BYTE *) lr.pBits) + 14 * lr.Pitch + 14 * sizeof(DWORD));
8319     color = *pos & 0x00ffffff;
8320     ok(color == 0x00000000, "vPos fraction test has color 0x%08x, expected 0x00000000\n", color);
8321
8322     hr = IDirect3DSurface9_UnlockRect(surface);
8323     ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr=%08x\n", hr);
8324
8325     hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8326     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed hr=%08x\n", hr);
8327     IDirect3DPixelShader9_Release(shader);
8328     IDirect3DPixelShader9_Release(shader_frac);
8329     if(surface) IDirect3DSurface9_Release(surface);
8330     IDirect3DSurface9_Release(backbuffer);
8331 }
8332
8333 static void pointsize_test(IDirect3DDevice9 *device)
8334 {
8335     HRESULT hr;
8336     D3DCAPS9 caps;
8337     D3DMATRIX matrix;
8338     D3DMATRIX identity;
8339     float ptsize, ptsize_orig, ptsizemax_orig, ptsizemin_orig;
8340     DWORD color;
8341
8342     const float vertices[] = {
8343         64,     64,     0.1,
8344         128,    64,     0.1,
8345         192,    64,     0.1,
8346         256,    64,     0.1,
8347         320,    64,     0.1,
8348         384,    64,     0.1,
8349         448,    64,     0.1,
8350         512,    64,     0.1,
8351         576,    64,     0.1,
8352     };
8353
8354     /* 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 */
8355     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;
8356     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;
8357     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;
8358     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;
8359
8360     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;
8361     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;
8362     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;
8363     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;
8364
8365     memset(&caps, 0, sizeof(caps));
8366     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8367     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed hr=%08x\n", hr);
8368     if(caps.MaxPointSize < 32.0) {
8369         skip("MaxPointSize < 32.0, skipping(MaxPointsize = %f)\n", caps.MaxPointSize);
8370         return;
8371     }
8372
8373     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 0.0, 0);
8374     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8375     hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &matrix);
8376     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%08x\n", hr);
8377     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8378     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed hr=%08x\n", hr);
8379     hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE, (DWORD *) &ptsize_orig);
8380     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed hr=%08x\n", hr);
8381
8382     hr = IDirect3DDevice9_BeginScene(device);
8383     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed hr=%08x\n", hr);
8384     if(SUCCEEDED(hr)) {
8385         ptsize = 16.0;
8386         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8387         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8388         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[0], sizeof(float) * 3);
8389         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8390
8391         ptsize = 32.0;
8392         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8393         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8394         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[3], sizeof(float) * 3);
8395         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8396
8397         ptsize = 31.5;
8398         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8399         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8400         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[6], sizeof(float) * 3);
8401         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8402
8403         if(caps.MaxPointSize >= 64.0) {
8404             ptsize = 64.0;
8405             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8406             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8407             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[9], sizeof(float) * 3);
8408             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8409
8410             ptsize = 63.75;
8411             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8412             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8413             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[15], sizeof(float) * 3);
8414             ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8415         }
8416
8417         ptsize = 1.0;
8418         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8419         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8420         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[12], sizeof(float) * 3);
8421         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8422
8423         hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE_MAX, (DWORD *) (&ptsizemax_orig));
8424         ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed, hr=%08x\n", hr);
8425         hr = IDirect3DDevice9_GetRenderState(device, D3DRS_POINTSIZE_MAX, (DWORD *) (&ptsizemin_orig));
8426         ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderState failed, hr=%08x\n", hr);
8427
8428         /* What happens if point scaling is disabled, and POINTSIZE_MAX < POINTSIZE? */
8429         ptsize = 16.0;
8430         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8431         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8432         ptsize = 1.0;
8433         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MAX, *((DWORD *) (&ptsize)));
8434         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8435         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[18], sizeof(float) * 3);
8436         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8437
8438         /* What happens if POINTSIZE_MAX < POINTSIZE_MIN?
8439          * ptsize = 4.0, ptsize_max = 1.0, ptsize_min = 16.0
8440          */
8441         ptsize = 4.0;
8442         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8443         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8444         ptsize = 16.0;
8445         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsize)));
8446         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8447         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[21], sizeof(float) * 3);
8448         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8449
8450         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MAX, *((DWORD *) (&ptsizemax_orig)));
8451         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8452
8453         /* pointsize < pointsize_min < pointsize_max?
8454          * pointsize = 1.0, pointsize_min = 16.0, pointsize_max = default(usually 64.0)
8455          */
8456         ptsize = 1.0;
8457         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize)));
8458         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8459         ptsize = 16.0;
8460         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsize)));
8461         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8462         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_POINTLIST, 1, &vertices[24], sizeof(float) * 3);
8463         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8464
8465         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE_MIN, *((DWORD *) (&ptsizemin_orig)));
8466         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr=%08x\n", hr);
8467
8468         hr = IDirect3DDevice9_EndScene(device);
8469         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed hr=%08x\n", hr);
8470     }
8471     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8472     color = getPixelColor(device, 64-9, 64-9);
8473     ok(color == 0x000000ff, "pSize: Pixel (64-9),(64-9) has color 0x%08x, expected 0x000000ff\n", color);
8474     color = getPixelColor(device, 64-8, 64-8);
8475     todo_wine ok(color == 0x00ffffff, "pSize: Pixel (64-8),(64-8) has color 0x%08x, expected 0x00ffffff\n", color);
8476     color = getPixelColor(device, 64-7, 64-7);
8477     ok(color == 0x00ffffff, "pSize: Pixel (64-7),(64-7) has color 0x%08x, expected 0x00ffffff\n", color);
8478     color = getPixelColor(device, 64+7, 64+7);
8479     ok(color == 0x00ffffff, "pSize: Pixel (64+7),(64+7) has color 0x%08x, expected 0x00ffffff\n", color);
8480     color = getPixelColor(device, 64+8, 64+8);
8481     ok(color == 0x000000ff, "pSize: Pixel (64+8),(64+8) has color 0x%08x, expected 0x000000ff\n", color);
8482     color = getPixelColor(device, 64+9, 64+9);
8483     ok(color == 0x000000ff, "pSize: Pixel (64+9),(64+9) has color 0x%08x, expected 0x000000ff\n", color);
8484
8485     color = getPixelColor(device, 128-17, 64-17);
8486     ok(color == 0x000000ff, "pSize: Pixel (128-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8487     color = getPixelColor(device, 128-16, 64-16);
8488     todo_wine ok(color == 0x00ffffff, "pSize: Pixel (128-16),(64-16) has color 0x%08x, expected 0x00ffffff\n", color);
8489     color = getPixelColor(device, 128-15, 64-15);
8490     ok(color == 0x00ffffff, "pSize: Pixel (128-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8491     color = getPixelColor(device, 128+15, 64+15);
8492     ok(color == 0x00ffffff, "pSize: Pixel (128+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8493     color = getPixelColor(device, 128+16, 64+16);
8494     ok(color == 0x000000ff, "pSize: Pixel (128+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8495     color = getPixelColor(device, 128+17, 64+17);
8496     ok(color == 0x000000ff, "pSize: Pixel (128+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8497
8498     color = getPixelColor(device, 192-17, 64-17);
8499     ok(color == 0x000000ff, "pSize: Pixel (192-17),(64-17) has color 0x%08x, expected 0x000000ff\n", color);
8500     color = getPixelColor(device, 192-16, 64-16);
8501     ok(color == 0x000000ff, "pSize: Pixel (192-16),(64-16) has color 0x%08x, expected 0x000000ff\n", color);
8502     color = getPixelColor(device, 192-15, 64-15);
8503     ok(color == 0x00ffffff, "pSize: Pixel (192-15),(64-15) has color 0x%08x, expected 0x00ffffff\n", color);
8504     color = getPixelColor(device, 192+15, 64+15);
8505     ok(color == 0x00ffffff, "pSize: Pixel (192+15),(64+15) has color 0x%08x, expected 0x00ffffff\n", color);
8506     color = getPixelColor(device, 192+16, 64+16);
8507     ok(color == 0x000000ff, "pSize: Pixel (192+16),(64+16) has color 0x%08x, expected 0x000000ff\n", color);
8508     color = getPixelColor(device, 192+17, 64+17);
8509     ok(color == 0x000000ff, "pSize: Pixel (192+17),(64+17) has color 0x%08x, expected 0x000000ff\n", color);
8510
8511     if(caps.MaxPointSize >= 64.0) {
8512         color = getPixelColor(device, 256-33, 64-33);
8513         ok(color == 0x000000ff, "pSize: Pixel (256-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8514         color = getPixelColor(device, 256-32, 64-32);
8515         todo_wine ok(color == 0x00ffffff, "pSize: Pixel (256-32),(64-32) has color 0x%08x, expected 0x00ffffff\n", color);
8516         color = getPixelColor(device, 256-31, 64-31);
8517         ok(color == 0x00ffffff, "pSize: Pixel (256-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8518         color = getPixelColor(device, 256+31, 64+31);
8519         ok(color == 0x00ffffff, "pSize: Pixel (256+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8520         color = getPixelColor(device, 256+32, 64+32);
8521         ok(color == 0x000000ff, "pSize: Pixel (256+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8522         color = getPixelColor(device, 256+33, 64+33);
8523         ok(color == 0x000000ff, "pSize: Pixel (256+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8524
8525         color = getPixelColor(device, 384-33, 64-33);
8526         ok(color == 0x000000ff, "pSize: Pixel (384-33),(64-33) has color 0x%08x, expected 0x000000ff\n", color);
8527         color = getPixelColor(device, 384-32, 64-32);
8528         ok(color == 0x000000ff, "pSize: Pixel (384-32),(64-32) has color 0x%08x, expected 0x000000ff\n", color);
8529         color = getPixelColor(device, 384-31, 64-31);
8530         ok(color == 0x00ffffff, "pSize: Pixel (384-31),(64-31) has color 0x%08x, expected 0x00ffffff\n", color);
8531         color = getPixelColor(device, 384+31, 64+31);
8532         ok(color == 0x00ffffff, "pSize: Pixel (384+31),(64+31) has color 0x%08x, expected 0x00ffffff\n", color);
8533         color = getPixelColor(device, 384+32, 64+32);
8534         ok(color == 0x000000ff, "pSize: Pixel (384+32),(64+32) has color 0x%08x, expected 0x000000ff\n", color);
8535         color = getPixelColor(device, 384+33, 64+33);
8536         ok(color == 0x000000ff, "pSize: Pixel (384+33),(64+33) has color 0x%08x, expected 0x000000ff\n", color);
8537     }
8538
8539     color = getPixelColor(device, 320-1, 64-1);
8540     ok(color == 0x000000ff, "pSize: Pixel (320-1),(64-1) has color 0x%08x, expected 0x000000ff\n", color);
8541     color = getPixelColor(device, 320-0, 64-0);
8542     ok(color == 0x00ffffff, "pSize: Pixel (320-0),(64-0) has color 0x%08x, expected 0x00ffffff\n", color);
8543     color = getPixelColor(device, 320+1, 64+1);
8544     ok(color == 0x000000ff, "pSize: Pixel (320+1),(64+1) has color 0x%08x, expected 0x000000ff\n", color);
8545
8546     /* ptsize = 16, ptsize_max = 1 --> point has size 1 */
8547     color = getPixelColor(device, 448-4, 64-4);
8548     ok(color == 0x000000ff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8549     color = getPixelColor(device, 448+4, 64+4);
8550     ok(color == 0x000000ff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8551
8552     /* ptsize = 4, ptsize_max = 1, ptsize_min = 16 --> point has size 1 */
8553     color = getPixelColor(device, 512-4, 64-4);
8554     ok(color == 0x000000ff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8555     color = getPixelColor(device, 512+4, 64+4);
8556     ok(color == 0x000000ff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8557
8558     /* ptsize = 1, ptsize_max = default(64), ptsize_min = 16 --> point has size 16
8559      * Don't be overly picky - just show that the point is bigger than 1 pixel
8560      */
8561     color = getPixelColor(device, 576-4, 64-4);
8562     ok(color == 0x00ffffff, "pSize: Pixel (448-4),(64-4) has color 0x%08x, expected 0x00ffffff\n", color);
8563     color = getPixelColor(device, 576+4, 64+4);
8564     ok(color == 0x00ffffff, "pSize: Pixel (448+4),(64+4) has color 0x%08x, expected 0x00ffffff\n", color);
8565
8566     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_POINTSIZE, *((DWORD *) (&ptsize_orig)));
8567     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed hr=%08x\n", hr);
8568     hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &identity);
8569     ok(hr == D3D_OK, "IDirect3DDevice9_SetTransform failed, hr=%08x\n", hr);
8570 }
8571
8572 static void multiple_rendertargets_test(IDirect3DDevice9 *device)
8573 {
8574     HRESULT hr;
8575     IDirect3DPixelShader9 *ps;
8576     IDirect3DTexture9 *tex1, *tex2;
8577     IDirect3DSurface9 *surf1, *surf2, *backbuf;
8578     D3DCAPS9 caps;
8579     DWORD color;
8580     DWORD shader_code[] = {
8581     0xffff0300,                                                             /* ps_3_0             */
8582     0x05000051, 0xa00f0000, 0x00000000, 0x3f800000, 0x00000000, 0x00000000, /* def c0, 0, 1, 0, 0 */
8583     0x05000051, 0xa00f0001, 0x00000000, 0x00000000, 0x3f800000, 0x00000000, /* def c1, 0, 0, 1, 0 */
8584     0x02000001, 0x800f0800, 0xa0e40000,                                     /* mov oC0, c0        */
8585     0x02000001, 0x800f0801, 0xa0e40001,                                     /* mov oC1, c1        */
8586     0x0000ffff                                                              /* END                */
8587     };
8588     float quad[] = {
8589        -1.0,   -1.0,    0.1,
8590         1.0,   -1.0,    0.1,
8591        -1.0,    1.0,    0.1,
8592         1.0,    1.0,    0.1,
8593     };
8594     float texquad[] = {
8595        -1.0,   -1.0,    0.1,    0.0,    0.0,
8596         0.0,   -1.0,    0.1,    1.0,    0.0,
8597        -1.0,    1.0,    0.1,    0.0,    1.0,
8598         0.0,    1.0,    0.1,    1.0,    1.0,
8599
8600         0.0,   -1.0,    0.1,    0.0,    0.0,
8601         1.0,   -1.0,    0.1,    1.0,    0.0,
8602         0.0,    1.0,    0.1,    0.0,    1.0,
8603         1.0,    1.0,    0.1,    1.0,    1.0,
8604     };
8605
8606     memset(&caps, 0, sizeof(caps));
8607     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8608     ok(hr == D3D_OK, "IDirect3DDevice9_GetCaps failed, hr=%08x\n", hr);
8609     if(caps.NumSimultaneousRTs < 2) {
8610         skip("Only 1 simultaneous render target supported, skipping MRT test\n");
8611         return;
8612     }
8613
8614     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffff0000, 0.0, 0);
8615     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed, hr=%08x\n", hr);
8616
8617     hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex1, NULL);
8618     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
8619     hr = IDirect3DDevice9_CreateTexture(device, 16, 16, 1, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &tex2, NULL);
8620     ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed, hr=%08x\n", hr);
8621     hr = IDirect3DDevice9_CreatePixelShader(device, shader_code, &ps);
8622     ok(hr == D3D_OK, "IDirect3DDevice9_CreatePixelShader failed, hr=%08x\n", hr);
8623
8624     hr = IDirect3DDevice9_GetRenderTarget(device, 0, &backbuf);
8625     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr=%08x\n", hr);
8626     hr = IDirect3DTexture9_GetSurfaceLevel(tex1, 0, &surf1);
8627     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%08x\n", hr);
8628     hr = IDirect3DTexture9_GetSurfaceLevel(tex2, 0, &surf2);
8629     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed, hr=%08x\n", hr);
8630
8631     hr = IDirect3DDevice9_SetPixelShader(device, ps);
8632     ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
8633     hr = IDirect3DDevice9_SetRenderTarget(device, 0, surf1);
8634     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8635     hr = IDirect3DDevice9_SetRenderTarget(device, 1, surf2);
8636     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8637     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ);
8638     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
8639
8640     hr = IDirect3DDevice9_BeginScene(device);
8641     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr=%08x\n", hr);
8642     if(SUCCEEDED(hr)) {
8643         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, 3 * sizeof(float));
8644         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8645
8646         hr = IDirect3DDevice9_SetPixelShader(device, NULL);
8647         ok(hr == D3D_OK, "IDirect3DDevice9_SetPixelShader failed, hr=%08x\n", hr);
8648         hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuf);
8649         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8650         hr = IDirect3DDevice9_SetRenderTarget(device, 1, NULL);
8651         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed, hr=%08x\n", hr);
8652         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8653         ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr=%08x\n", hr);
8654
8655         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex1);
8656         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8657         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[0], 5 * sizeof(float));
8658         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8659
8660         hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) tex2);
8661         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8662         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &texquad[20], 5 * sizeof(float));
8663         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed, hr=%08x\n", hr);
8664
8665         hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
8666         ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr=%08x\n", hr);
8667
8668         hr = IDirect3DDevice9_EndScene(device);
8669         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr=%08x\n", hr);
8670     }
8671
8672     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8673     color = getPixelColor(device, 160, 240);
8674     ok(color == 0x0000ff00, "Texture 1(output color 1) has color 0x%08x, expected 0x0000ff00\n", color);
8675     color = getPixelColor(device, 480, 240);
8676     ok(color == 0x000000ff, "Texture 2(output color 2) has color 0x%08x, expected 0x000000ff\n", color);
8677
8678     IDirect3DPixelShader9_Release(ps);
8679     IDirect3DTexture9_Release(tex1);
8680     IDirect3DTexture9_Release(tex2);
8681     IDirect3DSurface9_Release(surf1);
8682     IDirect3DSurface9_Release(surf2);
8683     IDirect3DSurface9_Release(backbuf);
8684 }
8685
8686 struct formats {
8687     const char *fmtName;
8688     D3DFORMAT textureFormat;
8689     DWORD resultColorBlending;
8690     DWORD resultColorNoBlending;
8691 };
8692
8693 const struct formats test_formats[] = {
8694   { "D3DFMT_G16R16", D3DFMT_G16R16, 0x001818ff, 0x002010ff},
8695   { "D3DFMT_R16F", D3DFMT_R16F, 0x0018ffff, 0x0020ffff },
8696   { "D3DFMT_G16R16F", D3DFMT_G16R16F, 0x001818ff, 0x002010ff },
8697   { "D3DFMT_A16B16G16R16F", D3DFMT_A16B16G16R16F, 0x00181800, 0x00201000 },
8698   { "D3DFMT_R32F", D3DFMT_R32F, 0x0018ffff, 0x0020ffff },
8699   { "D3DFMT_G32R32F", D3DFMT_G32R32F, 0x001818ff, 0x002010ff },
8700   { "D3DFMT_A32B32G32R32F", D3DFMT_A32B32G32R32F, 0x00181800, 0x00201000 },
8701   { NULL, 0 }
8702 };
8703
8704 static void pixelshader_blending_test(IDirect3DDevice9 *device)
8705 {
8706     HRESULT hr;
8707     IDirect3DTexture9 *offscreenTexture = NULL;
8708     IDirect3DSurface9 *backbuffer = NULL, *offscreen = NULL;
8709     IDirect3D9 *d3d = NULL;
8710     DWORD color;
8711     DWORD r0, g0, b0, r1, g1, b1;
8712     int fmt_index;
8713
8714     static const float quad[][5] = {
8715         {-0.5f, -0.5f, 0.1f, 0.0f, 0.0f},
8716         {-0.5f,  0.5f, 0.1f, 0.0f, 1.0f},
8717         { 0.5f, -0.5f, 0.1f, 1.0f, 0.0f},
8718         { 0.5f,  0.5f, 0.1f, 1.0f, 1.0f},
8719     };
8720
8721     /* Quad with R=0x10, G=0x20 */
8722     static const struct vertex quad1[] = {
8723         {-1.0f, -1.0f, 0.1f, 0x80102000},
8724         {-1.0f,  1.0f, 0.1f, 0x80102000},
8725         { 1.0f, -1.0f, 0.1f, 0x80102000},
8726         { 1.0f,  1.0f, 0.1f, 0x80102000},
8727     };
8728
8729     /* Quad with R=0x20, G=0x10 */
8730     static const struct vertex quad2[] = {
8731         {-1.0f, -1.0f, 0.1f, 0x80201000},
8732         {-1.0f,  1.0f, 0.1f, 0x80201000},
8733         { 1.0f, -1.0f, 0.1f, 0x80201000},
8734         { 1.0f,  1.0f, 0.1f, 0x80201000},
8735     };
8736
8737     IDirect3DDevice9_GetDirect3D(device, &d3d);
8738
8739     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
8740     ok(hr == D3D_OK, "Can't get back buffer, hr = %08x\n", hr);
8741     if(!backbuffer) {
8742         goto out;
8743     }
8744
8745     for(fmt_index=0; test_formats[fmt_index].textureFormat != 0; fmt_index++)
8746     {
8747         D3DFORMAT fmt = test_formats[fmt_index].textureFormat;
8748         if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0, D3DRTYPE_TEXTURE, fmt) != D3D_OK) {
8749            skip("%s textures not supported\n", test_formats[fmt_index].fmtName);
8750            continue;
8751         }
8752
8753         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
8754         ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
8755
8756         hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 1, D3DUSAGE_RENDERTARGET, fmt, D3DPOOL_DEFAULT, &offscreenTexture, NULL);
8757         ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "Creating the offscreen render target failed, hr = %08x\n", hr);
8758         if(!offscreenTexture) {
8759             continue;
8760         }
8761
8762         hr = IDirect3DTexture9_GetSurfaceLevel(offscreenTexture, 0, &offscreen);
8763         ok(hr == D3D_OK, "Can't get offscreen surface, hr = %08x\n", hr);
8764         if(!offscreen) {
8765             continue;
8766         }
8767
8768         hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8769         ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
8770
8771         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8772         ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8773         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
8774         ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8775         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
8776         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MINFILTER failed (0x%08x)\n", hr);
8777         hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
8778         ok(SUCCEEDED(hr), "SetSamplerState D3DSAMP_MAGFILTER failed (0x%08x)\n", hr);
8779         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
8780         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState returned %08x\n", hr);
8781
8782         /* Below we will draw two quads with different colors and try to blend them together.
8783          * The result color is compared with the expected outcome.
8784          */
8785         if(IDirect3DDevice9_BeginScene(device) == D3D_OK) {
8786             hr = IDirect3DDevice9_SetRenderTarget(device, 0, offscreen);
8787             ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
8788             hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x00ffffff, 0.0, 0);
8789             ok(hr == D3D_OK, "Clear failed, hr = %08x\n", hr);
8790
8791             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, TRUE);
8792             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8793
8794             /* Draw a quad using color 0x0010200 */
8795             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_ONE);
8796             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8797             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_ZERO);
8798             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8799             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(quad1[0]));
8800             ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8801
8802             /* Draw a quad using color 0x0020100 */
8803             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
8804             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8805             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
8806             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8807             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(quad2[0]));
8808             ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %#08x\n", hr);
8809
8810             /* We don't want to blend the result on the backbuffer */
8811             hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ALPHABLENDENABLE, FALSE);
8812             ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8813
8814             /* Prepare rendering the 'blended' texture quad to the backbuffer */
8815             hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8816             ok(hr == D3D_OK, "SetRenderTarget failed, hr = %08x\n", hr);
8817             hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) offscreenTexture);
8818             ok(hr == D3D_OK, "SetTexture failed, %08x\n", hr);
8819
8820             hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
8821             ok(hr == D3D_OK, "SetFVF failed, hr = %08x\n", hr);
8822
8823             /* This time with the texture */
8824             hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8825             ok(hr == D3D_OK, "DrawPrimitiveUP failed, hr = %08x\n", hr);
8826
8827             IDirect3DDevice9_EndScene(device);
8828         }
8829         IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8830
8831
8832         if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, fmt) == D3D_OK) {
8833             /* Compare the color of the center quad with our expectation */
8834             color = getPixelColor(device, 320, 240);
8835             r0 = (color & 0x00ff0000) >> 16;
8836             g0 = (color & 0x0000ff00) >>  8;
8837             b0 = (color & 0x000000ff) >>  0;
8838
8839             r1 = (test_formats[fmt_index].resultColorBlending & 0x00ff0000) >> 16;
8840             g1 = (test_formats[fmt_index].resultColorBlending & 0x0000ff00) >>  8;
8841             b1 = (test_formats[fmt_index].resultColorBlending & 0x000000ff) >>  0;
8842
8843             ok(r0 >= max(r1, 1) - 1 && r0 <= r1 + 1 &&
8844                g0 >= max(g1, 1) - 1 && g0 <= g1 + 1 &&
8845                b0 >= max(b1, 1) - 1 && b0 <= b1 + 1,
8846                "Offscreen failed for %s: Got color %#08x, expected %#08x.\n", test_formats[fmt_index].fmtName, color, test_formats[fmt_index].resultColorBlending);
8847         } else {
8848             /* No pixel shader blending is supported so expected garbage.The type of 'garbage' depends on the driver version and OS.
8849              * E.g. on G16R16 ati reports (on old r9600 drivers) 0x00ffffff and on modern ones 0x002010ff which is also what Nvidia
8850              * reports. On Vista Nvidia seems to report 0x00ffffff on Geforce7 cards. */
8851             color = getPixelColor(device, 320, 240);
8852             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);
8853         }
8854
8855         IDirect3DDevice9_SetTexture(device, 0, NULL);
8856         if(offscreenTexture) {
8857             IDirect3DTexture9_Release(offscreenTexture);
8858         }
8859         if(offscreen) {
8860             IDirect3DSurface9_Release(offscreen);
8861         }
8862     }
8863
8864 out:
8865     /* restore things */
8866     if(backbuffer) {
8867         IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
8868         IDirect3DSurface9_Release(backbuffer);
8869     }
8870 }
8871
8872 static void tssargtemp_test(IDirect3DDevice9 *device)
8873 {
8874     HRESULT hr;
8875     DWORD color;
8876     static const struct vertex quad[] = {
8877         {-1.0,     -1.0,    0.1,    0x00ff0000},
8878         { 1.0,     -1.0,    0.1,    0x00ff0000},
8879         {-1.0,      1.0,    0.1,    0x00ff0000},
8880         { 1.0,      1.0,    0.1,    0x00ff0000}
8881     };
8882     D3DCAPS9 caps;
8883
8884     memset(&caps, 0, sizeof(caps));
8885     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
8886     ok(hr == D3D_OK, "IDirect3DDevice9_GetDeviceCaps failed with %08x\n", hr);
8887     if(!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_TSSARGTEMP)) {
8888         skip("D3DPMISCCAPS_TSSARGTEMP not supported\n");
8889         return;
8890     }
8891
8892     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
8893     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
8894
8895     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8896     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8897     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
8898     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8899
8900     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
8901     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8902     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_TFACTOR);
8903     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8904     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_TEMP);
8905     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8906
8907     hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_ADD);
8908     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8909     hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG1, D3DTA_CURRENT);
8910     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8911     hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLORARG2, D3DTA_TEMP);
8912     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8913
8914     hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8915     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8916
8917     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x0000ff00);
8918     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed, hr = %08x\n", hr);
8919     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
8920     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %08x\n", hr);
8921
8922     hr = IDirect3DDevice9_BeginScene(device);
8923     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed, hr = %08x\n", hr);
8924     if(SUCCEEDED(hr)) {
8925
8926         hr = IDirect3DDevice9_EndScene(device);
8927         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed, hr = %08x\n", hr);
8928         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(quad[0]));
8929         ok(hr == D3D_OK, "IDirect3DDevice9_DrawPrimitiveUP failed with %08x\n", hr);
8930     }
8931     IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
8932     color = getPixelColor(device, 320, 240);
8933     ok(color == 0x00FFFF00, "TSSARGTEMP test returned color 0x%08x, expected 0x00FFFF00\n", color);
8934
8935     /* Set stage 1 back to default */
8936     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_RESULTARG, D3DTA_CURRENT);
8937     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8938     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
8939     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8940     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
8941     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8942     hr = IDirect3DDevice9_SetTextureStageState(device, 2, D3DTSS_COLOROP, D3DTOP_DISABLE);
8943     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8944     hr = IDirect3DDevice9_SetTextureStageState(device, 3, D3DTSS_COLOROP, D3DTOP_DISABLE);
8945     ok(hr == D3D_OK, "SetTextureStageState failed, hr = %08x\n", hr);
8946 }
8947
8948 struct testdata
8949 {
8950     DWORD idxVertex; /* number of instances in the first stream */
8951     DWORD idxColor; /* number of instances in the second stream */
8952     DWORD idxInstance; /* should be 1 ?? */
8953     DWORD color1; /* color 1 instance */
8954     DWORD color2; /* color 2 instance */
8955     DWORD color3; /* color 3 instance */
8956     DWORD color4; /* color 4 instance */
8957     WORD strVertex; /* specify which stream to use 0-2*/
8958     WORD strColor;
8959     WORD strInstance;
8960 };
8961
8962 static const struct testdata testcases[]=
8963 {
8964     {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /*  0 */
8965     {3, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /*  1 */
8966     {2, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /*  2 */
8967     {1, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /*  3 */
8968     {0, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0, 1, 2}, /*  4 */
8969     {4, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /*  5 */
8970     {4, 2, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /*  6 */
8971     {4, 1, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /*  7 */
8972     {4, 0, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 1, 2}, /*  8 */
8973     {3, 3, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ffffff, 0, 1, 2}, /*  9 */
8974     {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 0, 2}, /* 10 */
8975     {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0, 2, 1}, /* 11 */
8976     {4, 4, 1, 0x00ff0000, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 3, 1}, /* 12 */
8977     {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 2, 0, 1}, /* 13 */
8978     {4, 4, 1, 0x00ff0000, 0x00ff0000, 0x00ff0000, 0x00ff0000, 1, 2, 3}, /* 14 */
8979 /*
8980     This case is handled in a stand alone test, SetStreamSourceFreq(0,(D3DSTREAMSOURCE_INSTANCEDATA | 1))  has to return D3DERR_INVALIDCALL!
8981     {4, 4, 1, 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff, 2, 1, 0, D3DERR_INVALIDCALL},
8982 */
8983 };
8984
8985 /* Drawing Indexed Geometry with instances*/
8986 static void stream_test(IDirect3DDevice9 *device)
8987 {
8988     IDirect3DVertexBuffer9 *vb = NULL;
8989     IDirect3DVertexBuffer9 *vb2 = NULL;
8990     IDirect3DVertexBuffer9 *vb3 = NULL;
8991     IDirect3DIndexBuffer9 *ib = NULL;
8992     IDirect3DVertexDeclaration9 *pDecl = NULL;
8993     IDirect3DVertexShader9 *shader = NULL;
8994     HRESULT hr;
8995     BYTE *data;
8996     DWORD color;
8997     DWORD ind;
8998     unsigned i;
8999
9000     const DWORD shader_code[] =
9001     {
9002         0xfffe0101,                                     /* vs_1_1 */
9003         0x0000001f, 0x80000000, 0x900f0000,             /* dcl_position v0 */
9004         0x0000001f, 0x8000000a, 0x900f0001,             /* dcl_color0 v1 */
9005         0x0000001f, 0x80000005, 0x900f0002,             /* dcl_texcoord v2 */
9006         0x00000001, 0x800f0000, 0x90e40000,             /* mov r0, v0 */
9007         0x00000002, 0xc00f0000, 0x80e40000, 0x90e40002, /* add oPos, r0, v2 */
9008         0x00000001, 0xd00f0000, 0x90e40001,             /* mov oD0, v1 */
9009         0x0000ffff
9010     };
9011
9012     const float quad[][3] =
9013     {
9014         {-0.5f, -0.5f,  1.1f}, /*0 */
9015         {-0.5f,  0.5f,  1.1f}, /*1 */
9016         { 0.5f, -0.5f,  1.1f}, /*2 */
9017         { 0.5f,  0.5f,  1.1f}, /*3 */
9018     };
9019
9020     const float vertcolor[][4] =
9021     {
9022         {1.0f, 0.0f, 0.0f, 1.0f}, /*0 */
9023         {1.0f, 0.0f, 0.0f, 1.0f}, /*1 */
9024         {1.0f, 0.0f, 0.0f, 1.0f}, /*2 */
9025         {1.0f, 0.0f, 0.0f, 1.0f}, /*3 */
9026     };
9027
9028     /* 4 position for 4 instances */
9029     const float instancepos[][3] =
9030     {
9031         {-0.6f,-0.6f, 0.0f},
9032         { 0.6f,-0.6f, 0.0f},
9033         { 0.6f, 0.6f, 0.0f},
9034         {-0.6f, 0.6f, 0.0f},
9035     };
9036
9037     short indices[] = {0, 1, 2, 1, 2, 3};
9038
9039     D3DVERTEXELEMENT9 decl[] =
9040     {
9041         {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
9042         {1, 0,  D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
9043         {2, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
9044         D3DDECL_END()
9045     };
9046
9047     /* set the default value because it isn't done in wine? */
9048     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
9049     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9050
9051     /* check for D3DSTREAMSOURCE_INDEXEDDATA at stream0 */
9052     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 0, (D3DSTREAMSOURCE_INSTANCEDATA | 1));
9053     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9054
9055     /* check wrong cases */
9056     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 0);
9057     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9058     hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9059     ok(hr == D3D_OK && ind == 1, "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9060     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 2);
9061     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9062     hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9063     ok(hr == D3D_OK && ind == 2, "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9064     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INDEXEDDATA | 0));
9065     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9066     hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9067     ok(hr == D3D_OK && ind == (D3DSTREAMSOURCE_INDEXEDDATA | 0), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9068     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | 0));
9069     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9070     hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9071     ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9072     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, (D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA | 0));
9073     ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9074     hr = IDirect3DDevice9_GetStreamSourceFreq(device, 1, &ind);
9075     ok(hr == D3D_OK && ind == (0 | D3DSTREAMSOURCE_INSTANCEDATA), "IDirect3DDevice9_GetStreamSourceFreq failed with %08x\n", hr);
9076
9077     /* set the default value back */
9078     hr = IDirect3DDevice9_SetStreamSourceFreq(device, 1, 1);
9079     ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x\n", hr);
9080
9081     /* create all VertexBuffers*/
9082     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(quad), 0, 0, D3DPOOL_MANAGED, &vb, NULL);
9083     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9084     if(!vb) {
9085         skip("Failed to create a vertex buffer\n");
9086         return;
9087     }
9088     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(vertcolor), 0, 0, D3DPOOL_MANAGED, &vb2, NULL);
9089     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9090     if(!vb2) {
9091         skip("Failed to create a vertex buffer\n");
9092         goto out;
9093     }
9094     hr = IDirect3DDevice9_CreateVertexBuffer(device, sizeof(instancepos), 0, 0, D3DPOOL_MANAGED, &vb3, NULL);
9095     ok(hr == D3D_OK, "CreateVertexBuffer failed with %08x\n", hr);
9096     if(!vb3) {
9097         skip("Failed to create a vertex buffer\n");
9098         goto out;
9099     }
9100
9101     /* create IndexBuffer*/
9102     hr = IDirect3DDevice9_CreateIndexBuffer(device, sizeof(indices), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &ib, NULL);
9103     ok(hr == D3D_OK, "IDirect3DDevice9_CreateIndexBuffer failed with %08x\n", hr);
9104     if(!ib) {
9105         skip("Failed to create a index buffer\n");
9106         goto out;
9107     }
9108
9109     /* copy all Buffers (Vertex + Index)*/
9110     hr = IDirect3DVertexBuffer9_Lock(vb, 0, sizeof(quad), (void **) &data, 0);
9111     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9112     memcpy(data, quad, sizeof(quad));
9113     hr = IDirect3DVertexBuffer9_Unlock(vb);
9114     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9115     hr = IDirect3DVertexBuffer9_Lock(vb2, 0, sizeof(vertcolor), (void **) &data, 0);
9116     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9117     memcpy(data, vertcolor, sizeof(vertcolor));
9118     hr = IDirect3DVertexBuffer9_Unlock(vb2);
9119     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9120     hr = IDirect3DVertexBuffer9_Lock(vb3, 0, sizeof(instancepos), (void **) &data, 0);
9121     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Lock failed with %08x\n", hr);
9122     memcpy(data, instancepos, sizeof(instancepos));
9123     hr = IDirect3DVertexBuffer9_Unlock(vb3);
9124     ok(hr == D3D_OK, "IDirect3DVertexBuffer9_Unlock failed with %08x\n", hr);
9125     hr = IDirect3DIndexBuffer9_Lock(ib, 0, sizeof(indices), (void **) &data, 0);
9126     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Lock failed with %08x\n", hr);
9127     memcpy(data, indices, sizeof(indices));
9128     hr = IDirect3DIndexBuffer9_Unlock(ib);
9129     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
9130
9131     /* create VertexShader */
9132     hr = IDirect3DDevice9_CreateVertexShader(device, shader_code, &shader);
9133     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexShader failed hr=%08x\n", hr);
9134     if(!shader) {
9135         skip("Failed to create a vetex shader\n");
9136         goto out;
9137     }
9138
9139     hr = IDirect3DDevice9_SetVertexShader(device, shader);
9140     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetVertexShader failed hr=%08x\n", hr);
9141
9142     hr = IDirect3DDevice9_SetIndices(device, ib);
9143     ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x\n", hr);
9144
9145     /* run all tests */
9146     for( i = 0; i < sizeof(testcases)/sizeof(testcases[0]); ++i)
9147     {
9148         struct testdata act = testcases[i];
9149         decl[0].Stream = act.strVertex;
9150         decl[1].Stream = act.strColor;
9151         decl[2].Stream = act.strInstance;
9152         /* create VertexDeclarations */
9153         hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl, &pDecl);
9154         ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateVertexDeclaration failed hr=%08x (case %i)\n", hr, i);
9155
9156         hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0xffffffff, 0.0, 0);
9157         ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x (case %i)\n", hr, i);
9158
9159         hr = IDirect3DDevice9_BeginScene(device);
9160         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x (case %i)\n", hr, i);
9161         if(SUCCEEDED(hr))
9162         {
9163             hr = IDirect3DDevice9_SetVertexDeclaration(device, pDecl);
9164             ok(hr == D3D_OK, "IDirect3DDevice9_SetVertexDeclaration failed with %08x (case %i)\n", hr, i);
9165
9166             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxVertex));
9167             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9168             hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, vb, 0, sizeof(quad[0]));
9169             ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9170
9171             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strColor, (D3DSTREAMSOURCE_INDEXEDDATA | act.idxColor));
9172             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9173             hr = IDirect3DDevice9_SetStreamSource(device, act.strColor, vb2, 0, sizeof(vertcolor[0]));
9174             ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9175
9176             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strInstance, (D3DSTREAMSOURCE_INSTANCEDATA | act.idxInstance));
9177             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9178             hr = IDirect3DDevice9_SetStreamSource(device, act.strInstance, vb3, 0, sizeof(instancepos[0]));
9179             ok(hr == D3D_OK, "IDirect3DIndexBuffer9_Unlock failed with %08x (case %i)\n", hr, i);
9180
9181             /* don't know if this is right (1*3 and 4*1)*/
9182             hr = IDirect3DDevice9_DrawIndexedPrimitive(device, D3DPT_TRIANGLELIST, 0, 0, 1 * 3 , 0, 4*1);
9183             ok(hr == D3D_OK, "IDirect3DDevice9_DrawIndexedPrimitive failed with %08x (case %i)\n", hr, i);
9184             hr = IDirect3DDevice9_EndScene(device);
9185             ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x (case %i)\n", hr, i);
9186
9187             /* set all StreamSource && StreamSourceFreq back to default */
9188             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.strVertex, 1);
9189             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9190             hr = IDirect3DDevice9_SetStreamSource(device, act.strVertex, NULL, 0, 0);
9191             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9192             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxColor, 1);
9193             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9194             hr = IDirect3DDevice9_SetStreamSource(device, act.idxColor, NULL, 0, 0);
9195             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9196             hr = IDirect3DDevice9_SetStreamSourceFreq(device, act.idxInstance, 1);
9197             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSourceFreq failed with %08x (case %i)\n", hr, i);
9198             hr = IDirect3DDevice9_SetStreamSource(device, act.idxInstance, NULL, 0, 0);
9199             ok(hr == D3D_OK, "IDirect3DDevice9_SetStreamSource failed with %08x (case %i)\n", hr, i);
9200         }
9201
9202         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9203         ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x (case %i)\n", hr, i);
9204
9205         hr = IDirect3DVertexDeclaration9_Release(pDecl);
9206         ok(hr == D3D_OK, "IDirect3DVertexDeclaration9_Release failed with %08x (case %i)\n", hr, i);
9207
9208         color = getPixelColor(device, 160, 360);
9209         ok(color == act.color1, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color1, i);
9210         color = getPixelColor(device, 480, 360);
9211         ok(color == act.color2, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color2, i);
9212         color = getPixelColor(device, 480, 120);
9213         ok(color == act.color3, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color3, i);
9214         color = getPixelColor(device, 160, 120);
9215         ok(color == act.color4, "has color 0x%08x, expected 0x%08x (case %i)\n", color, act.color4, i);
9216     }
9217
9218     hr = IDirect3DDevice9_SetIndices(device, NULL);
9219     ok(hr == D3D_OK, "IDirect3DDevice9_SetIndices failed with %08x\n", hr);
9220
9221 out:
9222     if(vb) IDirect3DVertexBuffer9_Release(vb);
9223     if(vb2)IDirect3DVertexBuffer9_Release(vb2);
9224     if(vb3)IDirect3DVertexBuffer9_Release(vb3);
9225     if(ib)IDirect3DIndexBuffer9_Release(ib);
9226     if(shader)IDirect3DVertexShader9_Release(shader);
9227 }
9228
9229 static void np2_stretch_rect_test(IDirect3DDevice9 *device) {
9230     IDirect3DSurface9 *src = NULL, *dst = NULL, *backbuffer = NULL;
9231     IDirect3DTexture9 *dsttex = NULL;
9232     HRESULT hr;
9233     DWORD color;
9234     D3DRECT r1 = {0,  0,  50,  50 };
9235     D3DRECT r2 = {50, 0,  100, 50 };
9236     D3DRECT r3 = {50, 50, 100, 100};
9237     D3DRECT r4 = {0,  50,  50, 100};
9238     const float quad[] = {
9239         -1.0,   -1.0,   0.1,    0.0,    0.0,
9240          1.0,   -1.0,   0.1,    1.0,    0.0,
9241         -1.0,    1.0,   0.1,    0.0,    1.0,
9242          1.0,    1.0,   0.1,    1.0,    1.0,
9243     };
9244
9245     hr = IDirect3DDevice9_GetBackBuffer(device, 0, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
9246     ok(hr == D3D_OK, "IDirect3DDevice9_GetBackBuffer failed with %08x\n", hr);
9247
9248     hr = IDirect3DDevice9_CreateRenderTarget(device, 100, 100, D3DFMT_A8R8G8B8, D3DMULTISAMPLE_NONE, 0, TRUE, &src, NULL );
9249     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateRenderTarget failed with %08x\n", hr);
9250     hr = IDirect3DDevice9_CreateTexture(device, 25, 25, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &dsttex, NULL);
9251     ok(hr == D3D_OK || hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr);
9252
9253     if(!src || !dsttex) {
9254         skip("One or more test resources could not be created\n");
9255         goto cleanup;
9256     }
9257
9258     hr = IDirect3DTexture9_GetSurfaceLevel(dsttex, 0, &dst);
9259     ok(hr == D3D_OK, "IDirect3DTexture9_GetSurfaceLevel failed with %08x\n", hr);
9260
9261     hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xff00ffff, 0.0, 0);
9262     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9263
9264     /* Clear the StretchRect destination for debugging */
9265     hr = IDirect3DDevice9_SetRenderTarget(device, 0, dst);
9266     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9267     hr = IDirect3DDevice9_Clear(device, 1, NULL, D3DCLEAR_TARGET, 0xffff00ff, 0.0, 0);
9268     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9269
9270     hr = IDirect3DDevice9_SetRenderTarget(device, 0, src);
9271     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9272
9273     hr = IDirect3DDevice9_Clear(device, 1, &r1, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9274     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9275     hr = IDirect3DDevice9_Clear(device, 1, &r2, D3DCLEAR_TARGET, 0xff00ff00, 0.0, 0);
9276     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9277     hr = IDirect3DDevice9_Clear(device, 1, &r3, D3DCLEAR_TARGET, 0xff0000ff, 0.0, 0);
9278     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9279     hr = IDirect3DDevice9_Clear(device, 1, &r4, D3DCLEAR_TARGET, 0xff000000, 0.0, 0);
9280     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with %08x\n", hr);
9281
9282     /* Stretchrect before setting the render target back to the backbuffer. This will make Wine use
9283      * the target -> texture GL blit path
9284      */
9285     hr = IDirect3DDevice9_StretchRect(device, src, NULL, dst, NULL, D3DTEXF_POINT);
9286     ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with %08x\n", hr);
9287     IDirect3DSurface9_Release(dst);
9288
9289     hr = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
9290     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderTarget failed with %08x\n", hr);
9291
9292     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) dsttex);
9293     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9294     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1);
9295     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with %08x\n", hr);
9296     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9297     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9298     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9299     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9300
9301     hr = IDirect3DDevice9_BeginScene(device);
9302     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with %08x\n", hr);
9303     if(SUCCEEDED(hr)) {
9304         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(float) * 5);
9305         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%08x)\n", hr);
9306         hr = IDirect3DDevice9_EndScene(device);
9307         ok(hr == D3D_OK, "IDirect3DDevice9_EndScene failed with %08x\n", hr);
9308     }
9309
9310     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9311     ok(hr == D3D_OK, "IDirect3DDevice9_Present failed with %08x\n", hr);
9312     color = getPixelColor(device, 160, 360);
9313     ok(color == 0x00ff0000, "stretchrect: Pixel 160,360 has color 0x%08x, expected 0x00ff0000\n", color);
9314     color = getPixelColor(device, 480, 360);
9315     ok(color == 0x0000ff00, "stretchrect: Pixel 480,360 has color 0x%08x, expected 0x0000ff00\n", color);
9316     color = getPixelColor(device, 480, 120);
9317     ok(color == 0x000000ff, "stretchrect: Pixel 480,120 has color 0x%08x, expected 0x000000ff\n", color);
9318     color = getPixelColor(device, 160, 120);
9319     ok(color == 0x00000000, "stretchrect: Pixel 160,120 has color 0x%08x, expected 0x00000000\n", color);
9320
9321     hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
9322     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9323     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9324     ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed with %08x\n", hr);
9325
9326 cleanup:
9327     if(src) IDirect3DSurface9_Release(src);
9328     if(backbuffer) IDirect3DSurface9_Release(backbuffer);
9329     if(dsttex) IDirect3DTexture9_Release(dsttex);
9330 }
9331
9332 static void texop_test(IDirect3DDevice9 *device)
9333 {
9334     IDirect3DVertexDeclaration9 *vertex_declaration = NULL;
9335     IDirect3DTexture9 *texture = NULL;
9336     D3DLOCKED_RECT locked_rect;
9337     D3DCOLOR color;
9338     D3DCAPS9 caps;
9339     HRESULT hr;
9340     unsigned i;
9341
9342     static const struct {
9343         float x, y, z;
9344         float s, t;
9345         D3DCOLOR diffuse;
9346     } quad[] = {
9347         {-1.0f, -1.0f, 0.1f, -1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9348         {-1.0f,  1.0f, 0.1f, -1.0f,  1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9349         { 1.0f, -1.0f, 0.1f,  1.0f, -1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)},
9350         { 1.0f,  1.0f, 0.1f,  1.0f,  1.0f, D3DCOLOR_ARGB(0x55, 0xff, 0x00, 0x00)}
9351     };
9352
9353     static const D3DVERTEXELEMENT9 decl_elements[] = {
9354         {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
9355         {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
9356         {0, 20, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
9357         D3DDECL_END()
9358     };
9359
9360     static const struct {
9361         D3DTEXTUREOP op;
9362         const char *name;
9363         DWORD caps_flag;
9364         D3DCOLOR result;
9365     } test_data[] = {
9366         {D3DTOP_SELECTARG1,                "SELECTARG1",                D3DTEXOPCAPS_SELECTARG1,                D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9367         {D3DTOP_SELECTARG2,                "SELECTARG2",                D3DTEXOPCAPS_SELECTARG2,                D3DCOLOR_ARGB(0x00, 0x33, 0x33, 0x33)},
9368         {D3DTOP_MODULATE,                  "MODULATE",                  D3DTEXOPCAPS_MODULATE,                  D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x00)},
9369         {D3DTOP_MODULATE2X,                "MODULATE2X",                D3DTEXOPCAPS_MODULATE2X,                D3DCOLOR_ARGB(0x00, 0x00, 0x66, 0x00)},
9370         {D3DTOP_MODULATE4X,                "MODULATE4X",                D3DTEXOPCAPS_MODULATE4X,                D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9371         {D3DTOP_ADD,                       "ADD",                       D3DTEXOPCAPS_ADD,                       D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9372         {D3DTOP_ADDSIGNED,                 "ADDSIGNED",                 D3DTEXOPCAPS_ADDSIGNED,                 D3DCOLOR_ARGB(0x00, 0x00, 0xb2, 0x00)},
9373         {D3DTOP_ADDSIGNED2X,               "ADDSIGNED2X",               D3DTEXOPCAPS_ADDSIGNED2X,               D3DCOLOR_ARGB(0x00, 0x00, 0xff, 0x00)},
9374         {D3DTOP_SUBTRACT,                  "SUBTRACT",                  D3DTEXOPCAPS_SUBTRACT,                  D3DCOLOR_ARGB(0x00, 0x00, 0xcc, 0x00)},
9375         {D3DTOP_ADDSMOOTH,                 "ADDSMOOTH",                 D3DTEXOPCAPS_ADDSMOOTH,                 D3DCOLOR_ARGB(0x00, 0x33, 0xff, 0x33)},
9376         {D3DTOP_BLENDDIFFUSEALPHA,         "BLENDDIFFUSEALPHA",         D3DTEXOPCAPS_BLENDDIFFUSEALPHA,         D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9377         {D3DTOP_BLENDTEXTUREALPHA,         "BLENDTEXTUREALPHA",         D3DTEXOPCAPS_BLENDTEXTUREALPHA,         D3DCOLOR_ARGB(0x00, 0x14, 0xad, 0x14)},
9378         {D3DTOP_BLENDFACTORALPHA,          "BLENDFACTORALPHA",          D3DTEXOPCAPS_BLENDFACTORALPHA,          D3DCOLOR_ARGB(0x00, 0x07, 0xe4, 0x07)},
9379         {D3DTOP_BLENDTEXTUREALPHAPM,       "BLENDTEXTUREALPHAPM",       D3DTEXOPCAPS_BLENDTEXTUREALPHAPM,       D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9380         {D3DTOP_BLENDCURRENTALPHA,         "BLENDCURRENTALPHA",         D3DTEXOPCAPS_BLENDCURRENTALPHA,         D3DCOLOR_ARGB(0x00, 0x22, 0x77, 0x22)},
9381         {D3DTOP_MODULATEALPHA_ADDCOLOR,    "MODULATEALPHA_ADDCOLOR",    D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR,    D3DCOLOR_ARGB(0x00, 0x1f, 0xff, 0x1f)},
9382         {D3DTOP_MODULATECOLOR_ADDALPHA,    "MODULATECOLOR_ADDALPHA",    D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA,    D3DCOLOR_ARGB(0x00, 0x99, 0xcc, 0x99)},
9383         {D3DTOP_MODULATEINVALPHA_ADDCOLOR, "MODULATEINVALPHA_ADDCOLOR", D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR, D3DCOLOR_ARGB(0x00, 0x14, 0xff, 0x14)},
9384         {D3DTOP_MODULATEINVCOLOR_ADDALPHA, "MODULATEINVCOLOR_ADDALPHA", D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA, D3DCOLOR_ARGB(0x00, 0xcc, 0x99, 0xcc)},
9385         /* BUMPENVMAP & BUMPENVMAPLUMINANCE have their own tests */
9386         {D3DTOP_DOTPRODUCT3,               "DOTPRODUCT2",               D3DTEXOPCAPS_DOTPRODUCT3,               D3DCOLOR_ARGB(0x00, 0x99, 0x99, 0x99)},
9387         {D3DTOP_MULTIPLYADD,               "MULTIPLYADD",               D3DTEXOPCAPS_MULTIPLYADD,               D3DCOLOR_ARGB(0x00, 0xff, 0x33, 0x00)},
9388         {D3DTOP_LERP,                      "LERP",                      D3DTEXOPCAPS_LERP,                      D3DCOLOR_ARGB(0x00, 0x00, 0x33, 0x33)},
9389     };
9390
9391     memset(&caps, 0, sizeof(caps));
9392     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9393     ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9394
9395     hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration);
9396     ok(SUCCEEDED(hr), "CreateVertexDeclaration failed with 0x%08x\n", hr);
9397     hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration);
9398     ok(SUCCEEDED(hr), "SetVertexDeclaration failed with 0x%08x\n", hr);
9399
9400     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
9401     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed with 0x%08x\n", hr);
9402     hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
9403     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9404     *((DWORD *)locked_rect.pBits) = D3DCOLOR_ARGB(0x99, 0x00, 0xff, 0x00);
9405     hr = IDirect3DTexture9_UnlockRect(texture, 0);
9406     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9407     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
9408     ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9409
9410     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG0, D3DTA_DIFFUSE);
9411     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9412     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9413     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9414     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9415     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9416
9417     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9418     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9419
9420     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE);
9421     ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9422     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0xdd333333);
9423     ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9424     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA);
9425     ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9426
9427     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9428     ok(SUCCEEDED(hr), "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9429
9430     for (i = 0; i < sizeof(test_data) / sizeof(*test_data); ++i)
9431     {
9432         if (!(caps.TextureOpCaps & test_data[i].caps_flag))
9433         {
9434             skip("tex operation %s not supported\n", test_data[i].name);
9435             continue;
9436         }
9437
9438         hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, test_data[i].op);
9439         ok(SUCCEEDED(hr), "SetTextureStageState (%s) failed with 0x%08x\n", test_data[i].name, hr);
9440
9441         hr = IDirect3DDevice9_BeginScene(device);
9442         ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9443
9444         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9445         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9446
9447         hr = IDirect3DDevice9_EndScene(device);
9448         ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9449
9450         hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9451         ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9452
9453         color = getPixelColor(device, 320, 240);
9454         ok(color_match(color, test_data[i].result, 3), "Operation %s returned color 0x%08x, expected 0x%08x\n",
9455                 test_data[i].name, color, test_data[i].result);
9456     }
9457
9458     if (texture) IDirect3DTexture9_Release(texture);
9459     if (vertex_declaration) IDirect3DVertexDeclaration9_Release(vertex_declaration);
9460 }
9461
9462 static void yuv_color_test(IDirect3DDevice9 *device) {
9463     HRESULT hr;
9464     IDirect3DSurface9 *surface = NULL, *target = NULL;
9465     unsigned int fmt, i;
9466     D3DFORMAT format;
9467     const char *fmt_string;
9468     D3DLOCKED_RECT lr;
9469     IDirect3D9 *d3d;
9470     HRESULT color;
9471     DWORD ref_color_left, ref_color_right;
9472
9473     struct {
9474         DWORD in;           /* The input color */
9475         DWORD uyvy_left;    /* "in" interpreted as uyvy and transformed to RGB, pixel 1/1*/
9476         DWORD uyvy_right;   /* "in" interpreted as uyvy and transformed to RGB, pixel 2/1*/
9477         DWORD yuy2_left;    /* "in" interpreted as yuy2 and transformed to RGB, pixel 1/1 */
9478         DWORD yuy2_right;   /* "in" interpreted as yuy2 and transformed to RGB, pixel 2/1 */
9479     } test_data[] = {
9480     /* Originally I wanted to avoid being evil, and set Y1 = Y2 to avoid triggering troubles in shader converters,
9481      * but the main difference between YUY2 and UYVY is the swapped ordering of the chroma and luminance
9482      * values. However, handling the two Y's properly could have a big impact on image quality, so be picky about
9483      * that
9484      */
9485       { 0x00000000, 0x00008700, 0x00008700, 0x00008700, 0x00008700 },
9486       { 0xff000000, 0x00008700, 0x004bff1c, 0x00b30000, 0x00b30000 },
9487       { 0x00ff0000, 0x00b30000, 0x00b30000, 0x00008700, 0x004bff1c },
9488       { 0x0000ff00, 0x004bff1c, 0x00008700, 0x000030e1, 0x000030e1 },
9489       { 0x000000ff, 0x000030e1, 0x000030e1, 0x004bff1c, 0x00008700 },
9490       { 0xffff0000, 0x00b30000, 0x00ffd01c, 0x00b30000, 0x00ffd01c },
9491       { 0xff00ff00, 0x004bff1c, 0x004bff1c, 0x00b300e1, 0x00b300e1 },
9492       { 0xff0000ff, 0x000030e1, 0x004bffff, 0x00ffd01c, 0x00b30000 },
9493       { 0x00ffff00, 0x00ffd01c, 0x00b30000, 0x000030e1, 0x004bffff },
9494       { 0x00ff00ff, 0x00b300e1, 0x00b300e1, 0x004bff1c, 0x004bff1c },
9495       { 0x0000ffff, 0x004bffff, 0x000030e1, 0x004bffff, 0x000030e1 },
9496       { 0xffffff00, 0x00ffd01c, 0x00ffd01c, 0x00b300e1, 0x00ff79ff },
9497       { 0xffff00ff, 0x00b300e1, 0x00ff79ff, 0x00ffd01c, 0x00ffd01c },
9498       { 0xffffffff, 0x00ff79ff, 0x00ff79ff, 0x00ff79ff, 0x00ff79ff },
9499
9500       { 0x4cff4c54, 0x00ff0000, 0x00ff0000, 0x000b8b00, 0x00b6ffa3 },
9501       { 0x00800080, 0x00000000, 0x00000000, 0x0000ff00, 0x0000ff00 },
9502       { 0xFF80FF80, 0x00ffffff, 0x00ffffff, 0x00ff00ff, 0x00ff00ff },
9503       { 0x1c6b1cff, 0x000000fd, 0x000000fd, 0x006dff45, 0x0000d500 },
9504     };
9505
9506     hr = IDirect3DDevice9_GetDirect3D(device, &d3d);
9507     ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D failed, hr = %08x\n", hr);
9508     hr = IDirect3DDevice9_GetRenderTarget(device, 0, &target);
9509     ok(hr == D3D_OK, "IDirect3DDevice9_GetRenderTarget failed, hr = %08x\n", hr);
9510
9511     IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX0);
9512     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed, hr = %08x\n", hr);
9513
9514     for(fmt = 0; fmt < 2; fmt++) {
9515         if(fmt == 0) {
9516             format = D3DFMT_UYVY;
9517             fmt_string = "D3DFMT_UYVY";
9518         } else {
9519             format = D3DFMT_YUY2;
9520             fmt_string = "D3DFMT_YUY2";
9521         }
9522
9523         /* Some(all?) Windows drivers do not support YUV 3D textures, only 2D surfaces in StretchRect. Thus use
9524                        * StretchRect to draw the YUV surface onto the screen instead of drawPrimitive
9525                        */
9526         if(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0,
9527                                         D3DRTYPE_SURFACE, format) != D3D_OK) {
9528             skip("%s is not supported\n", fmt_string);
9529             continue;
9530         }
9531
9532         /* A pixel is effectively 16 bit large, but two pixels are stored together, so the minimum size is 2x1 */
9533         hr = IDirect3DDevice9_CreateOffscreenPlainSurface(device, 2, 1, format, D3DPOOL_DEFAULT, &surface, NULL);
9534         ok(hr == D3D_OK, "IDirect3DDevice9_CreateOffscreenPlainSurface failed, hr = %08x\n", hr);
9535
9536         for(i = 0; i < (sizeof(test_data)/sizeof(test_data[0])); i++) {
9537             if(fmt == 0) {
9538                 ref_color_left = test_data[i].uyvy_left;
9539                 ref_color_right = test_data[i].uyvy_right;
9540             } else {
9541                 ref_color_left = test_data[i].yuy2_left;
9542                 ref_color_right = test_data[i].yuy2_right;
9543             }
9544
9545             memset(&lr, 0, sizeof(lr));
9546             hr = IDirect3DSurface9_LockRect(surface, &lr, NULL, 0);
9547             ok(hr == D3D_OK, "IDirect3DSurface9_LockRect failed, hr = %08x\n", hr);
9548             *((DWORD *) lr.pBits) = test_data[i].in;
9549             hr = IDirect3DSurface9_UnlockRect(surface);
9550             ok(hr == D3D_OK, "IDirect3DSurface9_UnlockRect failed, hr = %08x\n", hr);
9551
9552             hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9553             ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9554             hr = IDirect3DDevice9_StretchRect(device, surface, NULL, target, NULL, D3DTEXF_POINT);
9555             ok(hr == D3D_OK, "IDirect3DDevice9_StretchRect failed with 0x%08x\n", hr);
9556             hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9557             ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9558
9559             /* Native D3D can't resist filtering the YUY surface, even though we asked it not to do so above. To
9560              * prevent running into precision problems, read a far left and far right pixel. In the future we may
9561              * want to add tests for the filtered pixels as well.
9562              *
9563              * Unfortunately different implementations(Windows-NV and Mac-ATI tested) interpret some colors vastly
9564              * differently, so we need a max diff of 16
9565              */
9566             color = getPixelColor(device, 40, 240);
9567             ok(color_match(color, ref_color_left, 16),
9568                "Input 0x%08x: Got color 0x%08x for pixel 1/1, expected 0x%08x, format %s\n",
9569                test_data[i].in, color, ref_color_left, fmt_string);
9570             color = getPixelColor(device, 600, 240);
9571             ok(color_match(color, ref_color_right, 16),
9572                "Input 0x%08x: Got color 0x%08x for pixel 2/1, expected 0x%08x, format %s\n",
9573                test_data[i].in, color, ref_color_left, fmt_string);
9574         }
9575         IDirect3DSurface9_Release(surface);
9576     }
9577     IDirect3DSurface9_Release(target);
9578     IDirect3D9_Release(d3d);
9579 }
9580
9581 static void texop_range_test(IDirect3DDevice9 *device)
9582 {
9583     static const struct {
9584         float x, y, z;
9585         D3DCOLOR diffuse;
9586     } quad[] = {
9587         {-1.0f, -1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9588         {-1.0f,  1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9589         { 1.0f, -1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)},
9590         { 1.0f,  1.0f, 0.1f, D3DCOLOR_ARGB(0xff, 0xff, 0xff, 0xff)}
9591     };
9592     HRESULT hr;
9593     IDirect3DTexture9 *texture;
9594     D3DLOCKED_RECT locked_rect;
9595     D3DCAPS9 caps;
9596     DWORD color;
9597
9598     /* We need ADD and SUBTRACT operations */
9599     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9600     ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9601     if (!(caps.TextureOpCaps & D3DTEXOPCAPS_ADD)) {
9602         skip("D3DTOP_ADD is not supported, skipping value range test\n");
9603     }
9604     if (!(caps.TextureOpCaps & D3DTEXOPCAPS_SUBTRACT)) {
9605         skip("D3DTEXOPCAPS_SUBTRACT is not supported, skipping value range test\n");
9606     }
9607
9608     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9609     ok(SUCCEEDED(hr), "SetFVF failed with 0x%08x\n", hr);
9610     /* Stage 1: result = diffuse(=1.0) + diffuse
9611      * stage 2: result = result - tfactor(= 0.5)
9612      */
9613     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x80808080);
9614     ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9615     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
9616     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9617     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
9618     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9619     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_ADD);
9620     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9621     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT);
9622     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9623     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9624     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9625     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SUBTRACT);
9626     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9627
9628     hr = IDirect3DDevice9_BeginScene(device);
9629     ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9630     hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9631     ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9632     hr = IDirect3DDevice9_EndScene(device);
9633     ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9634     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9635     ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9636
9637     color = getPixelColor(device, 320, 240);
9638     ok(color_match(color, 0x00808080, 1), "texop Range > 1.0 returned 0x%08x, expected 0x00808080\n",
9639        color);
9640
9641     hr = IDirect3DDevice9_CreateTexture(device, 1, 1, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL);
9642     ok(SUCCEEDED(hr), "IDirect3DDevice9_CreateTexture failed with 0x%08x\n", hr);
9643     hr = IDirect3DTexture9_LockRect(texture, 0, &locked_rect, NULL, 0);
9644     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9645     *((DWORD *)locked_rect.pBits) = D3DCOLOR_ARGB(0x00, 0x00, 0x00, 0x00);
9646     hr = IDirect3DTexture9_UnlockRect(texture, 0);
9647     ok(SUCCEEDED(hr), "LockRect failed with 0x%08x\n", hr);
9648     hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture);
9649     ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9650
9651     /* Stage 1: result = texture(=0.0) - tfactor(= 0.5)
9652      * stage 2: result = result + diffuse(1.0)
9653      */
9654     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0x80808080);
9655     ok(SUCCEEDED(hr), "SetRenderState failed with 0x%08x\n", hr);
9656     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
9657     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9658     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9659     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9660     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SUBTRACT);
9661     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9662     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT);
9663     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9664     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
9665     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9666     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_ADD);
9667     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9668
9669     hr = IDirect3DDevice9_BeginScene(device);
9670     ok(SUCCEEDED(hr), "BeginScene failed with 0x%08x\n", hr);
9671     hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9672     ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9673     hr = IDirect3DDevice9_EndScene(device);
9674     ok(SUCCEEDED(hr), "EndScene failed with 0x%08x\n", hr);
9675     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9676     ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9677
9678     color = getPixelColor(device, 320, 240);
9679     ok(color_match(color, 0x00ffffff, 1), "texop Range < 0.0 returned 0x%08x, expected 0x00ffffff\n",
9680        color);
9681
9682     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9683     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9684     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9685     ok(SUCCEEDED(hr), "SetTextureStageState failed with 0x%08x\n", hr);
9686     hr = IDirect3DDevice9_SetTexture(device, 1, NULL);
9687     ok(SUCCEEDED(hr), "SetTexture failed with 0x%08x\n", hr);
9688     IDirect3DTexture9_Release(texture);
9689 }
9690
9691 static void alphareplicate_test(IDirect3DDevice9 *device) {
9692     struct vertex quad[] = {
9693         { -1.0,    -1.0,    0.1,    0x80ff00ff },
9694         {  1.0,    -1.0,    0.1,    0x80ff00ff },
9695         { -1.0,     1.0,    0.1,    0x80ff00ff },
9696         {  1.0,     1.0,    0.1,    0x80ff00ff },
9697     };
9698     HRESULT hr;
9699     DWORD color;
9700
9701     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9702     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9703
9704     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9705     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9706
9707     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9708     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9709     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE | D3DTA_ALPHAREPLICATE);
9710     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9711
9712     hr = IDirect3DDevice9_BeginScene(device);
9713     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9714     if(SUCCEEDED(hr)) {
9715         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9716         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9717         hr = IDirect3DDevice9_EndScene(device);
9718         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9719     }
9720
9721     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9722     ok(SUCCEEDED(hr), "Present failed with 0x%08x\n", hr);
9723
9724     color = getPixelColor(device, 320, 240);
9725     ok(color_match(color, 0x00808080, 1), "alphareplicate test 0x%08x, expected 0x00808080\n",
9726        color);
9727
9728     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9729     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9730
9731 }
9732
9733 static void dp3_alpha_test(IDirect3DDevice9 *device) {
9734     HRESULT hr;
9735     D3DCAPS9 caps;
9736     DWORD color;
9737     struct vertex quad[] = {
9738         { -1.0,    -1.0,    0.1,    0x408080c0 },
9739         {  1.0,    -1.0,    0.1,    0x408080c0 },
9740         { -1.0,     1.0,    0.1,    0x408080c0 },
9741         {  1.0,     1.0,    0.1,    0x408080c0 },
9742     };
9743
9744     memset(&caps, 0, sizeof(caps));
9745     hr = IDirect3DDevice9_GetDeviceCaps(device, &caps);
9746     ok(SUCCEEDED(hr), "GetDeviceCaps failed with 0x%08x\n", hr);
9747     if (!(caps.TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)) {
9748         skip("D3DTOP_DOTPRODUCT3 not supported\n");
9749         return;
9750     }
9751
9752     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
9753     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9754
9755     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9756     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9757
9758     /* dp3_x4 r0, diffuse_bias, tfactor_bias
9759      * mov r0.a, diffuse.a
9760      * mov r0, r0.a
9761      *
9762      * It turns out that the 2nd line is ignored, and the dp3 result written into r0.a instead
9763      * 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
9764      * (0.0 * 0.5 + 0.0 * 0.5 + 0.25 * 0.5) * 4 = 0.125 * 4 = 0.5, with a bunch of inprecision.
9765      */
9766     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DOTPRODUCT3);
9767     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9768     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
9769     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9770     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
9771     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9772     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
9773     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9774     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
9775     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9776     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
9777     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9778     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLORARG1, D3DTA_CURRENT | D3DTA_ALPHAREPLICATE);
9779     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9780     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
9781     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9782     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_TEXTUREFACTOR, 0xffffffff);
9783     ok(SUCCEEDED(hr), "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9784
9785     hr = IDirect3DDevice9_BeginScene(device);
9786     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9787     if(SUCCEEDED(hr)) {
9788         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
9789         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9790         hr = IDirect3DDevice9_EndScene(device);
9791         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9792     }
9793
9794     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9795     ok(SUCCEEDED(hr), "IDirect3DDevice9_Present failed with 0x%08x\n", hr);
9796
9797     color = getPixelColor(device, 320, 240);
9798     ok(color_match(color, 0x00808080, 4), "dp3 alpha test 0x%08x, expected 0x00808080\n",
9799        color);
9800
9801     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_COLOROP, D3DTOP_DISABLE);
9802     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9803     hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
9804     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9805     hr = IDirect3DDevice9_SetTextureStageState(device, 1, D3DTSS_COLOROP, D3DTOP_DISABLE);
9806     ok(hr == D3D_OK, "IDirect3DDevice9_SetTextureStageState failed with 0x%08x\n", hr);
9807 }
9808
9809 static void zwriteenable_test(IDirect3DDevice9 *device) {
9810     HRESULT hr;
9811     DWORD color;
9812     struct vertex quad1[] = {
9813         { -1.0,  -1.0,  0.1,    0x00ff0000},
9814         { -1.0,   1.0,  0.1,    0x00ff0000},
9815         {  1.0,  -1.0,  0.1,    0x00ff0000},
9816         {  1.0,   1.0,  0.1,    0x00ff0000},
9817     };
9818     struct vertex quad2[] = {
9819         { -1.0,  -1.0,  0.9,    0x0000ff00},
9820         { -1.0,   1.0,  0.9,    0x0000ff00},
9821         {  1.0,  -1.0,  0.9,    0x0000ff00},
9822         {  1.0,   1.0,  0.9,    0x0000ff00},
9823     };
9824
9825     hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x000000ff, 1.0f, 0);
9826     ok(hr == D3D_OK, "IDirect3DDevice9_Clear failed with 0x%08x\n", hr);
9827
9828     hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_DIFFUSE);
9829     ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF failed with 0x%08x\n", hr);
9830     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
9831     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9832     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE, TRUE);
9833     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9834     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
9835     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9836
9837     hr = IDirect3DDevice9_BeginScene(device);
9838     ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9839     if(SUCCEEDED(hr)) {
9840         /* The Z buffer is filled with 1.0. Draw a red quad with z = 0.1, zenable = D3DZB_FALSE, zwriteenable = TRUE.
9841          * The red color is written because the z test is disabled. The question is whether the z = 0.1 values
9842          * are written into the Z buffer. After the draw, set zenable = TRUE and draw a green quad at z = 0.9.
9843          * If the values are written, the z test will fail(0.9 > 0.1) and the red color remains. If the values
9844          * are not written, the z test succeeds(0.9 < 1.0) and the green color is written. It turns out that
9845          * the screen is green, so zenable = D3DZB_FALSE and zwriteenable  = TRUE does NOT write to the z buffer.
9846          */
9847         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad1, sizeof(*quad1));
9848         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9849         hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_TRUE);
9850         ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9851         hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad2, sizeof(*quad2));
9852         ok(SUCCEEDED(hr), "DrawPrimitiveUP failed with 0x%08x\n", hr);
9853
9854         hr = IDirect3DDevice9_EndScene(device);
9855         ok(hr == D3D_OK, "IDirect3DDevice9_BeginScene failed with 0x%08x\n", hr);
9856     }
9857
9858     hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
9859     ok(SUCCEEDED(hr), "IDirect3DDevice9_Present failed with 0x%08x\n", hr);
9860     color = getPixelColor(device, 320, 240);
9861     ok(color_match(color, 0x0000ff00, 1), "zwriteenable test returned 0x%08x, expected 0x0000ff00\n",
9862        color);
9863
9864     hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, D3DZB_FALSE);
9865     ok(hr == D3D_OK, "IDirect3DDevice9_SetRenderState failed with 0x%08x\n", hr);
9866 }
9867
9868 START_TEST(visual)
9869 {
9870     IDirect3DDevice9 *device_ptr;
9871     D3DCAPS9 caps;
9872     HRESULT hr;
9873     DWORD color;
9874
9875     d3d9_handle = LoadLibraryA("d3d9.dll");
9876     if (!d3d9_handle)
9877     {
9878         skip("Could not load d3d9.dll\n");
9879         return;
9880     }
9881
9882     device_ptr = init_d3d9();
9883     if (!device_ptr)
9884     {
9885         skip("Creating the device failed\n");
9886         return;
9887     }
9888
9889     IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps);
9890
9891     /* Check for the reliability of the returned data */
9892     hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xffff0000, 0.0, 0);
9893     if(FAILED(hr))
9894     {
9895         skip("Clear failed, can't assure correctness of the test results, skipping\n");
9896         goto cleanup;
9897     }
9898     IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9899
9900     color = getPixelColor(device_ptr, 1, 1);
9901     if(color !=0x00ff0000)
9902     {
9903         skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9904         goto cleanup;
9905     }
9906
9907     hr = IDirect3DDevice9_Clear(device_ptr, 0, NULL, D3DCLEAR_TARGET, 0xff00ddee, 0.0, 0);
9908     if(FAILED(hr))
9909     {
9910         skip("Clear failed, can't assure correctness of the test results, skipping\n");
9911         goto cleanup;
9912     }
9913     IDirect3DDevice9_Present(device_ptr, NULL, NULL, NULL, NULL);
9914
9915     color = getPixelColor(device_ptr, 639, 479);
9916     if(color != 0x0000ddee)
9917     {
9918         skip("Sanity check returned an incorrect color(%08x), can't assure the correctness of the tests, skipping\n", color);
9919         goto cleanup;
9920     }
9921
9922     /* Now execute the real tests */
9923     stretchrect_test(device_ptr);
9924     lighting_test(device_ptr);
9925     clear_test(device_ptr);
9926     fog_test(device_ptr);
9927     if(caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
9928     {
9929         test_cube_wrap(device_ptr);
9930     } else {
9931         skip("No cube texture support\n");
9932     }
9933     z_range_test(device_ptr);
9934     if(caps.TextureCaps & D3DPTEXTURECAPS_MIPMAP)
9935     {
9936         maxmip_test(device_ptr);
9937     }
9938     else
9939     {
9940         skip("No mipmap support\n");
9941     }
9942     offscreen_test(device_ptr);
9943     alpha_test(device_ptr);
9944     shademode_test(device_ptr);
9945     srgbtexture_test(device_ptr);
9946     release_buffer_test(device_ptr);
9947     float_texture_test(device_ptr);
9948     g16r16_texture_test(device_ptr);
9949     pixelshader_blending_test(device_ptr);
9950     texture_transform_flags_test(device_ptr);
9951     autogen_mipmap_test(device_ptr);
9952     fixed_function_decl_test(device_ptr);
9953     conditional_np2_repeat_test(device_ptr);
9954     fixed_function_bumpmap_test(device_ptr);
9955     if(caps.StencilCaps & D3DSTENCILCAPS_TWOSIDED) {
9956         stencil_cull_test(device_ptr);
9957     } else {
9958         skip("No two sided stencil support\n");
9959     }
9960     pointsize_test(device_ptr);
9961     tssargtemp_test(device_ptr);
9962     np2_stretch_rect_test(device_ptr);
9963     yuv_color_test(device_ptr);
9964     zwriteenable_test(device_ptr);
9965
9966     if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1))
9967     {
9968         test_constant_clamp_vs(device_ptr);
9969         test_compare_instructions(device_ptr);
9970     }
9971     else skip("No vs_1_1 support\n");
9972
9973     if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0))
9974     {
9975         test_mova(device_ptr);
9976         if (caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
9977             test_vshader_input(device_ptr);
9978             test_vshader_float16(device_ptr);
9979             stream_test(device_ptr);
9980         } else {
9981             skip("No vs_3_0 support\n");
9982         }
9983     }
9984     else skip("No vs_2_0 support\n");
9985
9986     if (caps.VertexShaderVersion >= D3DVS_VERSION(1, 1) && caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9987     {
9988         fog_with_shader_test(device_ptr);
9989         fog_srgbwrite_test(device_ptr);
9990     }
9991     else skip("No vs_1_1 and ps_1_1 support\n");
9992
9993     if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
9994     {
9995         texbem_test(device_ptr);
9996         texdepth_test(device_ptr);
9997         texkill_test(device_ptr);
9998         x8l8v8u8_test(device_ptr);
9999         if (caps.PixelShaderVersion >= D3DPS_VERSION(1, 4)) {
10000             constant_clamp_ps_test(device_ptr);
10001             cnd_test(device_ptr);
10002             if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) {
10003                 dp2add_ps_test(device_ptr);
10004                 if (caps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) {
10005                     nested_loop_test(device_ptr);
10006                     fixed_function_varying_test(device_ptr);
10007                     vFace_register_test(device_ptr);
10008                     vpos_register_test(device_ptr);
10009                     multiple_rendertargets_test(device_ptr);
10010                     if(caps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) {
10011                         vshader_version_varying_test(device_ptr);
10012                         pshader_version_varying_test(device_ptr);
10013                     } else {
10014                         skip("No vs_3_0 support\n");
10015                     }
10016                 } else {
10017                     skip("No ps_3_0 support\n");
10018                 }
10019             } else {
10020                 skip("No ps_2_0 support\n");
10021             }
10022         }
10023     }
10024     else skip("No ps_1_1 support\n");
10025
10026     texop_test(device_ptr);
10027     texop_range_test(device_ptr);
10028     alphareplicate_test(device_ptr);
10029     dp3_alpha_test(device_ptr);
10030
10031 cleanup:
10032     if(device_ptr) {
10033         ULONG ref;
10034
10035         D3DPRESENT_PARAMETERS present_parameters;
10036         IDirect3DSwapChain9 *swapchain;
10037         IDirect3DDevice9_GetSwapChain(device_ptr, 0, &swapchain);
10038         IDirect3DSwapChain9_GetPresentParameters(swapchain, &present_parameters);
10039         IDirect3DSwapChain9_Release(swapchain);
10040         ref = IDirect3DDevice9_Release(device_ptr);
10041         DestroyWindow(present_parameters.hDeviceWindow);
10042         ok(ref == 0, "The device was not properly freed: refcount %u\n", ref);
10043     }
10044 }