msxml3: Don't allocate new strings when returning namespace related data.
[wine] / 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 }