git.oblomov.eu Git - wine/blob - dlls/d3d8/tests/stateblock.c

   1 /*
   2  * Copyright 2006 Ivan Gyurdiev
   3  * Copyright 2005, 2008 Henri Verbeet
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21 #include <d3d8.h>
  22 #include "wine/test.h"
  23
  24 static DWORD texture_stages;
  25
  26 static HWND create_window(void)
  27 {
  28     WNDCLASS wc = {0};
  29     wc.lpfnWndProc = DefWindowProc;
  30     wc.lpszClassName = "d3d8_test_wc";
  31     RegisterClass(&wc);
  32
  33     return CreateWindow("d3d8_test_wc", "d3d8_test", 0, 0, 0, 0, 0, 0, 0, 0, 0);
  34 }
  35
  36 static HRESULT init_d3d8(HMODULE d3d8_module, IDirect3DDevice8 **device, D3DPRESENT_PARAMETERS *device_pparams)
  37 {
  38     IDirect3D8 * (WINAPI *d3d8_create)(UINT SDKVersion) = 0;
  39     D3DDISPLAYMODE d3ddm;
  40     IDirect3D8 *d3d8 = 0;
  41     HWND window;
  42     HRESULT hr;
  43
  44     d3d8_create = (void *)GetProcAddress(d3d8_module, "Direct3DCreate8");
  45     if (!d3d8_create) return E_FAIL;
  46
  47     d3d8 = d3d8_create(D3D_SDK_VERSION);
  48     if (!d3d8)
  49     {
  50         skip("Failed to create D3D8 object.\n");
  51         return E_FAIL;
  52     }
  53
  54     window = create_window();
  55
  56     IDirect3D8_GetAdapterDisplayMode(d3d8, D3DADAPTER_DEFAULT, &d3ddm);
  57     memset(device_pparams, 0, sizeof(*device_pparams));
  58     device_pparams->Windowed = TRUE;
  59     device_pparams->SwapEffect = D3DSWAPEFFECT_DISCARD;
  60     device_pparams->BackBufferFormat = d3ddm.Format;
  61
  62     hr = IDirect3D8_CreateDevice(d3d8, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window,
  63             D3DCREATE_SOFTWARE_VERTEXPROCESSING, device_pparams, device);
  64     ok(SUCCEEDED(hr) || hr == D3DERR_NOTAVAILABLE || broken(hr == D3DERR_INVALIDCALL),
  65             "IDirect3D8_CreateDevice failed, hr %#x.\n", hr);
  66
  67     return hr;
  68 }
  69
  70 static void test_begin_end_state_block(IDirect3DDevice8 *device)
  71 {
  72     DWORD state_block;
  73     HRESULT hr;
  74
  75     /* Should succeed */
  76     hr = IDirect3DDevice8_BeginStateBlock(device);
  77     ok(SUCCEEDED(hr), "BeginStateBlock failed, hr %#x.\n", hr);
  78     if (FAILED(hr)) return;
  79
  80     /* Calling BeginStateBlock while recording should return D3DERR_INVALIDCALL */
  81     hr = IDirect3DDevice8_BeginStateBlock(device);
  82     ok(hr == D3DERR_INVALIDCALL, "BeginStateBlock returned %#x, expected %#x.\n", hr, D3DERR_INVALIDCALL);
  83     if (hr != D3DERR_INVALIDCALL) return;
  84
  85     /* Should succeed */
  86     state_block = 0xdeadbeef;
  87     hr = IDirect3DDevice8_EndStateBlock(device, &state_block);
  88     ok(SUCCEEDED(hr) && state_block && state_block != 0xdeadbeef,
  89             "EndStateBlock returned: hr %#x, state_block %#x. "
  90             "Expected hr %#x, state_block != 0, state_block != 0xdeadbeef.\n", hr, state_block, D3D_OK);
  91     IDirect3DDevice8_DeleteStateBlock(device, state_block);
  92
  93     /* Calling EndStateBlock while not recording should return D3DERR_INVALIDCALL.
  94      * state_block should not be touched. */
  95     state_block = 0xdeadbeef;
  96     hr = IDirect3DDevice8_EndStateBlock(device, &state_block);
  97     ok(hr == D3DERR_INVALIDCALL && state_block == 0xdeadbeef,
  98             "EndStateBlock returned: hr %#x, state_block %#x. "
  99             "Expected hr %#x, state_block 0xdeadbeef.\n", hr, state_block, D3DERR_INVALIDCALL);
 100 }
 101
 102 /* ============================ State Testing Framework ========================== */
 103
 104 struct state_test
 105 {
 106     const char *test_name;
 107
 108     /* The initial data is usually the same
 109      * as the default data, but a write can have side effects.
 110      * The initial data is tested first, before any writes take place
 111      * The default data can be tested after a write */
 112     const void *initial_data;
 113
 114     /* The default data is the standard state to compare
 115      * against, and restore to */
 116     const void *default_data;
 117
 118     /* The test data is the experiment data to try
 119      * in - what we want to write
 120      * out - what windows will actually write (not necessarily the same)  */
 121     const void *test_data_in;
 122     const void *test_data_out_all;
 123     const void *test_data_out_vertex;
 124     const void *test_data_out_pixel;
 125
 126     HRESULT (*init)(IDirect3DDevice8 *device, struct state_test *test);
 127     void (*cleanup)(IDirect3DDevice8 *device, struct state_test *test);
 128     void (*apply_data)(IDirect3DDevice8 *device, const struct state_test *test,
 129             const void *data);
 130     void (*check_data)(IDirect3DDevice8 *device, const struct state_test *test,
 131             const void *data_expected, unsigned int chain_stage);
 132
 133     /* Test arguments */
 134     const void *test_arg;
 135
 136     /* Test-specific context data */
 137     void *test_context;
 138 };
 139
 140 /* See below for explanation of the flags */
 141 #define EVENT_OK    0
 142 #define EVENT_ERROR -1
 143
 144 struct event_data
 145 {
 146     DWORD stateblock;
 147     IDirect3DSurface8 *original_render_target;
 148     IDirect3DSwapChain8 *new_swap_chain;
 149 };
 150
 151 enum stateblock_data
 152 {
 153     SB_DATA_NONE = 0,
 154     SB_DATA_DEFAULT,
 155     SB_DATA_INITIAL,
 156     SB_DATA_TEST_IN,
 157     SB_DATA_TEST_ALL,
 158     SB_DATA_TEST_VERTEX,
 159     SB_DATA_TEST_PIXEL,
 160 };
 161
 162 struct event
 163 {
 164     int (*event_fn)(IDirect3DDevice8 *device, struct event_data *event_data);
 165     enum stateblock_data check;
 166     enum stateblock_data apply;
 167 };
 168
 169 static const void *get_event_data(const struct state_test *test, enum stateblock_data data)
 170 {
 171     switch (data)
 172     {
 173         case SB_DATA_DEFAULT:
 174             return test->default_data;
 175
 176         case SB_DATA_INITIAL:
 177             return test->initial_data;
 178
 179         case SB_DATA_TEST_IN:
 180             return test->test_data_in;
 181
 182         case SB_DATA_TEST_ALL:
 183             return test->test_data_out_all;
 184
 185         case SB_DATA_TEST_VERTEX:
 186             return test->test_data_out_vertex;
 187
 188         case SB_DATA_TEST_PIXEL:
 189             return test->test_data_out_pixel;
 190
 191         default:
 192             return NULL;
 193     }
 194 }
 195
 196 /* This is an event-machine, which tests things.
 197  * It tests get and set operations for a batch of states, based on
 198  * results from the event function, which directs what's to be done */
 199 static void execute_test_chain(IDirect3DDevice8 *device, struct state_test *test,
 200         unsigned int ntests, struct event *event, unsigned int nevents, struct event_data *event_data)
 201 {
 202     unsigned int i, j;
 203
 204     /* For each queued event */
 205     for (j = 0; j < nevents; ++j)
 206     {
 207         const void *data;
 208
 209         /* Execute the next event handler (if available). */
 210         if (event[j].event_fn)
 211         {
 212             if (event[j].event_fn(device, event_data) == EVENT_ERROR)
 213             {
 214                 trace("Stage %u in error state, aborting.\n", j);
 215                 break;
 216             }
 217         }
 218
 219         if (event[j].check != SB_DATA_NONE)
 220         {
 221             for (i = 0; i < ntests; ++i)
 222             {
 223                 data = get_event_data(&test[i], event[j].check);
 224                 test[i].check_data(device, &test[i], data, j);
 225             }
 226         }
 227
 228         if (event[j].apply != SB_DATA_NONE)
 229         {
 230             for (i = 0; i < ntests; ++i)
 231             {
 232                 data = get_event_data(&test[i], event[j].apply);
 233                 test[i].apply_data(device, &test[i], data);
 234             }
 235         }
 236     }
 237
 238     /* Attempt to reset any changes made. */
 239     for (i = 0; i < ntests; ++i)
 240     {
 241         test[i].apply_data(device, &test[i], test[i].default_data);
 242     }
 243 }
 244
 245 static int switch_render_target(IDirect3DDevice8* device, struct event_data *event_data)
 246 {
 247     D3DPRESENT_PARAMETERS present_parameters;
 248     IDirect3DSwapChain8 *swapchain = NULL;
 249     IDirect3DSurface8 *backbuffer = NULL;
 250     D3DDISPLAYMODE d3ddm;
 251     HRESULT hr;
 252
 253     /* Parameters for new swapchain */
 254     IDirect3DDevice8_GetDisplayMode(device, &d3ddm);
 255     memset(&present_parameters, 0, sizeof(present_parameters));
 256     present_parameters.Windowed = TRUE;
 257     present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
 258     present_parameters.BackBufferFormat = d3ddm.Format;
 259
 260     /* Create new swapchain */
 261     hr = IDirect3DDevice8_CreateAdditionalSwapChain(device, &present_parameters, &swapchain);
 262     ok(SUCCEEDED(hr), "CreateAdditionalSwapChain returned %#x.\n", hr);
 263     if (FAILED(hr)) goto error;
 264
 265     /* Get its backbuffer */
 266     hr = IDirect3DSwapChain8_GetBackBuffer(swapchain, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
 267     ok(SUCCEEDED(hr), "GetBackBuffer returned %#x.\n", hr);
 268     if (FAILED(hr)) goto error;
 269
 270     /* Save the current render target */
 271     hr = IDirect3DDevice8_GetRenderTarget(device, &event_data->original_render_target);
 272     ok(SUCCEEDED(hr), "GetRenderTarget returned %#x.\n", hr);
 273     if (FAILED(hr)) goto error;
 274
 275     /* Set the new swapchain's backbuffer as a render target */
 276     hr = IDirect3DDevice8_SetRenderTarget(device, backbuffer, NULL);
 277     ok(SUCCEEDED(hr), "SetRenderTarget returned %#x.\n", hr);
 278     if (FAILED(hr)) goto error;
 279
 280     IDirect3DSurface8_Release(backbuffer);
 281     event_data->new_swap_chain = swapchain;
 282     return EVENT_OK;
 283
 284 error:
 285     if (backbuffer) IDirect3DSurface8_Release(backbuffer);
 286     if (swapchain) IDirect3DSwapChain8_Release(swapchain);
 287     return EVENT_ERROR;
 288 }
 289
 290 static int revert_render_target(IDirect3DDevice8 *device, struct event_data *event_data)
 291 {
 292     HRESULT hr;
 293
 294     /* Reset the old render target */
 295     hr = IDirect3DDevice8_SetRenderTarget(device, event_data->original_render_target, NULL);
 296     ok(SUCCEEDED(hr), "SetRenderTarget returned %#x.\n", hr);
 297     if (FAILED(hr))
 298     {
 299         IDirect3DSurface8_Release(event_data->original_render_target);
 300         return EVENT_ERROR;
 301     }
 302
 303     IDirect3DSurface8_Release(event_data->original_render_target);
 304     IDirect3DSwapChain8_Release(event_data->new_swap_chain);
 305     return EVENT_OK;
 306 }
 307
 308 static int create_stateblock_all(IDirect3DDevice8 *device, struct event_data *event_data)
 309 {
 310     HRESULT hr;
 311
 312     hr = IDirect3DDevice8_CreateStateBlock(device, D3DSBT_ALL, &event_data->stateblock);
 313     ok(SUCCEEDED(hr), "CreateStateBlock returned %#x.\n", hr);
 314     if (FAILED(hr)) return EVENT_ERROR;
 315     return EVENT_OK;
 316 }
 317
 318 static int create_stateblock_vertex(IDirect3DDevice8 *device, struct event_data *event_data)
 319 {
 320     HRESULT hr;
 321
 322     hr = IDirect3DDevice8_CreateStateBlock(device, D3DSBT_VERTEXSTATE, &event_data->stateblock);
 323     ok(SUCCEEDED(hr), "CreateStateBlock returned %#x.\n", hr);
 324     if (FAILED(hr)) return EVENT_ERROR;
 325     return EVENT_OK;
 326 }
 327
 328 static int create_stateblock_pixel(IDirect3DDevice8 *device, struct event_data *event_data)
 329 {
 330     HRESULT hr;
 331
 332     hr = IDirect3DDevice8_CreateStateBlock(device, D3DSBT_PIXELSTATE, &event_data->stateblock);
 333     ok(SUCCEEDED(hr), "CreateStateBlock returned %#x.\n", hr);
 334     if (FAILED(hr)) return EVENT_ERROR;
 335     return EVENT_OK;
 336 }
 337
 338 static int begin_stateblock(IDirect3DDevice8 *device, struct event_data *event_data)
 339 {
 340     HRESULT hr;
 341
 342     hr = IDirect3DDevice8_BeginStateBlock(device);
 343     ok(SUCCEEDED(hr), "BeginStateBlock returned %#x.\n", hr);
 344     if (FAILED(hr)) return EVENT_ERROR;
 345     return EVENT_OK;
 346 }
 347
 348 static int end_stateblock(IDirect3DDevice8 *device, struct event_data *event_data)
 349 {
 350     HRESULT hr;
 351
 352     hr = IDirect3DDevice8_EndStateBlock(device, &event_data->stateblock);
 353     ok(SUCCEEDED(hr), "EndStateBlock returned %#x.\n", hr);
 354     if (FAILED(hr)) return EVENT_ERROR;
 355     return EVENT_OK;
 356 }
 357
 358 static int delete_stateblock(IDirect3DDevice8 *device, struct event_data *event_data)
 359 {
 360     IDirect3DDevice8_DeleteStateBlock(device, event_data->stateblock);
 361     return EVENT_OK;
 362 }
 363
 364 static int apply_stateblock(IDirect3DDevice8 *device, struct event_data *event_data)
 365 {
 366     HRESULT hr;
 367
 368     hr = IDirect3DDevice8_ApplyStateBlock(device, event_data->stateblock);
 369     ok(SUCCEEDED(hr), "Apply returned %#x.\n", hr);
 370
 371     IDirect3DDevice8_DeleteStateBlock(device, event_data->stateblock);
 372     if (FAILED(hr)) return EVENT_ERROR;
 373     return EVENT_OK;
 374 }
 375
 376 static int capture_stateblock(IDirect3DDevice8 *device, struct event_data *event_data)
 377 {
 378     HRESULT hr;
 379
 380     hr = IDirect3DDevice8_CaptureStateBlock(device, event_data->stateblock);
 381     ok(SUCCEEDED(hr), "Capture returned %#x.\n", hr);
 382     if (FAILED(hr)) return EVENT_ERROR;
 383
 384     return EVENT_OK;
 385 }
 386
 387 static void execute_test_chain_all(IDirect3DDevice8 *device, struct state_test *test, unsigned int ntests)
 388 {
 389     struct event_data arg;
 390     unsigned int i;
 391     HRESULT hr;
 392
 393     struct event read_events[] =
 394     {
 395         {NULL,                      SB_DATA_INITIAL,        SB_DATA_NONE},
 396     };
 397
 398     struct event write_read_events[] =
 399     {
 400         {NULL,                      SB_DATA_NONE,           SB_DATA_TEST_IN},
 401         {NULL,                      SB_DATA_TEST_ALL,       SB_DATA_NONE},
 402     };
 403
 404     struct event abort_stateblock_events[] =
 405     {
 406         {begin_stateblock,          SB_DATA_NONE,           SB_DATA_TEST_IN},
 407         {end_stateblock,            SB_DATA_NONE,           SB_DATA_NONE},
 408         {delete_stateblock,         SB_DATA_DEFAULT,        SB_DATA_NONE},
 409     };
 410
 411     struct event apply_stateblock_events[] =
 412     {
 413         {begin_stateblock,          SB_DATA_NONE,           SB_DATA_TEST_IN},
 414         {end_stateblock,            SB_DATA_NONE,           SB_DATA_NONE},
 415         {apply_stateblock,          SB_DATA_TEST_ALL,       SB_DATA_NONE},
 416     };
 417
 418     struct event capture_reapply_stateblock_events[] =
 419     {
 420         {begin_stateblock,          SB_DATA_NONE,           SB_DATA_TEST_IN},
 421         {end_stateblock,            SB_DATA_NONE,           SB_DATA_NONE},
 422         {capture_stateblock,        SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 423         {apply_stateblock,          SB_DATA_DEFAULT,        SB_DATA_NONE},
 424     };
 425
 426     struct event create_stateblock_capture_apply_all_events[] =
 427     {
 428         {create_stateblock_all,     SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 429         {capture_stateblock,        SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 430         {apply_stateblock,          SB_DATA_TEST_ALL,       SB_DATA_NONE},
 431     };
 432
 433     struct event create_stateblock_apply_all_events[] =
 434     {
 435         {NULL,                      SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 436         {create_stateblock_all,     SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 437         {apply_stateblock,          SB_DATA_TEST_ALL,       SB_DATA_NONE},
 438     };
 439
 440     struct event create_stateblock_capture_apply_vertex_events[] =
 441     {
 442         {create_stateblock_vertex,  SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 443         {capture_stateblock,        SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 444         {apply_stateblock,          SB_DATA_TEST_VERTEX,    SB_DATA_NONE},
 445     };
 446
 447     struct event create_stateblock_apply_vertex_events[] =
 448     {
 449         {NULL,                      SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 450         {create_stateblock_vertex,  SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 451         {apply_stateblock,          SB_DATA_TEST_VERTEX,    SB_DATA_NONE},
 452     };
 453
 454     struct event create_stateblock_capture_apply_pixel_events[] =
 455     {
 456         {create_stateblock_pixel,   SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 457         {capture_stateblock,        SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 458         {apply_stateblock,          SB_DATA_TEST_PIXEL,     SB_DATA_NONE},
 459     };
 460
 461     struct event create_stateblock_apply_pixel_events[] =
 462     {
 463         {NULL,                      SB_DATA_DEFAULT,        SB_DATA_TEST_IN},
 464         {create_stateblock_pixel,   SB_DATA_TEST_ALL,       SB_DATA_DEFAULT},
 465         {apply_stateblock,          SB_DATA_TEST_PIXEL,     SB_DATA_NONE},
 466     };
 467
 468     struct event rendertarget_switch_events[] =
 469     {
 470         {NULL,                      SB_DATA_NONE,           SB_DATA_TEST_IN},
 471         {switch_render_target,      SB_DATA_TEST_ALL,       SB_DATA_NONE},
 472         {revert_render_target,      SB_DATA_NONE,           SB_DATA_NONE},
 473     };
 474
 475     struct event rendertarget_stateblock_events[] =
 476     {
 477         {begin_stateblock,          SB_DATA_NONE,           SB_DATA_TEST_IN},
 478         {switch_render_target,      SB_DATA_DEFAULT,        SB_DATA_NONE},
 479         {end_stateblock,            SB_DATA_NONE,           SB_DATA_NONE},
 480         {revert_render_target,      SB_DATA_NONE,           SB_DATA_NONE},
 481         {apply_stateblock,          SB_DATA_TEST_ALL,       SB_DATA_NONE},
 482     };
 483
 484     /* Setup each test for execution */
 485     for (i = 0; i < ntests; ++i)
 486     {
 487         hr = test[i].init(device, &test[i]);
 488         ok(SUCCEEDED(hr), "Test \"%s\" failed setup, aborting\n", test[i].test_name);
 489         if (FAILED(hr)) return;
 490     }
 491
 492     trace("Running initial read state tests\n");
 493     execute_test_chain(device, test, ntests, read_events, 1, NULL);
 494
 495     trace("Running write-read state tests\n");
 496     execute_test_chain(device, test, ntests, write_read_events, 2, NULL);
 497
 498     trace("Running stateblock abort state tests\n");
 499     execute_test_chain(device, test, ntests, abort_stateblock_events, 3, &arg);
 500
 501     trace("Running stateblock apply state tests\n");
 502     execute_test_chain(device, test, ntests, apply_stateblock_events, 3, &arg);
 503
 504     trace("Running stateblock capture/reapply state tests\n");
 505     execute_test_chain(device, test, ntests, capture_reapply_stateblock_events, 4, &arg);
 506
 507     trace("Running create stateblock capture/apply all state tests\n");
 508     execute_test_chain(device, test, ntests, create_stateblock_capture_apply_all_events, 3, &arg);
 509
 510     trace("Running create stateblock apply all state tests\n");
 511     execute_test_chain(device, test, ntests, create_stateblock_apply_all_events, 3, &arg);
 512
 513     trace("Running create stateblock capture/apply vertex state tests\n");
 514     execute_test_chain(device, test, ntests, create_stateblock_capture_apply_vertex_events, 3, &arg);
 515
 516     trace("Running create stateblock apply vertex state tests\n");
 517     execute_test_chain(device, test, ntests, create_stateblock_apply_vertex_events, 3, &arg);
 518
 519     trace("Running create stateblock capture/apply pixel state tests\n");
 520     execute_test_chain(device, test, ntests, create_stateblock_capture_apply_pixel_events, 3, &arg);
 521
 522     trace("Running create stateblock apply pixel state tests\n");
 523     execute_test_chain(device, test, ntests, create_stateblock_apply_pixel_events, 3, &arg);
 524
 525     trace("Running rendertarget switch state tests\n");
 526     execute_test_chain(device, test, ntests, rendertarget_switch_events, 3, &arg);
 527
 528     trace("Running stateblock apply over rendertarget switch interrupt tests\n");
 529     execute_test_chain(device, test, ntests, rendertarget_stateblock_events, 5, &arg);
 530
 531     /* Cleanup resources */
 532     for (i = 0; i < ntests; ++i)
 533     {
 534         if (test[i].cleanup) test[i].cleanup(device, &test[i]);
 535     }
 536 }
 537
 538 /* =================== State test: Pixel and Vertex Shader constants ============ */
 539
 540 struct shader_constant_data
 541 {
 542     float float_constant[4]; /* 1x4 float constant */
 543 };
 544
 545 struct shader_constant_arg
 546 {
 547     unsigned int idx;
 548     BOOL pshader;
 549 };
 550
 551 static const struct shader_constant_data shader_constant_poison_data =
 552 {
 553     {1.0f, 2.0f, 3.0f, 4.0f},
 554 };
 555
 556 static const struct shader_constant_data shader_constant_default_data =
 557 {
 558     {0.0f, 0.0f, 0.0f, 0.0f},
 559 };
 560
 561 static const struct shader_constant_data shader_constant_test_data =
 562 {
 563     {5.0f, 6.0f, 7.0f, 8.0f},
 564 };
 565
 566 static void shader_constant_apply_data(IDirect3DDevice8 *device, const struct state_test *test, const void *data)
 567 {
 568     const struct shader_constant_data *scdata = data;
 569     const struct shader_constant_arg *scarg = test->test_arg;
 570     unsigned int index = scarg->idx;
 571     HRESULT hr;
 572
 573     if (!scarg->pshader)
 574     {
 575         hr = IDirect3DDevice8_SetVertexShaderConstant(device, index, scdata->float_constant, 1);
 576         ok(SUCCEEDED(hr), "SetVertexShaderConstant returned %#x.\n", hr);
 577     }
 578     else
 579     {
 580         hr = IDirect3DDevice8_SetPixelShaderConstant(device, index, scdata->float_constant, 1);
 581         ok(SUCCEEDED(hr), "SetPixelShaderConstant returned %#x.\n", hr);
 582     }
 583 }
 584
 585 static void shader_constant_check_data(IDirect3DDevice8 *device, const struct state_test *test,
 586         const void *expected_data, unsigned int chain_stage)
 587 {
 588     const struct shader_constant_data *scdata = expected_data;
 589     const struct shader_constant_arg *scarg = test->test_arg;
 590     struct shader_constant_data value;
 591     HRESULT hr;
 592
 593     value = shader_constant_poison_data;
 594
 595     if (!scarg->pshader)
 596     {
 597         hr = IDirect3DDevice8_GetVertexShaderConstant(device, scarg->idx, value.float_constant, 1);
 598         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
 599     }
 600     else
 601     {
 602         hr = IDirect3DDevice8_GetPixelShaderConstant(device, scarg->idx, value.float_constant, 1);
 603         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
 604     }
 605
 606     ok(!memcmp(value.float_constant, scdata->float_constant, sizeof(scdata->float_constant)),
 607             "Chain stage %u, %s constant:\n\t{%.8e, %.8e, %.8e, %.8e} expected\n\t{%.8e, %.8e, %.8e, %.8e} received\n",
 608             chain_stage, scarg->pshader ? "pixel shader" : "vertex shader",
 609             scdata->float_constant[0], scdata->float_constant[1],
 610             scdata->float_constant[2], scdata->float_constant[3],
 611             value.float_constant[0], value.float_constant[1],
 612             value.float_constant[2], value.float_constant[3]);
 613 }
 614
 615 static HRESULT shader_constant_test_init(IDirect3DDevice8 *device, struct state_test *test)
 616 {
 617     const struct shader_constant_arg *test_arg = test->test_arg;
 618
 619     test->test_context = NULL;
 620     test->test_data_in = &shader_constant_test_data;
 621     test->test_data_out_all = &shader_constant_test_data;
 622     if (test_arg->pshader)
 623     {
 624         test->test_data_out_vertex = &shader_constant_default_data;
 625         test->test_data_out_pixel = &shader_constant_test_data;
 626     }
 627     else
 628     {
 629         test->test_data_out_vertex = &shader_constant_test_data;
 630         test->test_data_out_pixel = &shader_constant_default_data;
 631     }
 632     test->default_data = &shader_constant_default_data;
 633     test->initial_data = &shader_constant_default_data;
 634
 635     return D3D_OK;
 636 }
 637
 638 static void shader_constants_queue_test(struct state_test *test, const struct shader_constant_arg *test_arg)
 639 {
 640     test->init = shader_constant_test_init;
 641     test->cleanup = NULL;
 642     test->apply_data = shader_constant_apply_data;
 643     test->check_data = shader_constant_check_data;
 644     test->test_name = test_arg->pshader ? "set_get_pshader_constants" : "set_get_vshader_constants";
 645     test->test_arg = test_arg;
 646 }
 647
 648 /* =================== State test: Lights ===================================== */
 649
 650 struct light_data
 651 {
 652     D3DLIGHT8 light;
 653     BOOL enabled;
 654     HRESULT get_light_result;
 655     HRESULT get_enabled_result;
 656 };
 657
 658 struct light_arg
 659 {
 660     unsigned int idx;
 661 };
 662
 663 static const struct light_data light_poison_data =
 664 {
 665     {
 666         0x1337c0de,
 667         {7.0, 4.0, 2.0, 1.0},
 668         {7.0, 4.0, 2.0, 1.0},
 669         {7.0, 4.0, 2.0, 1.0},
 670         {3.3f, 4.4f, 5.5f},
 671         {6.6f, 7.7f, 8.8f},
 672         12.12f, 13.13f, 14.14f, 15.15f, 16.16f, 17.17f, 18.18f,
 673     },
 674     TRUE,
 675     0x1337c0de,
 676     0x1337c0de,
 677 };
 678
 679 static const struct light_data light_default_data =
 680 {
 681     {
 682         D3DLIGHT_DIRECTIONAL,
 683         {1.0, 1.0, 1.0, 0.0},
 684         {0.0, 0.0, 0.0, 0.0},
 685         {0.0, 0.0, 0.0, 0.0},
 686         {0.0, 0.0, 0.0},
 687         {0.0, 0.0, 1.0},
 688         0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
 689     },
 690     FALSE,
 691     D3D_OK,
 692     D3D_OK,
 693 };
 694
 695 /* This is used for the initial read state (before a write causes side effects)
 696  * The proper return status is D3DERR_INVALIDCALL */
 697 static const struct light_data light_initial_data =
 698 {
 699     {
 700         0x1337c0de,
 701         {7.0, 4.0, 2.0, 1.0},
 702         {7.0, 4.0, 2.0, 1.0},
 703         {7.0, 4.0, 2.0, 1.0},
 704         {3.3f, 4.4f, 5.5f},
 705         {6.6f, 7.7f, 8.8f},
 706         12.12f, 13.13f, 14.14f, 15.15f, 16.16f, 17.17f, 18.18f,
 707     },
 708     TRUE,
 709     D3DERR_INVALIDCALL,
 710     D3DERR_INVALIDCALL,
 711 };
 712
 713 static const struct light_data light_test_data_in =
 714 {
 715     {
 716         1,
 717         {2.0, 2.0, 2.0, 2.0},
 718         {3.0, 3.0, 3.0, 3.0},
 719         {4.0, 4.0, 4.0, 4.0},
 720         {5.0, 5.0, 5.0},
 721         {6.0, 6.0, 6.0},
 722         7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0,
 723     },
 724     TRUE,
 725     D3D_OK,
 726     D3D_OK,
 727 };
 728
 729 /* SetLight will use 128 as the "enabled" value */
 730 static const struct light_data light_test_data_out =
 731 {
 732     {
 733         1,
 734         {2.0, 2.0, 2.0, 2.0},
 735         {3.0, 3.0, 3.0, 3.0},
 736         {4.0, 4.0, 4.0, 4.0},
 737         {5.0, 5.0, 5.0},
 738         {6.0, 6.0, 6.0},
 739         7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0,
 740     },
 741     128,
 742     D3D_OK,
 743     D3D_OK,
 744 };
 745
 746 static void light_apply_data(IDirect3DDevice8 *device, const struct state_test *test, const void *data)
 747 {
 748     const struct light_data *ldata = data;
 749     const struct light_arg *larg = test->test_arg;
 750     unsigned int index = larg->idx;
 751     HRESULT hr;
 752
 753     hr = IDirect3DDevice8_SetLight(device, index, &ldata->light);
 754     ok(SUCCEEDED(hr), "SetLight returned %#x.\n", hr);
 755
 756     hr = IDirect3DDevice8_LightEnable(device, index, ldata->enabled);
 757     ok(SUCCEEDED(hr), "SetLightEnable returned %#x.\n", hr);
 758 }
 759
 760 static void light_check_data(IDirect3DDevice8 *device, const struct state_test *test,
 761         const void *expected_data, unsigned int chain_stage)
 762 {
 763     const struct light_arg *larg = test->test_arg;
 764     const struct light_data *ldata = expected_data;
 765     struct light_data value;
 766
 767     value = light_poison_data;
 768
 769     value.get_enabled_result = IDirect3DDevice8_GetLightEnable(device, larg->idx, &value.enabled);
 770     value.get_light_result = IDirect3DDevice8_GetLight(device, larg->idx, &value.light);
 771
 772     ok(value.get_enabled_result == ldata->get_enabled_result,
 773             "Chain stage %u: expected get_enabled_result %#x, got %#x.\n",
 774             chain_stage, ldata->get_enabled_result, value.get_enabled_result);
 775     ok(value.get_light_result == ldata->get_light_result,
 776             "Chain stage %u: expected get_light_result %#x, got %#x.\n",
 777             chain_stage, ldata->get_light_result, value.get_light_result);
 778
 779     ok(value.enabled == ldata->enabled,
 780             "Chain stage %u: expected enabled %#x, got %#x.\n",
 781             chain_stage, ldata->enabled, value.enabled);
 782     ok(value.light.Type == ldata->light.Type,
 783             "Chain stage %u: expected light.Type %#x, got %#x.\n",
 784             chain_stage, ldata->light.Type, value.light.Type);
 785     ok(!memcmp(&value.light.Diffuse, &ldata->light.Diffuse, sizeof(value.light.Diffuse)),
 786             "Chain stage %u, light.Diffuse:\n\t{%.8e, %.8e, %.8e, %.8e} expected\n"
 787             "\t{%.8e, %.8e, %.8e, %.8e} received.\n", chain_stage,
 788             ldata->light.Diffuse.r, ldata->light.Diffuse.g,
 789             ldata->light.Diffuse.b, ldata->light.Diffuse.a,
 790             value.light.Diffuse.r, value.light.Diffuse.g,
 791             value.light.Diffuse.b, value.light.Diffuse.a);
 792     ok(!memcmp(&value.light.Specular, &ldata->light.Specular, sizeof(value.light.Specular)),
 793             "Chain stage %u, light.Specular:\n\t{%.8e, %.8e, %.8e, %.8e} expected\n"
 794             "\t{%.8e, %.8e, %.8e, %.8e} received.\n", chain_stage,
 795             ldata->light.Specular.r, ldata->light.Specular.g,
 796             ldata->light.Specular.b, ldata->light.Specular.a,
 797             value.light.Specular.r, value.light.Specular.g,
 798             value.light.Specular.b, value.light.Specular.a);
 799     ok(!memcmp(&value.light.Ambient, &ldata->light.Ambient, sizeof(value.light.Ambient)),
 800             "Chain stage %u, light.Ambient:\n\t{%.8e, %.8e, %.8e, %.8e} expected\n"
 801             "\t{%.8e, %.8e, %.8e, %.8e} received.\n", chain_stage,
 802             ldata->light.Ambient.r, ldata->light.Ambient.g,
 803             ldata->light.Ambient.b, ldata->light.Ambient.a,
 804             value.light.Ambient.r, value.light.Ambient.g,
 805             value.light.Ambient.b, value.light.Ambient.a);
 806     ok(!memcmp(&value.light.Position, &ldata->light.Position, sizeof(value.light.Position)),
 807             "Chain stage %u, light.Position:\n\t{%.8e, %.8e, %.8e} expected\n\t{%.8e, %.8e, %.8e} received.\n",
 808             chain_stage, ldata->light.Position.x, ldata->light.Position.y, ldata->light.Position.z,
 809             value.light.Position.x, value.light.Position.y, value.light.Position.z);
 810     ok(!memcmp(&value.light.Direction, &ldata->light.Direction, sizeof(value.light.Direction)),
 811             "Chain stage %u, light.Direction:\n\t{%.8e, %.8e, %.8e} expected\n\t{%.8e, %.8e, %.8e} received.\n",
 812             chain_stage, ldata->light.Direction.x, ldata->light.Direction.y, ldata->light.Direction.z,
 813             value.light.Direction.x, value.light.Direction.y, value.light.Direction.z);
 814     ok(value.light.Range == ldata->light.Range,
 815             "Chain stage %u: expected light.Range %.8e, got %.8e.\n",
 816             chain_stage, ldata->light.Range, value.light.Range);
 817     ok(value.light.Falloff == ldata->light.Falloff,
 818             "Chain stage %u: expected light.Falloff %.8e, got %.8e.\n",
 819             chain_stage, ldata->light.Falloff, value.light.Falloff);
 820     ok(value.light.Attenuation0 == ldata->light.Attenuation0,
 821             "Chain stage %u: expected light.Attenuation0 %.8e, got %.8e.\n",
 822             chain_stage, ldata->light.Attenuation0, value.light.Attenuation0);
 823     ok(value.light.Attenuation1 == ldata->light.Attenuation1,
 824             "Chain stage %u: expected light.Attenuation1 %.8e, got %.8e.\n",
 825             chain_stage, ldata->light.Attenuation1, value.light.Attenuation1);
 826     ok(value.light.Attenuation2 == ldata->light.Attenuation2,
 827             "Chain stage %u: expected light.Attenuation2 %.8e, got %.8e.\n",
 828             chain_stage, ldata->light.Attenuation2, value.light.Attenuation2);
 829     ok(value.light.Theta == ldata->light.Theta,
 830             "Chain stage %u: expected light.Theta %.8e, got %.8e.\n",
 831             chain_stage, ldata->light.Theta, value.light.Theta);
 832     ok(value.light.Phi == ldata->light.Phi,
 833             "Chain stage %u: expected light.Phi %.8e, got %.8e.\n",
 834             chain_stage, ldata->light.Phi, value.light.Phi);
 835 }
 836
 837 static HRESULT light_test_init(IDirect3DDevice8 *device, struct state_test *test)
 838 {
 839     test->test_context = NULL;
 840     test->test_data_in = &light_test_data_in;
 841     test->test_data_out_all = &light_test_data_out;
 842     test->test_data_out_vertex = &light_test_data_out;
 843     test->test_data_out_pixel = &light_default_data;
 844     test->default_data = &light_default_data;
 845     test->initial_data = &light_initial_data;
 846
 847     return D3D_OK;
 848 }
 849
 850 static void lights_queue_test(struct state_test *test, const struct light_arg *test_arg)
 851 {
 852     test->init = light_test_init;
 853     test->cleanup = NULL;
 854     test->apply_data = light_apply_data;
 855     test->check_data = light_check_data;
 856     test->test_name = "set_get_light";
 857     test->test_arg = test_arg;
 858 }
 859
 860 /* =================== State test: Transforms ===================================== */
 861
 862 struct transform_data
 863 {
 864     D3DMATRIX view;
 865     D3DMATRIX projection;
 866     D3DMATRIX texture0;
 867     D3DMATRIX texture7;
 868     D3DMATRIX world0;
 869     D3DMATRIX world255;
 870 };
 871
 872 static const struct transform_data transform_default_data =
 873 {
 874     {{{
 875         1.0f, 0.0f, 0.0f, 0.0f,
 876         0.0f, 1.0f, 0.0f, 0.0f,
 877         0.0f, 0.0f, 1.0f, 0.0f,
 878         0.0f, 0.0f, 0.0f, 1.0f,
 879     }}},
 880     {{{
 881         1.0f, 0.0f, 0.0f, 0.0f,
 882         0.0f, 1.0f, 0.0f, 0.0f,
 883         0.0f, 0.0f, 1.0f, 0.0f,
 884         0.0f, 0.0f, 0.0f, 1.0f,
 885     }}},
 886     {{{
 887         1.0f, 0.0f, 0.0f, 0.0f,
 888         0.0f, 1.0f, 0.0f, 0.0f,
 889         0.0f, 0.0f, 1.0f, 0.0f,
 890         0.0f, 0.0f, 0.0f, 1.0f,
 891     }}},
 892     {{{
 893         1.0f, 0.0f, 0.0f, 0.0f,
 894         0.0f, 1.0f, 0.0f, 0.0f,
 895         0.0f, 0.0f, 1.0f, 0.0f,
 896         0.0f, 0.0f, 0.0f, 1.0f,
 897     }}},
 898     {{{
 899         1.0f, 0.0f, 0.0f, 0.0f,
 900         0.0f, 1.0f, 0.0f, 0.0f,
 901         0.0f, 0.0f, 1.0f, 0.0f,
 902         0.0f, 0.0f, 0.0f, 1.0f,
 903     }}},
 904     {{{
 905         1.0f, 0.0f, 0.0f, 0.0f,
 906         0.0f, 1.0f, 0.0f, 0.0f,
 907         0.0f, 0.0f, 1.0f, 0.0f,
 908         0.0f, 0.0f, 0.0f, 1.0f,
 909     }}},
 910 };
 911
 912 static const struct transform_data transform_poison_data =
 913 {
 914     {{{
 915          1.0f,  2.0f,  3.0f,  4.0f,
 916          5.0f,  6.0f,  7.0f,  8.0f,
 917          9.0f, 10.0f, 11.0f, 12.0f,
 918         13.0f, 14.0f, 15.0f, 16.0f,
 919     }}},
 920     {{{
 921         17.0f, 18.0f, 19.0f, 20.0f,
 922         21.0f, 22.0f, 23.0f, 24.0f,
 923         25.0f, 26.0f, 27.0f, 28.0f,
 924         29.0f, 30.0f, 31.0f, 32.0f,
 925     }}},
 926     {{{
 927         33.0f, 34.0f, 35.0f, 36.0f,
 928         37.0f, 38.0f, 39.0f, 40.0f,
 929         41.0f, 42.0f, 43.0f, 44.0f,
 930         45.0f, 46.0f, 47.0f, 48.0f,
 931     }}},
 932     {{{
 933         49.0f, 50.0f, 51.0f, 52.0f,
 934         53.0f, 54.0f, 55.0f, 56.0f,
 935         57.0f, 58.0f, 59.0f, 60.0f,
 936         61.0f, 62.0f, 63.0f, 64.0f,
 937     }}},
 938     {{{
 939         64.0f, 66.0f, 67.0f, 68.0f,
 940         69.0f, 70.0f, 71.0f, 72.0f,
 941         73.0f, 74.0f, 75.0f, 76.0f,
 942         77.0f, 78.0f, 79.0f, 80.0f,
 943     }}},
 944     {{{
 945         81.0f, 82.0f, 83.0f, 84.0f,
 946         85.0f, 86.0f, 87.0f, 88.0f,
 947         89.0f, 90.0f, 91.0f, 92.0f,
 948         93.0f, 94.0f, 95.0f, 96.0f,
 949     }}},
 950 };
 951
 952 static const struct transform_data transform_test_data =
 953 {
 954     {{{
 955           1.2f,     3.4f,  -5.6f,  7.2f,
 956         10.11f,  -12.13f, 14.15f, -1.5f,
 957         23.56f,   12.89f, 44.56f, -1.0f,
 958           2.3f,     0.0f,   4.4f,  5.5f,
 959     }}},
 960     {{{
 961           9.2f,    38.7f,  -6.6f,  7.2f,
 962         10.11f,  -12.13f, 77.15f, -1.5f,
 963         23.56f,   12.89f, 14.56f, -1.0f,
 964          12.3f,     0.0f,   4.4f,  5.5f,
 965     }}},
 966     {{{
 967          10.2f,     3.4f,   0.6f,  7.2f,
 968         10.11f,  -12.13f, 14.15f, -1.5f,
 969         23.54f,    12.9f, 44.56f, -1.0f,
 970           2.3f,     0.0f,   4.4f,  5.5f,
 971     }}},
 972     {{{
 973           1.2f,     3.4f,  -5.6f,  7.2f,
 974         10.11f,  -12.13f, -14.5f, -1.5f,
 975          2.56f,   12.89f, 23.56f, -1.0f,
 976         112.3f,     0.0f,   4.4f,  2.5f,
 977     }}},
 978     {{{
 979           1.2f,   31.41f,  58.6f,  7.2f,
 980         10.11f,  -12.13f, -14.5f, -1.5f,
 981          2.56f,   12.89f, 11.56f, -1.0f,
 982         112.3f,     0.0f,  44.4f,  2.5f,
 983     }}},
 984
 985     {{{
 986          1.20f,     3.4f,  -5.6f,  7.0f,
 987         10.11f, -12.156f, -14.5f, -1.5f,
 988          2.56f,   1.829f,  23.6f, -1.0f,
 989         112.3f,     0.0f,  41.4f,  2.5f,
 990     }}},
 991 };
 992
 993
 994 static void transform_apply_data(IDirect3DDevice8 *device, const struct state_test *test, const void *data)
 995 {
 996     const struct transform_data *tdata = data;
 997     HRESULT hr;
 998
 999     hr = IDirect3DDevice8_SetTransform(device, D3DTS_VIEW, &tdata->view);
1000     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1001
1002     hr = IDirect3DDevice8_SetTransform(device, D3DTS_PROJECTION, &tdata->projection);
1003     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1004
1005     hr = IDirect3DDevice8_SetTransform(device, D3DTS_TEXTURE0, &tdata->texture0);
1006     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1007
1008     hr = IDirect3DDevice8_SetTransform(device, D3DTS_TEXTURE0 + texture_stages - 1, &tdata->texture7);
1009     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1010
1011     hr = IDirect3DDevice8_SetTransform(device, D3DTS_WORLD, &tdata->world0);
1012     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1013
1014     hr = IDirect3DDevice8_SetTransform(device, D3DTS_WORLDMATRIX(255), &tdata->world255);
1015     ok(SUCCEEDED(hr), "SetTransform returned %#x.\n", hr);
1016 }
1017
1018 static void compare_matrix(const char *name, unsigned int chain_stage,
1019         const D3DMATRIX *received, const D3DMATRIX *expected)
1020 {
1021     ok(!memcmp(expected, received, sizeof(*expected)),
1022             "Chain stage %u, matrix %s:\n"
1023             "\t{\n"
1024             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1025             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1026             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1027             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1028             "\t} expected\n"
1029             "\t{\n"
1030             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1031             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1032             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1033             "\t\t%.8e, %.8e, %.8e, %.8e,\n"
1034             "\t} received\n",
1035             chain_stage, name,
1036             U(*expected).m[0][0], U(*expected).m[1][0], U(*expected).m[2][0], U(*expected).m[3][0],
1037             U(*expected).m[0][1], U(*expected).m[1][1], U(*expected).m[2][1], U(*expected).m[3][1],
1038             U(*expected).m[0][2], U(*expected).m[1][2], U(*expected).m[2][2], U(*expected).m[3][2],
1039             U(*expected).m[0][3], U(*expected).m[1][3], U(*expected).m[2][3], U(*expected).m[3][3],
1040             U(*received).m[0][0], U(*received).m[1][0], U(*received).m[2][0], U(*received).m[3][0],
1041             U(*received).m[0][1], U(*received).m[1][1], U(*received).m[2][1], U(*received).m[3][1],
1042             U(*received).m[0][2], U(*received).m[1][2], U(*received).m[2][2], U(*received).m[3][2],
1043             U(*received).m[0][3], U(*received).m[1][3], U(*received).m[2][3], U(*received).m[3][3]);
1044 }
1045
1046 static void transform_check_data(IDirect3DDevice8 *device, const struct state_test *test,
1047         const void *expected_data, unsigned int chain_stage)
1048 {
1049     const struct transform_data *tdata = expected_data;
1050     D3DMATRIX value;
1051     HRESULT hr;
1052
1053     value = transform_poison_data.view;
1054     hr = IDirect3DDevice8_GetTransform(device, D3DTS_VIEW, &value);
1055     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1056     compare_matrix("View", chain_stage, &value, &tdata->view);
1057
1058     value = transform_poison_data.projection;
1059     hr = IDirect3DDevice8_GetTransform(device, D3DTS_PROJECTION, &value);
1060     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1061     compare_matrix("Projection", chain_stage, &value, &tdata->projection);
1062
1063     value = transform_poison_data.texture0;
1064     hr = IDirect3DDevice8_GetTransform(device, D3DTS_TEXTURE0, &value);
1065     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1066     compare_matrix("Texture0", chain_stage, &value, &tdata->texture0);
1067
1068     value = transform_poison_data.texture7;
1069     hr = IDirect3DDevice8_GetTransform(device, D3DTS_TEXTURE0 + texture_stages - 1, &value);
1070     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1071     compare_matrix("Texture7", chain_stage, &value, &tdata->texture7);
1072
1073     value = transform_poison_data.world0;
1074     hr = IDirect3DDevice8_GetTransform(device, D3DTS_WORLD, &value);
1075     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1076     compare_matrix("World0", chain_stage, &value, &tdata->world0);
1077
1078     value = transform_poison_data.world255;
1079     hr = IDirect3DDevice8_GetTransform(device, D3DTS_WORLDMATRIX(255), &value);
1080     ok(SUCCEEDED(hr), "GetTransform returned %#x.\n", hr);
1081     compare_matrix("World255", chain_stage, &value, &tdata->world255);
1082 }
1083
1084 static HRESULT transform_test_init(IDirect3DDevice8 *device, struct state_test *test)
1085 {
1086     test->test_context = NULL;
1087     test->test_data_in = &transform_test_data;
1088     test->test_data_out_all = &transform_test_data;
1089     test->test_data_out_vertex = &transform_default_data;
1090     test->test_data_out_pixel = &transform_default_data;
1091     test->default_data = &transform_default_data;
1092     test->initial_data = &transform_default_data;
1093
1094     return D3D_OK;
1095 }
1096
1097 static void transform_queue_test(struct state_test *test)
1098 {
1099     test->init = transform_test_init;
1100     test->cleanup = NULL;
1101     test->apply_data = transform_apply_data;
1102     test->check_data = transform_check_data;
1103     test->test_name = "set_get_transforms";
1104     test->test_arg = NULL;
1105 }
1106
1107 /* =================== State test: Render States ===================================== */
1108
1109 const D3DRENDERSTATETYPE render_state_indices[] =
1110 {
1111     D3DRS_ZENABLE,
1112     D3DRS_FILLMODE,
1113     D3DRS_SHADEMODE,
1114     D3DRS_ZWRITEENABLE,
1115     D3DRS_ALPHATESTENABLE,
1116     D3DRS_LASTPIXEL,
1117     D3DRS_SRCBLEND,
1118     D3DRS_DESTBLEND,
1119     D3DRS_CULLMODE,
1120     D3DRS_ZFUNC,
1121     D3DRS_ALPHAREF,
1122     D3DRS_ALPHAFUNC,
1123     D3DRS_DITHERENABLE,
1124     D3DRS_ALPHABLENDENABLE,
1125     D3DRS_FOGENABLE,
1126     D3DRS_SPECULARENABLE,
1127     D3DRS_FOGCOLOR,
1128     D3DRS_FOGTABLEMODE,
1129     D3DRS_FOGSTART,
1130     D3DRS_FOGEND,
1131     D3DRS_FOGDENSITY,
1132     D3DRS_RANGEFOGENABLE,
1133     D3DRS_STENCILENABLE,
1134     D3DRS_STENCILFAIL,
1135     D3DRS_STENCILZFAIL,
1136     D3DRS_STENCILPASS,
1137     D3DRS_STENCILFUNC,
1138     D3DRS_STENCILREF,
1139     D3DRS_STENCILMASK,
1140     D3DRS_STENCILWRITEMASK,
1141     D3DRS_TEXTUREFACTOR,
1142     D3DRS_WRAP0,
1143     D3DRS_WRAP1,
1144     D3DRS_WRAP2,
1145     D3DRS_WRAP3,
1146     D3DRS_WRAP4,
1147     D3DRS_WRAP5,
1148     D3DRS_WRAP6,
1149     D3DRS_WRAP7,
1150     D3DRS_CLIPPING,
1151     D3DRS_LIGHTING,
1152     D3DRS_AMBIENT,
1153     D3DRS_FOGVERTEXMODE,
1154     D3DRS_COLORVERTEX,
1155     D3DRS_LOCALVIEWER,
1156     D3DRS_NORMALIZENORMALS,
1157     D3DRS_DIFFUSEMATERIALSOURCE,
1158     D3DRS_SPECULARMATERIALSOURCE,
1159     D3DRS_AMBIENTMATERIALSOURCE,
1160     D3DRS_EMISSIVEMATERIALSOURCE,
1161     D3DRS_VERTEXBLEND,
1162     D3DRS_CLIPPLANEENABLE,
1163 #if 0 /* Driver dependent */
1164     D3DRS_POINTSIZE,
1165 #endif
1166     D3DRS_POINTSIZE_MIN,
1167     D3DRS_POINTSPRITEENABLE,
1168     D3DRS_POINTSCALEENABLE,
1169     D3DRS_POINTSCALE_A,
1170     D3DRS_POINTSCALE_B,
1171     D3DRS_POINTSCALE_C,
1172     D3DRS_MULTISAMPLEANTIALIAS,
1173     D3DRS_MULTISAMPLEMASK,
1174     D3DRS_PATCHEDGESTYLE,
1175 #if 0 /* Apparently not recorded in the stateblock */
1176     D3DRS_DEBUGMONITORTOKEN,
1177 #endif
1178     D3DRS_POINTSIZE_MAX,
1179     D3DRS_INDEXEDVERTEXBLENDENABLE,
1180     D3DRS_COLORWRITEENABLE,
1181     D3DRS_TWEENFACTOR,
1182     D3DRS_BLENDOP,
1183 };
1184
1185 struct render_state_data
1186 {
1187     DWORD states[sizeof(render_state_indices) / sizeof(*render_state_indices)];
1188 };
1189
1190 struct render_state_arg
1191 {
1192     D3DPRESENT_PARAMETERS *device_pparams;
1193     float pointsize_max;
1194 };
1195
1196 struct render_state_context
1197 {
1198     struct render_state_data default_data_buffer;
1199     struct render_state_data test_data_all_buffer;
1200     struct render_state_data test_data_vertex_buffer;
1201     struct render_state_data test_data_pixel_buffer;
1202     struct render_state_data poison_data_buffer;
1203 };
1204
1205 static void render_state_apply_data(IDirect3DDevice8 *device, const struct state_test *test, const void *data)
1206 {
1207     const struct render_state_data *rsdata = data;
1208     unsigned int i;
1209     HRESULT hr;
1210
1211     for (i = 0; i < sizeof(render_state_indices) / sizeof(*render_state_indices); ++i)
1212     {
1213         hr = IDirect3DDevice8_SetRenderState(device, render_state_indices[i], rsdata->states[i]);
1214         ok(SUCCEEDED(hr), "SetRenderState returned %#x.\n", hr);
1215     }
1216 }
1217
1218 static void render_state_check_data(IDirect3DDevice8 *device, const struct state_test *test,
1219         const void *expected_data, unsigned int chain_stage)
1220 {
1221     const struct render_state_context *ctx = test->test_context;
1222     const struct render_state_data *rsdata = expected_data;
1223     unsigned int i;
1224     HRESULT hr;
1225
1226     for (i = 0; i < sizeof(render_state_indices) / sizeof(*render_state_indices); ++i)
1227     {
1228         DWORD value = ctx->poison_data_buffer.states[i];
1229         hr = IDirect3DDevice8_GetRenderState(device, render_state_indices[i], &value);
1230         ok(SUCCEEDED(hr), "GetRenderState returned %#x.\n", hr);
1231         ok(value == rsdata->states[i], "Chain stage %u, render state %#x: expected %#x, got %#x.\n",
1232                 chain_stage, render_state_indices[i], rsdata->states[i], value);
1233     }
1234 }
1235
1236 static inline DWORD to_dword(float fl)
1237 {
1238     union {float f; DWORD d;} ret;
1239
1240     ret.f = fl;
1241     return ret.d;
1242 }
1243
1244 static void render_state_default_data_init(const struct render_state_arg *rsarg, struct render_state_data *data)
1245 {
1246     DWORD zenable = rsarg->device_pparams->EnableAutoDepthStencil ? D3DZB_TRUE : D3DZB_FALSE;
1247     unsigned int idx = 0;
1248
1249     data->states[idx++] = zenable;               /* ZENABLE */
1250     data->states[idx++] = D3DFILL_SOLID;         /* FILLMODE */
1251     data->states[idx++] = D3DSHADE_GOURAUD;      /* SHADEMODE */
1252     data->states[idx++] = TRUE;                  /* ZWRITEENABLE */
1253     data->states[idx++] = FALSE;                 /* ALPHATESTENABLE */
1254     data->states[idx++] = TRUE;                  /* LASTPIXEL */
1255     data->states[idx++] = D3DBLEND_ONE;          /* SRCBLEND */
1256     data->states[idx++] = D3DBLEND_ZERO;         /* DESTBLEND */
1257     data->states[idx++] = D3DCULL_CCW;           /* CULLMODE */
1258     data->states[idx++] = D3DCMP_LESSEQUAL;      /* ZFUNC */
1259     data->states[idx++] = 0;                     /* ALPHAREF */
1260     data->states[idx++] = D3DCMP_ALWAYS;         /* ALPHAFUNC */
1261     data->states[idx++] = FALSE;                 /* DITHERENABLE */
1262     data->states[idx++] = FALSE;                 /* ALPHABLENDENABLE */
1263     data->states[idx++] = FALSE;                 /* FOGENABLE */
1264     data->states[idx++] = FALSE;                 /* SPECULARENABLE */
1265     data->states[idx++] = 0;                     /* FOGCOLOR */
1266     data->states[idx++] = D3DFOG_NONE;           /* FOGTABLEMODE */
1267     data->states[idx++] = to_dword(0.0f);        /* FOGSTART */
1268     data->states[idx++] = to_dword(1.0f);        /* FOGEND */
1269     data->states[idx++] = to_dword(1.0f);        /* FOGDENSITY */
1270     data->states[idx++] = FALSE;                 /* RANGEFOGENABLE */
1271     data->states[idx++] = FALSE;                 /* STENCILENABLE */
1272     data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILFAIL */
1273     data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILZFAIL */
1274     data->states[idx++] = D3DSTENCILOP_KEEP;     /* STENCILPASS */
1275     data->states[idx++] = D3DCMP_ALWAYS;         /* STENCILFUNC */
1276     data->states[idx++] = 0;                     /* STENCILREF */
1277     data->states[idx++] = 0xFFFFFFFF;            /* STENCILMASK */
1278     data->states[idx++] = 0xFFFFFFFF;            /* STENCILWRITEMASK */
1279     data->states[idx++] = 0xFFFFFFFF;            /* TEXTUREFACTOR */
1280     data->states[idx++] = 0;                     /* WRAP 0 */
1281     data->states[idx++] = 0;                     /* WRAP 1 */
1282     data->states[idx++] = 0;                     /* WRAP 2 */
1283     data->states[idx++] = 0;                     /* WRAP 3 */
1284     data->states[idx++] = 0;                     /* WRAP 4 */
1285     data->states[idx++] = 0;                     /* WRAP 5 */
1286     data->states[idx++] = 0;                     /* WRAP 6 */
1287     data->states[idx++] = 0;                     /* WRAP 7 */
1288     data->states[idx++] = TRUE;                  /* CLIPPING */
1289     data->states[idx++] = TRUE;                  /* LIGHTING */
1290     data->states[idx++] = 0;                     /* AMBIENT */
1291     data->states[idx++] = D3DFOG_NONE;           /* FOGVERTEXMODE */
1292     data->states[idx++] = TRUE;                  /* COLORVERTEX */
1293     data->states[idx++] = TRUE;                  /* LOCALVIEWER */
1294     data->states[idx++] = FALSE;                 /* NORMALIZENORMALS */
1295     data->states[idx++] = D3DMCS_COLOR1;         /* DIFFUSEMATERIALSOURCE */
1296     data->states[idx++] = D3DMCS_COLOR2;         /* SPECULARMATERIALSOURCE */
1297     data->states[idx++] = D3DMCS_MATERIAL;       /* AMBIENTMATERIALSOURCE */
1298     data->states[idx++] = D3DMCS_MATERIAL;       /* EMISSIVEMATERIALSOURCE */
1299     data->states[idx++] = D3DVBF_DISABLE;        /* VERTEXBLEND */
1300     data->states[idx++] = 0;                     /* CLIPPLANEENABLE */
1301     if (0) data->states[idx++] = to_dword(1.0f); /* POINTSIZE, driver dependent, increase array size to enable */
1302     data->states[idx++] = to_dword(0.0f);        /* POINTSIZEMIN */
1303     data->states[idx++] = FALSE;                 /* POINTSPRITEENABLE */
1304     data->states[idx++] = FALSE;                 /* POINTSCALEENABLE */
1305     data->states[idx++] = to_dword(1.0f);        /* POINTSCALE_A */
1306     data->states[idx++] = to_dword(0.0f);        /* POINTSCALE_B */
1307     data->states[idx++] = to_dword(0.0f);        /* POINTSCALE_C */
1308     data->states[idx++] = TRUE;                  /* MULTISAMPLEANTIALIAS */
1309     data->states[idx++] = 0xFFFFFFFF;            /* MULTISAMPLEMASK */
1310     data->states[idx++] = D3DPATCHEDGE_DISCRETE; /* PATCHEDGESTYLE */
1311     if (0) data->states[idx++] = 0xbaadcafe;     /* DEBUGMONITORTOKEN, not recorded in the stateblock */
1312     data->states[idx++] = to_dword(rsarg->pointsize_max); /* POINTSIZE_MAX */
1313     data->states[idx++] = FALSE;                 /* INDEXEDVERTEXBLENDENABLE */
1314     data->states[idx++] = 0x0000000F;            /* COLORWRITEENABLE */
1315     data->states[idx++] = to_dword(0.0f);        /* TWEENFACTOR */
1316     data->states[idx++] = D3DBLENDOP_ADD;        /* BLENDOP */
1317 }
1318
1319 static void render_state_poison_data_init(struct render_state_data *data)
1320 {
1321     unsigned int i;
1322
1323     for (i = 0; i < sizeof(render_state_indices) / sizeof(*render_state_indices); ++i)
1324     {
1325         data->states[i] = 0x1337c0de;
1326     }
1327 }
1328
1329 static void render_state_test_data_init(struct render_state_data *data)
1330 {
1331     unsigned int idx = 0;
1332
1333     data->states[idx++] = D3DZB_USEW;            /* ZENABLE */
1334     data->states[idx++] = D3DFILL_WIREFRAME;     /* FILLMODE */
1335     data->states[idx++] = D3DSHADE_PHONG;        /* SHADEMODE */
1336     data->states[idx++] = FALSE;                 /* ZWRITEENABLE */
1337     data->states[idx++] = TRUE;                  /* ALPHATESTENABLE */
1338     data->states[idx++] = FALSE;                 /* LASTPIXEL */
1339     data->states[idx++] = D3DBLEND_SRCALPHASAT;  /* SRCBLEND */
1340     data->states[idx++] = D3DBLEND_INVDESTALPHA; /* DESTBLEND */
1341     data->states[idx++] = D3DCULL_CW;            /* CULLMODE */
1342     data->states[idx++] = D3DCMP_NOTEQUAL;       /* ZFUNC */
1343     data->states[idx++] = 10;                    /* ALPHAREF */
1344     data->states[idx++] = D3DCMP_GREATER;        /* ALPHAFUNC */
1345     data->states[idx++] = TRUE;                  /* DITHERENABLE */
1346     data->states[idx++] = TRUE;                  /* ALPHABLENDENABLE */
1347     data->states[idx++] = TRUE;                  /* FOGENABLE */
1348     data->states[idx++] = TRUE;                  /* SPECULARENABLE */
1349     data->states[idx++] = 1 << 31;               /* FOGCOLOR */
1350     data->states[idx++] = D3DFOG_EXP;            /* FOGTABLEMODE */
1351     data->states[idx++] = to_dword(0.1f);        /* FOGSTART */
1352     data->states[idx++] = to_dword(0.8f);        /* FOGEND */
1353     data->states[idx++] = to_dword(0.5f);        /* FOGDENSITY */
1354     data->states[idx++] = TRUE;                  /* RANGEFOGENABLE */
1355     data->states[idx++] = TRUE;                  /* STENCILENABLE */
1356     data->states[idx++] = D3DSTENCILOP_INCRSAT;  /* STENCILFAIL */
1357     data->states[idx++] = D3DSTENCILOP_REPLACE;  /* STENCILZFAIL */
1358     data->states[idx++] = D3DSTENCILOP_INVERT;   /* STENCILPASS */
1359     data->states[idx++] = D3DCMP_LESS;           /* STENCILFUNC */
1360     data->states[idx++] = 10;                    /* STENCILREF */
1361     data->states[idx++] = 0xFF00FF00;            /* STENCILMASK */
1362     data->states[idx++] = 0x00FF00FF;            /* STENCILWRITEMASK */
1363     data->states[idx++] = 0xF0F0F0F0;            /* TEXTUREFACTOR */
1364     data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_2;                                   /* WRAP 0 */
1365     data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3;                                   /* WRAP 1 */
1366     data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_3;                                   /* WRAP 2 */
1367     data->states[idx++] = D3DWRAPCOORD_3 | D3DWRAPCOORD_0;                                   /* WRAP 4 */
1368     data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2;                  /* WRAP 5 */
1369     data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3 | D3DWRAPCOORD_2;                  /* WRAP 6 */
1370     data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_1 | D3DWRAPCOORD_0;                  /* WRAP 7 */
1371     data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_0 | D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 8 */
1372     data->states[idx++] = FALSE;                 /* CLIPPING */
1373     data->states[idx++] = FALSE;                 /* LIGHTING */
1374     data->states[idx++] = 255 << 16;             /* AMBIENT */
1375     data->states[idx++] = D3DFOG_EXP2;           /* FOGVERTEXMODE */
1376     data->states[idx++] = FALSE;                 /* COLORVERTEX */
1377     data->states[idx++] = FALSE;                 /* LOCALVIEWER */
1378     data->states[idx++] = TRUE;                  /* NORMALIZENORMALS */
1379     data->states[idx++] = D3DMCS_COLOR2;         /* DIFFUSEMATERIALSOURCE */
1380     data->states[idx++] = D3DMCS_MATERIAL;       /* SPECULARMATERIALSOURCE */
1381     data->states[idx++] = D3DMCS_COLOR1;         /* AMBIENTMATERIALSOURCE */
1382     data->states[idx++] = D3DMCS_COLOR2;         /* EMISSIVEMATERIALSOURCE */
1383     data->states[idx++] = D3DVBF_3WEIGHTS;       /* VERTEXBLEND */
1384     data->states[idx++] = 0xf1f1f1f1;            /* CLIPPLANEENABLE */
1385     if (0) data->states[idx++] = to_dword(32.0f);/* POINTSIZE, driver dependent, increase array size to enable */
1386     data->states[idx++] = to_dword(0.7f);        /* POINTSIZEMIN */
1387     data->states[idx++] = TRUE;                  /* POINTSPRITEENABLE */
1388     data->states[idx++] = TRUE;                  /* POINTSCALEENABLE */
1389     data->states[idx++] = to_dword(0.7f);        /* POINTSCALE_A */
1390     data->states[idx++] = to_dword(0.5f);        /* POINTSCALE_B */
1391     data->states[idx++] = to_dword(0.4f);        /* POINTSCALE_C */
1392     data->states[idx++] = FALSE;                 /* MULTISAMPLEANTIALIAS */
1393     data->states[idx++] = 0xABCDDBCA;            /* MULTISAMPLEMASK */
1394     data->states[idx++] = D3DPATCHEDGE_CONTINUOUS; /* PATCHEDGESTYLE */
1395     if (0) data->states[idx++] = D3DDMT_DISABLE; /* DEBUGMONITORTOKEN, not recorded in the stateblock */
1396     data->states[idx++] = to_dword(77.0f);       /* POINTSIZE_MAX */
1397     data->states[idx++] = TRUE;                  /* INDEXEDVERTEXBLENDENABLE */
1398     data->states[idx++] = 0x00000009;            /* COLORWRITEENABLE */
1399     data->states[idx++] = to_dword(0.2f);        /* TWEENFACTOR */
1400     data->states[idx++] = D3DBLENDOP_REVSUBTRACT;/* BLENDOP */
1401 }
1402
1403 static HRESULT render_state_test_init(IDirect3DDevice8 *device, struct state_test *test)
1404 {
1405     static const DWORD states_vertex[] =
1406     {
1407         D3DRS_AMBIENT,
1408         D3DRS_AMBIENTMATERIALSOURCE,
1409         D3DRS_CLIPPING,
1410         D3DRS_CLIPPLANEENABLE,
1411         D3DRS_COLORVERTEX,
1412         D3DRS_CULLMODE,
1413         D3DRS_DIFFUSEMATERIALSOURCE,
1414         D3DRS_EMISSIVEMATERIALSOURCE,
1415         D3DRS_FOGCOLOR,
1416         D3DRS_FOGDENSITY,
1417         D3DRS_FOGENABLE,
1418         D3DRS_FOGEND,
1419         D3DRS_FOGSTART,
1420         D3DRS_FOGTABLEMODE,
1421         D3DRS_FOGVERTEXMODE,
1422         D3DRS_INDEXEDVERTEXBLENDENABLE,
1423         D3DRS_LIGHTING,
1424         D3DRS_LOCALVIEWER,
1425         D3DRS_MULTISAMPLEANTIALIAS,
1426         D3DRS_MULTISAMPLEMASK,
1427         D3DRS_NORMALIZENORMALS,
1428         D3DRS_PATCHEDGESTYLE,
1429         D3DRS_POINTSCALE_A,
1430         D3DRS_POINTSCALE_B,
1431         D3DRS_POINTSCALE_C,
1432         D3DRS_POINTSCALEENABLE,
1433         D3DRS_POINTSIZE,
1434         D3DRS_POINTSIZE_MAX,
1435         D3DRS_POINTSIZE_MIN,
1436         D3DRS_POINTSPRITEENABLE,
1437         D3DRS_RANGEFOGENABLE,
1438         D3DRS_SHADEMODE,
1439         D3DRS_SPECULARENABLE,
1440         D3DRS_SPECULARMATERIALSOURCE,
1441         D3DRS_TWEENFACTOR,
1442         D3DRS_VERTEXBLEND,
1443     };
1444
1445     static const DWORD states_pixel[] =
1446     {
1447         D3DRS_ALPHABLENDENABLE,
1448         D3DRS_ALPHAFUNC,
1449         D3DRS_ALPHAREF,
1450         D3DRS_ALPHATESTENABLE,
1451         D3DRS_BLENDOP,
1452         D3DRS_COLORWRITEENABLE,
1453         D3DRS_DESTBLEND,
1454         D3DRS_DITHERENABLE,
1455         D3DRS_FILLMODE,
1456         D3DRS_FOGDENSITY,
1457         D3DRS_FOGEND,
1458         D3DRS_FOGSTART,
1459         D3DRS_LASTPIXEL,
1460         D3DRS_SHADEMODE,
1461         D3DRS_SRCBLEND,
1462         D3DRS_STENCILENABLE,
1463         D3DRS_STENCILFAIL,
1464         D3DRS_STENCILFUNC,
1465         D3DRS_STENCILMASK,
1466         D3DRS_STENCILPASS,
1467         D3DRS_STENCILREF,
1468         D3DRS_STENCILWRITEMASK,
1469         D3DRS_STENCILZFAIL,
1470         D3DRS_TEXTUREFACTOR,
1471         D3DRS_WRAP0,
1472         D3DRS_WRAP1,
1473         D3DRS_WRAP2,
1474         D3DRS_WRAP3,
1475         D3DRS_WRAP4,
1476         D3DRS_WRAP5,
1477         D3DRS_WRAP6,
1478         D3DRS_WRAP7,
1479         D3DRS_ZENABLE,
1480         D3DRS_ZFUNC,
1481         D3DRS_ZWRITEENABLE,
1482     };
1483
1484     const struct render_state_arg *rsarg = test->test_arg;
1485     unsigned int i, j;
1486
1487     struct render_state_context *ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ctx));
1488     if (!ctx) return E_FAIL;
1489     test->test_context = ctx;
1490
1491     test->default_data = &ctx->default_data_buffer;
1492     test->initial_data = &ctx->default_data_buffer;
1493     test->test_data_in = &ctx->test_data_all_buffer;
1494     test->test_data_out_all = &ctx->test_data_all_buffer;
1495     test->test_data_out_vertex = &ctx->test_data_vertex_buffer;
1496     test->test_data_out_pixel = &ctx->test_data_pixel_buffer;
1497
1498     render_state_default_data_init(rsarg, &ctx->default_data_buffer);
1499     render_state_test_data_init(&ctx->test_data_all_buffer);
1500     render_state_poison_data_init(&ctx->poison_data_buffer);
1501
1502     for (i = 0; i < sizeof(render_state_indices) / sizeof(*render_state_indices); ++i)
1503     {
1504         ctx->test_data_vertex_buffer.states[i] = ctx->default_data_buffer.states[i];
1505         for (j = 0; j < sizeof(states_vertex) / sizeof(*states_vertex); ++j)
1506         {
1507             if (render_state_indices[i] == states_vertex[j])
1508             {
1509                 ctx->test_data_vertex_buffer.states[i] = ctx->test_data_all_buffer.states[i];
1510                 break;
1511             }
1512         }
1513
1514         ctx->test_data_pixel_buffer.states[i] = ctx->default_data_buffer.states[i];
1515         for (j = 0; j < sizeof(states_pixel) / sizeof(*states_pixel); ++j)
1516         {
1517             if (render_state_indices[i] == states_pixel[j])
1518             {
1519                 ctx->test_data_pixel_buffer.states[i] = ctx->test_data_all_buffer.states[i];
1520                 break;
1521             }
1522         }
1523     }
1524
1525     return D3D_OK;
1526 }
1527
1528 static void render_state_test_cleanup(IDirect3DDevice8 *device, struct state_test *test)
1529 {
1530     HeapFree(GetProcessHeap(), 0, test->test_context);
1531 }
1532
1533 static void render_states_queue_test(struct state_test *test, const struct render_state_arg *test_arg)
1534 {
1535     test->init = render_state_test_init;
1536     test->cleanup = render_state_test_cleanup;
1537     test->apply_data = render_state_apply_data;
1538     test->check_data = render_state_check_data;
1539     test->test_name = "set_get_render_states";
1540     test->test_arg = test_arg;
1541 }
1542
1543 /* resource tests */
1544
1545 struct resource_test_arg
1546 {
1547     DWORD vs_version;
1548     DWORD ps_version;
1549     UINT stream_count;
1550     UINT tex_count;
1551 };
1552
1553 struct resource_test_data
1554 {
1555     DWORD vs;
1556     DWORD ps;
1557     IDirect3DIndexBuffer8 *ib;
1558     IDirect3DVertexBuffer8 **vb;
1559     IDirect3DTexture8 **tex;
1560 };
1561
1562 struct resource_test_context
1563 {
1564     struct resource_test_data default_data;
1565     struct resource_test_data test_data_all;
1566     struct resource_test_data test_data_vertex;
1567     struct resource_test_data test_data_pixel;
1568     struct resource_test_data poison_data;
1569 };
1570
1571 static void resource_apply_data(IDirect3DDevice8 *device, const struct state_test *test, const void *data)
1572 {
1573     const struct resource_test_arg *arg = test->test_arg;
1574     const struct resource_test_data *d = data;
1575     unsigned int i;
1576     HRESULT hr;
1577
1578     hr = IDirect3DDevice8_SetVertexShader(device, d->vs);
1579     ok(SUCCEEDED(hr), "SetVertexShader (%u) returned %#x.\n", d->vs, hr);
1580
1581     hr = IDirect3DDevice8_SetPixelShader(device, d->ps);
1582     ok(SUCCEEDED(hr), "SetPixelShader (%u) returned %#x.\n", d->ps, hr);
1583
1584     hr = IDirect3DDevice8_SetIndices(device, d->ib, 0);
1585     ok(SUCCEEDED(hr), "SetIndices (%p) returned %#x.\n", d->ib, hr);
1586
1587     for (i = 0; i < arg->stream_count; ++i)
1588     {
1589         hr = IDirect3DDevice8_SetStreamSource(device, i, d->vb[i], 64);
1590         ok(SUCCEEDED(hr), "SetStreamSource (%u, %p, 64) returned %#x.\n",
1591                 i, d->vb[i], hr);
1592     }
1593
1594     for (i = 0; i < arg->tex_count; ++i)
1595     {
1596         hr = IDirect3DDevice8_SetTexture(device, i, (IDirect3DBaseTexture8 *)d->tex[i]);
1597         ok(SUCCEEDED(hr), "SetTexture (%u, %p) returned %#x.\n", i, d->tex[i], hr);
1598     }
1599 }
1600
1601 static void resource_check_data(IDirect3DDevice8 *device, const struct state_test *test,
1602         const void *expected_data, unsigned int chain_stage)
1603 {
1604     const struct resource_test_context *ctx = test->test_context;
1605     const struct resource_test_data *poison = &ctx->poison_data;
1606     const struct resource_test_arg *arg = test->test_arg;
1607     const struct resource_test_data *d = expected_data;
1608     unsigned int i;
1609     HRESULT hr;
1610     void *ptr;
1611     DWORD v;
1612
1613     v = poison->vs;
1614     hr = IDirect3DDevice8_GetVertexShader(device, &v);
1615     ok(SUCCEEDED(hr), "GetVertexShader returned %#x.\n", hr);
1616     ok(v == d->vs, "Chain stage %u, expected vertex shader %#x, received %#x.\n",
1617             chain_stage, d->vs, v);
1618
1619     v = poison->ps;
1620     hr = IDirect3DDevice8_GetPixelShader(device, &v);
1621     ok(SUCCEEDED(hr), "GetPixelShader returned %#x.\n", hr);
1622     ok(v == d->ps, "Chain stage %u, expected pixel shader %#x, received %#x.\n",
1623             chain_stage, d->ps, v);
1624
1625     ptr = poison->ib;
1626     hr = IDirect3DDevice8_GetIndices(device, (IDirect3DIndexBuffer8 **)&ptr, &v);
1627     ok(SUCCEEDED(hr), "GetIndices returned %#x.\n", hr);
1628     ok(ptr == d->ib, "Chain stage %u, expected index buffer %p, received %p.\n",
1629             chain_stage, d->ib, ptr);
1630     if (SUCCEEDED(hr) && ptr)
1631     {
1632         IDirect3DIndexBuffer8_Release((IDirect3DIndexBuffer8 *)ptr);
1633     }
1634
1635     for (i = 0; i < arg->stream_count; ++i)
1636     {
1637         ptr = poison->vb[i];
1638         hr = IDirect3DDevice8_GetStreamSource(device, i, (IDirect3DVertexBuffer8 **)&ptr, &v);
1639         ok(SUCCEEDED(hr), "GetStreamSource (%u) returned %#x.\n", i, hr);
1640         ok(ptr == d->vb[i], "Chain stage %u, stream %u, expected vertex buffer %p, received %p.\n",
1641                 chain_stage, i, d->vb[i], ptr);
1642         if (SUCCEEDED(hr) && ptr)
1643         {
1644             IDirect3DIndexBuffer8_Release((IDirect3DVertexBuffer8 *)ptr);
1645         }
1646     }
1647
1648     for (i = 0; i < arg->tex_count; ++i)
1649     {
1650         ptr = poison->tex[i];
1651         hr = IDirect3DDevice8_GetTexture(device, i, (IDirect3DBaseTexture8 **)&ptr);
1652         ok(SUCCEEDED(hr), "SetTexture (%u) returned %#x.\n", i, hr);
1653         ok(ptr == d->tex[i], "Chain stage %u, texture stage %u, expected texture %p, received %p.\n",
1654                 chain_stage, i, d->tex[i], ptr);
1655         if (SUCCEEDED(hr) && ptr)
1656         {
1657             IDirect3DBaseTexture8_Release((IDirect3DBaseTexture8 *)ptr);
1658         }
1659     }
1660 }
1661
1662 static void resource_default_data_init(struct resource_test_data *data, const struct resource_test_arg *arg)
1663 {
1664     unsigned int i;
1665
1666     data->vs = 0;
1667     data->ps = 0;
1668     data->ib = NULL;
1669     data->vb = HeapAlloc(GetProcessHeap(), 0, arg->stream_count * sizeof(*data->vb));
1670     for (i = 0; i < arg->stream_count; ++i)
1671     {
1672         data->vb[i] = NULL;
1673     }
1674     data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex));
1675     for (i = 0; i < arg->tex_count; ++i)
1676     {
1677         data->tex[i] = NULL;
1678     }
1679 }
1680
1681 static void resource_test_data_init(IDirect3DDevice8 *device,
1682         struct resource_test_data *data, const struct resource_test_arg *arg)
1683 {
1684     static const DWORD vs_code[] =
1685     {
1686         0xfffe0101,                                                             /* vs_1_1                       */
1687         0x00000009, 0xc0010000, 0x90e40000, 0xa0e40000,                         /* dp4 oPos.x, v0, c0           */
1688         0x00000009, 0xc0020000, 0x90e40000, 0xa0e40001,                         /* dp4 oPos.y, v0, c1           */
1689         0x00000009, 0xc0040000, 0x90e40000, 0xa0e40002,                         /* dp4 oPos.z, v0, c2           */
1690         0x00000009, 0xc0080000, 0x90e40000, 0xa0e40003,                         /* dp4 oPos.w, v0, c3           */
1691         0x0000ffff,                                                             /* END                          */
1692     };
1693     static const DWORD ps_code[] =
1694     {
1695         0xffff0101,                                                             /* ps_1_1                       */
1696         0x00000051, 0xa00f0001, 0x3f800000, 0x00000000, 0x00000000, 0x00000000, /* def c1 = 1.0, 0.0, 0.0, 0.0  */
1697         0x00000042, 0xb00f0000,                                                 /* tex t0                       */
1698         0x00000008, 0x800f0000, 0xa0e40001, 0xa0e40000,                         /* dp3 r0, c1, c0               */
1699         0x00000005, 0x800f0000, 0x90e40000, 0x80e40000,                         /* mul r0, v0, r0               */
1700         0x00000005, 0x800f0000, 0xb0e40000, 0x80e40000,                         /* mul r0, t0, r0               */
1701         0x0000ffff,                                                             /* END                          */
1702     };
1703     static const DWORD decl[] =
1704     {
1705         D3DVSD_STREAM(0),
1706         D3DVSD_REG(D3DVSDE_POSITION, D3DVSDT_FLOAT3),
1707         D3DVSD_REG(D3DVSDE_DIFFUSE, D3DVSDT_D3DCOLOR),
1708         D3DVSD_END(),
1709     };
1710
1711     unsigned int i;
1712     HRESULT hr;
1713
1714     if (arg->vs_version)
1715     {
1716         hr = IDirect3DDevice8_CreateVertexShader(device, decl, vs_code, &data->vs, 0);
1717         ok(SUCCEEDED(hr), "CreateVertexShader returned hr %#x.\n", hr);
1718     }
1719
1720     if (arg->ps_version)
1721     {
1722         hr = IDirect3DDevice8_CreatePixelShader(device, ps_code, &data->ps);
1723         ok(SUCCEEDED(hr), "CreatePixelShader returned hr %#x.\n", hr);
1724     }
1725
1726     hr = IDirect3DDevice8_CreateIndexBuffer(device, 64, D3DUSAGE_DYNAMIC, D3DFMT_INDEX32, D3DPOOL_DEFAULT, &data->ib);
1727     ok(SUCCEEDED(hr), "CreateIndexBuffer returned hr %#x.\n", hr);
1728
1729     data->vb = HeapAlloc(GetProcessHeap(), 0, arg->stream_count * sizeof(*data->vb));
1730     for (i = 0; i < arg->stream_count; ++i)
1731     {
1732         hr = IDirect3DDevice8_CreateVertexBuffer(device, 64, D3DUSAGE_DYNAMIC,
1733                 0, D3DPOOL_DEFAULT, &data->vb[i]);
1734         ok(SUCCEEDED(hr), "CreateVertexBuffer (%u) returned hr %#x.\n", i, hr);
1735     }
1736
1737     data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex));
1738     for (i = 0; i < arg->tex_count; ++i)
1739     {
1740         hr = IDirect3DDevice8_CreateTexture(device, 64, 64, 0, 0,
1741                 D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &data->tex[i]);
1742         ok(SUCCEEDED(hr), "CreateTexture (%u) returned hr %#x.\n", i, hr);
1743     }
1744 }
1745
1746 static void resource_poison_data_init(struct resource_test_data *data, const struct resource_test_arg *arg)
1747 {
1748     DWORD_PTR poison = 0xdeadbeef;
1749     unsigned int i;
1750
1751     data->vs = poison++;
1752     data->ps = poison++;
1753     data->ib = (IDirect3DIndexBuffer8 *)poison++;
1754     data->vb = HeapAlloc(GetProcessHeap(), 0, arg->stream_count * sizeof(*data->vb));
1755     for (i = 0; i < arg->stream_count; ++i)
1756     {
1757         data->vb[i] = (IDirect3DVertexBuffer8 *)poison++;
1758     }
1759     data->tex = HeapAlloc(GetProcessHeap(), 0, arg->tex_count * sizeof(*data->tex));
1760     for (i = 0; i < arg->tex_count; ++i)
1761     {
1762         data->tex[i] = (IDirect3DTexture8 *)poison++;
1763     }
1764 }
1765
1766 static HRESULT resource_test_init(IDirect3DDevice8 *device, struct state_test *test)
1767 {
1768     const struct resource_test_arg *arg = test->test_arg;
1769     struct resource_test_context *ctx;
1770
1771     ctx = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ctx));
1772     if (!ctx) return E_OUTOFMEMORY;
1773
1774     test->test_context = ctx;
1775     test->test_data_in = &ctx->test_data_all;
1776     test->test_data_out_all = &ctx->test_data_all;
1777     test->test_data_out_vertex = &ctx->test_data_vertex;
1778     test->test_data_out_pixel = &ctx->test_data_pixel;
1779     test->default_data = &ctx->default_data;
1780     test->initial_data = &ctx->default_data;
1781
1782     resource_default_data_init(&ctx->default_data, arg);
1783     resource_test_data_init(device, &ctx->test_data_all, arg);
1784     resource_default_data_init(&ctx->test_data_vertex, arg);
1785     resource_default_data_init(&ctx->test_data_pixel, arg);
1786     resource_poison_data_init(&ctx->poison_data, arg);
1787
1788     ctx->test_data_vertex.vs = ctx->test_data_all.vs;
1789     ctx->test_data_pixel.ps = ctx->test_data_all.ps;
1790
1791     return D3D_OK;
1792 }
1793
1794 static void resource_test_cleanup(IDirect3DDevice8 *device, struct state_test *test)
1795 {
1796     struct resource_test_context *ctx = test->test_context;
1797     const struct resource_test_arg *arg = test->test_arg;
1798     unsigned int i;
1799     HRESULT hr;
1800
1801     resource_apply_data(device, test, &ctx->default_data);
1802
1803     if (ctx->test_data_all.vs)
1804     {
1805         hr = IDirect3DDevice8_DeleteVertexShader(device, ctx->test_data_all.vs);
1806         ok(SUCCEEDED(hr), "DeleteVertexShader (%u) returned %#x.\n", ctx->test_data_all.vs, hr);
1807     }
1808
1809     if (ctx->test_data_all.ps)
1810     {
1811         hr = IDirect3DDevice8_DeletePixelShader(device, ctx->test_data_all.ps);
1812         ok(SUCCEEDED(hr), "DeletePixelShader (%u) returned %#x.\n", ctx->test_data_all.ps, hr);
1813     }
1814
1815     IDirect3DIndexBuffer8_Release(ctx->test_data_all.ib);
1816     for (i = 0; i < arg->stream_count; ++i)
1817     {
1818         IDirect3DVertexBuffer8_Release(ctx->test_data_all.vb[i]);
1819     }
1820
1821     for (i = 0; i < arg->tex_count; ++i)
1822     {
1823         IDirect3DBaseTexture8_Release(ctx->test_data_all.tex[i]);
1824     }
1825
1826     HeapFree(GetProcessHeap(), 0, ctx->default_data.vb);
1827     HeapFree(GetProcessHeap(), 0, ctx->default_data.tex);
1828     HeapFree(GetProcessHeap(), 0, ctx->test_data_all.vb);
1829     HeapFree(GetProcessHeap(), 0, ctx->test_data_all.tex);
1830     HeapFree(GetProcessHeap(), 0, ctx->test_data_vertex.vb);
1831     HeapFree(GetProcessHeap(), 0, ctx->test_data_vertex.tex);
1832     HeapFree(GetProcessHeap(), 0, ctx->test_data_pixel.vb);
1833     HeapFree(GetProcessHeap(), 0, ctx->test_data_pixel.tex);
1834     HeapFree(GetProcessHeap(), 0, ctx->poison_data.vb);
1835     HeapFree(GetProcessHeap(), 0, ctx->poison_data.tex);
1836     HeapFree(GetProcessHeap(), 0, ctx);
1837 }
1838
1839 static void resource_test_queue(struct state_test *test, const struct resource_test_arg *test_arg)
1840 {
1841     test->init = resource_test_init;
1842     test->cleanup = resource_test_cleanup;
1843     test->apply_data = resource_apply_data;
1844     test->check_data = resource_check_data;
1845     test->test_name = "set_get_resources";
1846     test->test_arg = test_arg;
1847 }
1848
1849 /* =================== Main state tests function =============================== */
1850
1851 static void test_state_management(IDirect3DDevice8 *device, D3DPRESENT_PARAMETERS *device_pparams)
1852 {
1853     D3DCAPS8 caps;
1854     HRESULT hr;
1855
1856     /* Test count: 2 for shader constants
1857      *             1 for lights
1858      *             1 for transforms
1859      *             1 for render states
1860      *             1 for resources
1861      */
1862     struct state_test tests[6];
1863     unsigned int tcount = 0;
1864
1865     struct shader_constant_arg pshader_constant_arg;
1866     struct shader_constant_arg vshader_constant_arg;
1867     struct resource_test_arg resource_test_arg;
1868     struct render_state_arg render_state_arg;
1869     struct light_arg light_arg;
1870
1871     hr = IDirect3DDevice8_GetDeviceCaps(device, &caps);
1872     ok(SUCCEEDED(hr), "GetDeviceCaps returned %#x.\n", hr);
1873     if (FAILED(hr)) return;
1874
1875     texture_stages = caps.MaxTextureBlendStages;
1876
1877     /* Zero test memory */
1878     memset(tests, 0, sizeof(tests));
1879
1880     if (caps.VertexShaderVersion & 0xffff)
1881     {
1882         vshader_constant_arg.idx = 0;
1883         vshader_constant_arg.pshader = FALSE;
1884         shader_constants_queue_test(&tests[tcount++], &vshader_constant_arg);
1885     }
1886
1887     if (caps.PixelShaderVersion & 0xffff)
1888     {
1889         pshader_constant_arg.idx = 0;
1890         pshader_constant_arg.pshader = TRUE;
1891         shader_constants_queue_test(&tests[tcount++], &pshader_constant_arg);
1892     }
1893
1894     light_arg.idx = 0;
1895     lights_queue_test(&tests[tcount++], &light_arg);
1896
1897     transform_queue_test(&tests[tcount++]);
1898
1899     render_state_arg.device_pparams = device_pparams;
1900     render_state_arg.pointsize_max = caps.MaxPointSize;
1901     render_states_queue_test(&tests[tcount++], &render_state_arg);
1902
1903     resource_test_arg.vs_version = caps.VertexShaderVersion & 0xffff;
1904     resource_test_arg.ps_version = caps.PixelShaderVersion & 0xffff;
1905     resource_test_arg.stream_count = caps.MaxStreams;
1906     resource_test_arg.tex_count = caps.MaxTextureBlendStages;
1907     resource_test_queue(&tests[tcount++], &resource_test_arg);
1908
1909     execute_test_chain_all(device, tests, tcount);
1910 }
1911
1912 static void test_shader_constant_apply(IDirect3DDevice8 *device)
1913 {
1914     static const float initial[] = {0.0f, 0.0f, 0.0f, 0.0f};
1915     static const float vs_const[] = {1.0f, 2.0f, 3.0f, 4.0f};
1916     static const float ps_const[] = {5.0f, 6.0f, 7.0f, 8.0f};
1917     DWORD vs_version, ps_version;
1918     DWORD stateblock;
1919     D3DCAPS8 caps;
1920     float ret[4];
1921     HRESULT hr;
1922
1923     hr = IDirect3DDevice8_GetDeviceCaps(device, &caps);
1924     ok(SUCCEEDED(hr), "GetDeviceCaps returned %#x.\n", hr);
1925     vs_version = caps.VertexShaderVersion & 0xffff;
1926     ps_version = caps.PixelShaderVersion & 0xffff;
1927
1928     if (vs_version)
1929     {
1930         hr = IDirect3DDevice8_SetVertexShaderConstant(device, 0, initial, 1);
1931         ok(SUCCEEDED(hr), "SetVertexShaderConstant returned %#x.\n", hr);
1932         hr = IDirect3DDevice8_SetVertexShaderConstant(device, 1, initial, 1);
1933         ok(SUCCEEDED(hr), "SetVertexShaderConstant returned %#x.\n", hr);
1934
1935         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 0, ret, 1);
1936         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
1937         ok(!memcmp(ret, initial, sizeof(initial)),
1938                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1939                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
1940         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 1, ret, 1);
1941         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x\n", hr);
1942         ok(!memcmp(ret, initial, sizeof(initial)),
1943                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1944                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
1945
1946         hr = IDirect3DDevice8_SetVertexShaderConstant(device, 0, vs_const, 1);
1947         ok(SUCCEEDED(hr), "SetVertexShaderConstant returned %#x.\n", hr);
1948     }
1949     if (ps_version)
1950     {
1951         hr = IDirect3DDevice8_SetPixelShaderConstant(device, 0, initial, 1);
1952         ok(SUCCEEDED(hr), "SetPixelShaderConstant returned %#x.\n", hr);
1953         hr = IDirect3DDevice8_SetPixelShaderConstant(device, 1, initial, 1);
1954         ok(SUCCEEDED(hr), "SetPixelShaderConstant returned %#x.\n", hr);
1955
1956         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 0, ret, 1);
1957         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
1958         ok(!memcmp(ret, initial, sizeof(initial)),
1959                 "GetpixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1960                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
1961         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 1, ret, 1);
1962         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
1963         ok(!memcmp(ret, initial, sizeof(initial)),
1964                 "GetPixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1965                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
1966
1967         hr = IDirect3DDevice8_SetPixelShaderConstant(device, 0, ps_const, 1);
1968         ok(SUCCEEDED(hr), "SetPixelShaderConstant returned %#x.\n", hr);
1969     }
1970
1971     hr = IDirect3DDevice8_BeginStateBlock(device);
1972     ok(SUCCEEDED(hr), "BeginStateBlock returned %#x\n", hr);
1973
1974     if (vs_version)
1975     {
1976         hr = IDirect3DDevice8_SetVertexShaderConstant(device, 1, vs_const, 1);
1977         ok(SUCCEEDED(hr), "SetVertexShaderConstant returned %#x.\n", hr);
1978     }
1979     if (ps_version)
1980     {
1981         hr = IDirect3DDevice8_SetPixelShaderConstant(device, 1, ps_const, 1);
1982         ok(SUCCEEDED(hr), "SetPixelShaderConstant returned %#x.\n", hr);
1983     }
1984
1985     hr = IDirect3DDevice8_EndStateBlock(device, &stateblock);
1986     ok(SUCCEEDED(hr), "EndStateBlock returned %#x\n", hr);
1987
1988     if (vs_version)
1989     {
1990         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 0, ret, 1);
1991         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
1992         ok(!memcmp(ret, vs_const, sizeof(vs_const)),
1993                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1994                 ret[0], ret[1], ret[2], ret[3], vs_const[0], vs_const[1], vs_const[2], vs_const[3]);
1995         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 1, ret, 1);
1996         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
1997         ok(!memcmp(ret, initial, sizeof(initial)),
1998                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
1999                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
2000     }
2001     if (ps_version)
2002     {
2003         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 0, ret, 1);
2004         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
2005         ok(!memcmp(ret, ps_const, sizeof(ps_const)),
2006                 "GetPixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2007                 ret[0], ret[1], ret[2], ret[3], ps_const[0], ps_const[1], ps_const[2], ps_const[3]);
2008         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 1, ret, 1);
2009         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
2010         ok(!memcmp(ret, initial, sizeof(initial)),
2011                 "GetPixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2012                 ret[0], ret[1], ret[2], ret[3], initial[0], initial[1], initial[2], initial[3]);
2013     }
2014
2015     /* Apply doesn't overwrite constants that aren't explicitly set on the source stateblock. */
2016     hr = IDirect3DDevice8_ApplyStateBlock(device, stateblock);
2017     ok(SUCCEEDED(hr), "Apply returned %#x\n", hr);
2018
2019     if (vs_version)
2020     {
2021         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 0, ret, 1);
2022         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
2023         ok(!memcmp(ret, vs_const, sizeof(vs_const)),
2024                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2025                 ret[0], ret[1], ret[2], ret[3], vs_const[0], vs_const[1], vs_const[2], vs_const[3]);
2026         hr = IDirect3DDevice8_GetVertexShaderConstant(device, 1, ret, 1);
2027         ok(SUCCEEDED(hr), "GetVertexShaderConstant returned %#x.\n", hr);
2028         ok(!memcmp(ret, vs_const, sizeof(vs_const)),
2029                 "GetVertexShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2030                 ret[0], ret[1], ret[2], ret[3], vs_const[0], vs_const[1], vs_const[2], vs_const[3]);
2031     }
2032     if (ps_version)
2033     {
2034         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 0, ret, 1);
2035         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
2036         ok(!memcmp(ret, ps_const, sizeof(ps_const)),
2037                 "GetPixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2038                 ret[0], ret[1], ret[2], ret[3], ps_const[0], ps_const[1], ps_const[2], ps_const[3]);
2039         hr = IDirect3DDevice8_GetPixelShaderConstant(device, 1, ret, 1);
2040         ok(SUCCEEDED(hr), "GetPixelShaderConstant returned %#x.\n", hr);
2041         ok(!memcmp(ret, ps_const, sizeof(ps_const)),
2042                 "GetPixelShaderConstant got {%f, %f, %f, %f}, expected {%f, %f, %f, %f}\n",
2043                 ret[0], ret[1], ret[2], ret[3], ps_const[0], ps_const[1], ps_const[2], ps_const[3]);
2044     }
2045
2046     IDirect3DDevice8_DeleteStateBlock(device, stateblock);
2047 }
2048
2049 START_TEST(stateblock)
2050 {
2051     IDirect3DDevice8 *device = NULL;
2052     D3DPRESENT_PARAMETERS device_pparams;
2053     HMODULE d3d8_module;
2054     ULONG refcount;
2055     HRESULT hr;
2056
2057     d3d8_module = LoadLibraryA("d3d8.dll");
2058     if (!d3d8_module)
2059     {
2060         skip("Could not load d3d8.dll\n");
2061         return;
2062     }
2063
2064     hr = init_d3d8(d3d8_module, &device, &device_pparams);
2065     if (FAILED(hr))
2066     {
2067         FreeLibrary(d3d8_module);
2068         return;
2069     }
2070
2071     test_begin_end_state_block(device);
2072     test_state_management(device, &device_pparams);
2073     test_shader_constant_apply(device);
2074
2075     refcount = IDirect3DDevice8_Release(device);
2076     ok(!refcount, "Device has %u references left\n", refcount);
2077
2078     FreeLibrary(d3d8_module);
2079 }