[D3D9] Resend, Test: State management test framework for d3d9
Ivan Gyurdiev
ivg231 at gmail.com
Thu Jul 20 22:08:42 CDT 2006
Add a framework to test device state management. It's an event-based
loop that executes functions, and does memcmp testing in response to
command events. The functions and commands to execute describe a
particular test pattern to run. A test structure describes a particular
state test to run. Each test is ran through each test pattern (event
sequence).
For more detail, see post on wine-devel.
Tests:
======
- The missing light recording test was converted to this new framework
- The vertex shader constant test was converted to this new framework
(and I added pixel shader constants)
- Added a new test for render states
- Added a new test for transforms
Test patterns/Event sequences:
==============================
1) Initial Value - read data, compare to initial sample
2) Write/Read - write data, read data, compare to test sample
3) Stateblock Abort - start block, write data, end block, release block,
compare to default sample
4) Stateblock Apply - start block, write data, end block, apply block,
compare to test sample
5) Stateblock Capture/Reapply - start block, write data, end block,
capture, compare to default sample, write data (again), apply, compare
to default sample
6) Render Target Switch - write data, switch render target, compare to
test sample, revert render target
7) Render Target/Stateblock Interaction - start block, write data,
switch render target, compare to default sample, end block, revert
render target, apply block, compare to test sample
-------------- next part --------------
---
dlls/d3d9/tests/shader.c | 38 -
dlls/d3d9/tests/stateblock.c | 1354 +++++++++++++++++++++++++++++++++++++++---
2 files changed, 1262 insertions(+), 130 deletions(-)
93854ba291ab330923c4f3b642c04b934edb0bce
diff --git a/dlls/d3d9/tests/shader.c b/dlls/d3d9/tests/shader.c
index e6a10b4..522c8d9 100644
--- a/dlls/d3d9/tests/shader.c
+++ b/dlls/d3d9/tests/shader.c
@@ -104,43 +104,6 @@ static void test_get_set_vertex_shader(I
"Expected hret 0x%lx, current_shader_ptr %p, refcount %d.\n", hret, current_shader_ptr, shader_refcount, D3D_OK, shader_ptr, i);
}
-static void test_get_set_vertex_shader_constants(IDirect3DDevice9 *device_ptr)
-{
- HRESULT hret;
- int int_in[4] = {0xdead0000, 0xdead0001, 0xdead0002, 0xdead0003};
- int int_out[4] = {0};
- float float_in[4] = {0.14f, 0.15f, 0.92f, 0.65f};
- float float_out[4] = {0};
- BOOL bool_in[4] = {TRUE, FALSE, FALSE, TRUE};
- BOOL bool_out[4] = {0};
-
- hret = IDirect3DDevice9_SetVertexShaderConstantI(device_ptr, 0, int_in, 1);
- ok(hret == D3D_OK, "SetVertexShaderConstantI returned %#lx.\n", hret);
- hret = IDirect3DDevice9_SetVertexShaderConstantF(device_ptr, 0, float_in, 1);
- ok(hret == D3D_OK, "SetVertexShaderConstantF returned %#lx.\n", hret);
- hret = IDirect3DDevice9_SetVertexShaderConstantB(device_ptr, 0, bool_in, 4);
- ok(hret == D3D_OK, "SetVertexShaderConstantB returned %#lx.\n", hret);
-
- hret = IDirect3DDevice9_GetVertexShaderConstantI(device_ptr, 0, int_out, 1);
- ok(hret == D3D_OK, "GetVertexShaderConstantI returned %#lx.\n", hret);
- hret = IDirect3DDevice9_GetVertexShaderConstantF(device_ptr, 0, float_out, 1);
- ok(hret == D3D_OK, "GetVertexShaderConstantF returned %#lx.\n", hret);
- hret = IDirect3DDevice9_GetVertexShaderConstantB(device_ptr, 0, bool_out, 4);
- ok(hret == D3D_OK, "GetVertexShaderConstantB returned %#lx.\n", hret);
-
- /* The constant arrays aren't shared between I/F/B, so they shouldn't
- * overwrite eachother's values */
- ok(!memcmp(int_in, int_out, sizeof(int_in)),
- "Int constant data doesn't match (%#x, %#x, %#x, %#x).\n",
- int_out[0], int_out[1], int_out[2], int_out[3]);
- ok(!memcmp(float_in, float_out, sizeof(float_in)),
- "Float constant data doesn't match (%f, %f, %f, %f).\n",
- float_out[0], float_out[1], float_out[2], float_out[3]);
- ok(!memcmp(bool_in, bool_out, sizeof(bool_in)),
- "Bool constant data doesn't match (%#x, %#x, %#x, %#x).\n",
- bool_out[0], bool_out[1], bool_out[2], bool_out[3]);
-}
-
static void test_get_set_pixel_shader(IDirect3DDevice9 *device_ptr)
{
static DWORD simple_ps[] = {0xFFFF0101, /* ps_1_1 */
@@ -198,7 +161,6 @@ START_TEST(shader)
if (caps.VertexShaderVersion & 0xffff)
{
test_get_set_vertex_shader(device_ptr);
- test_get_set_vertex_shader_constants(device_ptr);
}
else trace("No vertex shader support, skipping test\n");
diff --git a/dlls/d3d9/tests/stateblock.c b/dlls/d3d9/tests/stateblock.c
index 178edf5..3eb5d6e 100644
--- a/dlls/d3d9/tests/stateblock.c
+++ b/dlls/d3d9/tests/stateblock.c
@@ -1,5 +1,6 @@
/*
* Copyright (C) 2005 Henri Verbeet
+ * Copyright (C) 2006 Ivan Gyurdiev
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -33,32 +34,34 @@ static HWND create_window(void)
0, 0, 0, 0, 0, 0, 0, 0, 0);
}
-static IDirect3DDevice9 *init_d3d9(void)
+static HRESULT init_d3d9(
+ IDirect3DDevice9** device,
+ D3DPRESENT_PARAMETERS* device_pparams)
{
IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0;
IDirect3D9 *d3d9_ptr = 0;
- IDirect3DDevice9 *device_ptr = 0;
- D3DPRESENT_PARAMETERS present_parameters;
HRESULT hres;
+ HWND window;
d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9");
ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n");
- if (!d3d9_create) return NULL;
+ if (!d3d9_create) return E_FAIL;
d3d9_ptr = d3d9_create(D3D_SDK_VERSION);
ok(d3d9_ptr != NULL, "Failed to create IDirect3D9 object\n");
- if (!d3d9_ptr) return NULL;
+ if (!d3d9_ptr) return E_FAIL;
- ZeroMemory(&present_parameters, sizeof(present_parameters));
- present_parameters.Windowed = TRUE;
- present_parameters.hDeviceWindow = create_window();
- present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
+ window = create_window();
- hres = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, NULL,
- D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr);
- ok(hres == D3D_OK, "IDirect3D_CreateDevice returned: 0x%lx\n", hres);
+ ZeroMemory(device_pparams, sizeof(D3DPRESENT_PARAMETERS));
+ device_pparams->Windowed = TRUE;
+ device_pparams->hDeviceWindow = window;
+ device_pparams->SwapEffect = D3DSWAPEFFECT_DISCARD;
- return device_ptr;
+ hres = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_NULLREF, window,
+ D3DCREATE_SOFTWARE_VERTEXPROCESSING, device_pparams, device);
+ ok(hres == D3D_OK, "IDirect3D_CreateDevice returned: 0x%lx\n", hres);
+ return hres;
}
static void test_begin_end_state_block(IDirect3DDevice9 *device_ptr)
@@ -91,96 +94,1261 @@ static void test_begin_end_state_block(I
"Expected hret 0x%lx, state_block_ptr 0xdeadbeef.\n", hret, state_block_ptr, D3DERR_INVALIDCALL);
}
-static void test_missing_light_recording(IDirect3DDevice9 *device_ptr)
+/* ============================ State Testing Framework ========================== */
+
+typedef struct state_test {
+ const char* test_name;
+
+ /* The initial data is usually the same
+ * as the default data, but a write can have side effects.
+ * The initial data is tested first, before any writes take place
+ * The default data can be tested after a write */
+ const void* initial_data;
+
+ /* The default data is the standard state to compare
+ * against, and restore to */
+ const void* default_data;
+
+ /* The test data is the experiment data to try
+ * in - what we want to write
+ * out - what windows will actually write (not necessarily the same) */
+ const void* test_data_in;
+ const void* test_data_out;
+
+ /* The poison data is the data to preinitialize the return buffer to */
+ const void* poison_data;
+
+ /* Return buffer */
+ void* return_data;
+
+ unsigned int data_size;
+
+ void (*set_handler) (IDirect3DDevice9* device, const void* data, void* set_arg);
+ void (*get_handler) (IDirect3DDevice9* device, const void* data, void* get_arg);
+ void (*print_handler) (const void* data);
+
+ void* set_arg;
+ void* get_arg;
+
+} state_test;
+
+/* See below for explanation of the flags */
+#define EVENT_OK 0x00
+#define EVENT_CHECK_DEFAULT 0x01
+#define EVENT_CHECK_INITIAL 0x02
+#define EVENT_CHECK_TEST 0x04
+#define EVENT_ERROR 0x08
+#define EVENT_APPLY_DATA 0x10
+
+typedef struct event {
+ int (*event_fn) (IDirect3DDevice9* device, void* arg);
+ int status;
+} event;
+
+/* This is an event-machine, which tests things.
+ * It tests get and set operations for a batch of states, based on
+ * results from the event function, which directs what's to be done */
+
+static void execute_test_chain(
+ IDirect3DDevice9* device,
+ state_test* test,
+ unsigned int ntests,
+ event *event,
+ unsigned int nevents,
+ void* event_arg) {
+
+ int outcome;
+ unsigned int i = 0, j;
+
+ /* For each queued event */
+ for (j=0; j < nevents; j++) {
+
+ /* Execute the next event handler (if available) or just set the supplied status */
+ outcome = event[j].status;
+ if (event[j].event_fn)
+ outcome |= event[j].event_fn(device, event_arg);
+
+ /* Now verify correct outcome depending on what was signaled by the handler.
+ * An EVENT_CHECK_TEST signal means check the returned data against the test_data (out).
+ * An EVENT_CHECK_DEFAULT signal means check the returned data against the default_data.
+ * An EVENT_CHECK_INITIAL signal means check the returned data against the initial_data.
+ * An EVENT_ERROR signal means the test isn't going to work, exit the event loop.
+ * An EVENT_APPLY_DATA signal means load the test data (after checks) */
+
+ if (outcome & EVENT_ERROR) {
+ trace("Test %s, Stage %u in error state, aborting\n", test[i].test_name, j);
+ break;
+
+ } else if (outcome & EVENT_CHECK_TEST || outcome & EVENT_CHECK_DEFAULT || outcome & EVENT_CHECK_INITIAL) {
+
+ for (i=0; i < ntests; i++) {
+
+ memcpy(test[i].return_data, test[i].poison_data, test[i].data_size);
+ test[i].get_handler(device, test[i].return_data, test[i].get_arg);
+ if ((outcome & EVENT_CHECK_TEST) &&
+ memcmp(test[i].test_data_out, test[i].return_data, test[i].data_size)) {
+
+ ok(FALSE, "Test %s, Stage %u: change applied, but returned data does not "
+ "match test data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
+
+ if (test[i].print_handler) {
+ trace("Returned data was:\n");
+ test[i].print_handler(test[i].return_data);
+ trace("Test data was:\n");
+ test[i].print_handler(test[i].test_data_out);
+ }
+ }
+
+ else if ((outcome & EVENT_CHECK_DEFAULT) &&
+ memcmp(test[i].default_data, test[i].return_data, test[i].data_size)) {
+
+ ok (FALSE, "Test %s, Stage %u: change aborted, but returned data does not "
+ "match default data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
+
+ if (test[i].print_handler) {
+ trace("Returned data was:\n");
+ test[i].print_handler(test[i].return_data);
+ trace("Default data was:\n");
+ test[i].print_handler(test[i].default_data);
+ }
+ }
+
+ else if ((outcome & EVENT_CHECK_INITIAL) &&
+ memcmp(test[i].initial_data, test[i].return_data, test[i].data_size)) {
+
+ ok (FALSE, "Test %s, Stage %u: returned data does not "
+ "match initial data [csize=%u]\n", test[i].test_name, j, test[i].data_size);
+
+ if (test[i].print_handler) {
+ trace("Returned data was:\n");
+ test[i].print_handler(test[i].return_data);
+ trace("Initial data was:\n");
+ test[i].print_handler(test[i].initial_data);
+ }
+ }
+ }
+ }
+
+ if (outcome & EVENT_APPLY_DATA) {
+ for (i=0; i < ntests; i++)
+ test[i].set_handler(device, test[i].test_data_in, test[i].set_arg);
+ }
+ }
+
+ /* Attempt to reset any changes made */
+ for (i=0; i < ntests; i++)
+ test[i].set_handler(device, test[i].default_data, test[i].set_arg);
+}
+
+typedef struct event_data {
+ IDirect3DStateBlock9* stateblock;
+ IDirect3DSurface9* original_render_target;
+} event_data;
+
+static int switch_render_target(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ HRESULT hret;
+ D3DPRESENT_PARAMETERS present_parameters;
+ event_data* edata = (event_data*) data;
+ IDirect3DSwapChain9* swapchain = NULL;
+ IDirect3DSurface9* backbuffer = NULL;
+
+ /* Parameters for new swapchain */
+ ZeroMemory(&present_parameters, sizeof(present_parameters));
+ present_parameters.Windowed = TRUE;
+ present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD;
+
+ /* Create new swapchain */
+ hret = IDirect3DDevice9_CreateAdditionalSwapChain(device, &present_parameters, &swapchain);
+ ok (hret == D3D_OK, "CreateAdditionalSwapChain returned %#lx.\n", hret);
+ if (hret != D3D_OK) goto error;
+
+ /* Get its backbuffer */
+ hret = IDirect3DSwapChain9_GetBackBuffer(swapchain, 0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+ ok (hret == D3D_OK, "GetBackBuffer returned %#lx.\n", hret);
+ if (hret != D3D_OK) goto error;
+
+ /* Save the current render target */
+ hret = IDirect3DDevice9_GetRenderTarget(device, 0, &edata->original_render_target);
+ ok (hret == D3D_OK, "GetRenderTarget returned %#lx.\n", hret);
+ if (hret != D3D_OK) goto error;
+
+ /* Set the new swapchain's backbuffer as a render target */
+ hret = IDirect3DDevice9_SetRenderTarget(device, 0, backbuffer);
+ ok (hret == D3D_OK, "SetRenderTarget returned %#lx.\n", hret);
+ if (hret != D3D_OK) goto error;
+
+ IUnknown_Release(backbuffer);
+ IUnknown_Release(swapchain);
+ return EVENT_OK;
+
+ error:
+ if (backbuffer) IUnknown_Release(backbuffer);
+ if (swapchain) IUnknown_Release(swapchain);
+ return EVENT_ERROR;
+}
+
+static int revert_render_target(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ HRESULT hret;
+ event_data* edata = (event_data*) data;
+
+ /* Reset the old render target */
+ hret = IDirect3DDevice9_SetRenderTarget(device, 0, edata->original_render_target);
+ ok (hret == D3D_OK, "SetRenderTarget returned %#lx.\n", hret);
+ if (hret != D3D_OK) {
+ IUnknown_Release(edata->original_render_target);
+ return EVENT_ERROR;
+ }
+
+ IUnknown_Release(edata->original_render_target);
+ return EVENT_OK;
+}
+
+static int begin_stateblock(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ HRESULT hret;
+
+ data = NULL;
+ hret = IDirect3DDevice9_BeginStateBlock(device);
+ ok(hret == D3D_OK, "BeginStateBlock returned %#lx.\n", hret);
+ if (hret != D3D_OK) return EVENT_ERROR;
+ return EVENT_OK;
+}
+
+static int end_stateblock(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ HRESULT hret;
+ event_data* edata = (event_data*) data;
+
+ hret = IDirect3DDevice9_EndStateBlock(device, &edata->stateblock);
+ ok(hret == D3D_OK, "EndStateBlock returned %#lx.\n", hret);
+ if (hret != D3D_OK) return EVENT_ERROR;
+ return EVENT_OK;
+}
+
+static int abort_stateblock(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ event_data* edata = (event_data*) data;
+
+ IUnknown_Release(edata->stateblock);
+ return EVENT_OK;
+}
+
+static int apply_stateblock(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ event_data* edata = (event_data*) data;
+ HRESULT hret;
+
+ hret = IDirect3DStateBlock9_Apply(edata->stateblock);
+ ok(hret == D3D_OK, "Apply returned %#lx.\n", hret);
+ if (hret != D3D_OK) {
+ IUnknown_Release(edata->stateblock);
+ return EVENT_ERROR;
+ }
+
+ IUnknown_Release(edata->stateblock);
+ return EVENT_OK;
+}
+
+static int capture_stateblock(
+ IDirect3DDevice9* device,
+ void* data) {
+
+ HRESULT hret;
+ event_data* edata = (event_data*) data;
+
+ hret = IDirect3DStateBlock9_Capture(edata->stateblock);
+ ok(hret == D3D_OK, "Capture returned %#lx.\n", hret);
+ if (hret != D3D_OK)
+ return EVENT_ERROR;
+
+ return EVENT_OK;
+}
+
+static void execute_test_chain_all(
+ IDirect3DDevice9* device,
+ state_test* test,
+ unsigned int ntests) {
+
+ event_data arg;
+
+ event read_events[] = {
+ { NULL, EVENT_CHECK_INITIAL }
+ };
+
+ event write_read_events[] = {
+ { NULL, EVENT_APPLY_DATA },
+ { NULL, EVENT_CHECK_TEST }
+ };
+
+ event abort_stateblock_events[] = {
+ { begin_stateblock, EVENT_APPLY_DATA },
+ { end_stateblock, EVENT_OK },
+ { abort_stateblock, EVENT_CHECK_DEFAULT }
+ };
+
+ event apply_stateblock_events[] = {
+ { begin_stateblock, EVENT_APPLY_DATA },
+ { end_stateblock, EVENT_OK },
+ { apply_stateblock, EVENT_CHECK_TEST }
+ };
+
+ event capture_reapply_stateblock_events[] = {
+ { begin_stateblock, EVENT_APPLY_DATA },
+ { end_stateblock, EVENT_OK },
+ { capture_stateblock, EVENT_CHECK_DEFAULT | EVENT_APPLY_DATA },
+ { apply_stateblock, EVENT_CHECK_DEFAULT }
+ };
+
+ event rendertarget_switch_events[] = {
+ { NULL, EVENT_APPLY_DATA },
+ { switch_render_target, EVENT_CHECK_TEST },
+ { revert_render_target, EVENT_OK }
+ };
+
+ event rendertarget_stateblock_events[] = {
+ { begin_stateblock, EVENT_APPLY_DATA },
+ { switch_render_target, EVENT_CHECK_DEFAULT },
+ { end_stateblock, EVENT_OK },
+ { revert_render_target, EVENT_OK },
+ { apply_stateblock, EVENT_CHECK_TEST }
+ };
+
+ trace("Running initial read state tests\n");
+ execute_test_chain(device, test, ntests, read_events, 1, NULL);
+
+ trace("Running write-read state tests\n");
+ execute_test_chain(device, test, ntests, write_read_events, 2, NULL);
+
+ trace("Running stateblock abort state tests\n");
+ execute_test_chain(device, test, ntests, abort_stateblock_events, 3, &arg);
+
+ trace("Running stateblock apply state tests\n");
+ execute_test_chain(device, test, ntests, apply_stateblock_events, 3, &arg);
+
+ trace("Running stateblock capture/reapply state tests\n");
+ execute_test_chain(device, test, ntests, capture_reapply_stateblock_events, 4, &arg);
+
+ trace("Running rendertarget switch state tests\n");
+ execute_test_chain(device, test, ntests, rendertarget_switch_events, 3, &arg);
+
+ trace("Running stateblock apply over rendertarget switch interrupt tests\n");
+ execute_test_chain(device, test, ntests, rendertarget_stateblock_events, 5, &arg);
+}
+
+/* =================== State test: Pixel and Vertex Shader constants ============ */
+
+typedef struct shader_constant_data {
+ int int_constant[4]; /* 1x4 integer constant */
+ float float_constant[4]; /* 1x4 float constant */
+ BOOL bool_constant[4]; /* 4x1 boolean constants */
+} shader_constant_data;
+
+typedef struct shader_constant_arg {
+ unsigned int idx;
+ BOOL pshader;
+} shader_constant_arg;
+
+static void shader_constant_print_handler(
+ const void* data) {
+
+ shader_constant_data* scdata = (shader_constant_data*) data;
+
+ trace("Integer constant = { %#x, %#x, %#x, %#x }\n",
+ scdata->int_constant[0], scdata->int_constant[1],
+ scdata->int_constant[2], scdata->int_constant[3]);
+
+ trace("Float constant = { %f, %f, %f, %f }\n",
+ scdata->float_constant[0], scdata->float_constant[1],
+ scdata->float_constant[2], scdata->float_constant[3]);
+
+ trace("Boolean constants = [ %#x, %#x, %#x, %#x ]\n",
+ scdata->bool_constant[0], scdata->bool_constant[1],
+ scdata->bool_constant[2], scdata->bool_constant[3]);
+}
+
+static void shader_constant_set_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ shader_constant_data* scdata = (shader_constant_data*) data;
+ shader_constant_arg* scarg = (shader_constant_arg*) arg;
+ unsigned int index = scarg->idx;
+
+ if (!scarg->pshader) {
+ hret = IDirect3DDevice9_SetVertexShaderConstantI(device, index, scdata->int_constant, 1);
+ ok(hret == D3D_OK, "SetVertexShaderConstantI returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_SetVertexShaderConstantF(device, index, scdata->float_constant, 1);
+ ok(hret == D3D_OK, "SetVertexShaderConstantF returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_SetVertexShaderConstantB(device, index, scdata->bool_constant, 4);
+ ok(hret == D3D_OK, "SetVertexShaderConstantB returned %#lx.\n", hret);
+
+ } else {
+ hret = IDirect3DDevice9_SetPixelShaderConstantI(device, index, scdata->int_constant, 1);
+ ok(hret == D3D_OK, "SetPixelShaderConstantI returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_SetPixelShaderConstantF(device, index, scdata->float_constant, 1);
+ ok(hret == D3D_OK, "SetPixelShaderConstantF returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_SetPixelShaderConstantB(device, index, scdata->bool_constant, 4);
+ ok(hret == D3D_OK, "SetPixelShaderConstantB returned %#lx.\n", hret);
+ }
+}
+
+static void shader_constant_get_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ shader_constant_data* scdata = (shader_constant_data*) data;
+ shader_constant_arg* scarg = (shader_constant_arg*) arg;
+ unsigned int index = scarg->idx;
+
+ if (!scarg->pshader) {
+ hret = IDirect3DDevice9_GetVertexShaderConstantI(device, index, scdata->int_constant, 1);
+ ok(hret == D3D_OK, "GetVertexShaderConstantI returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_GetVertexShaderConstantF(device, index, scdata->float_constant, 1);
+ ok(hret == D3D_OK, "GetVertexShaderConstantF returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_GetVertexShaderConstantB(device, index, scdata->bool_constant, 4);
+ ok(hret == D3D_OK, "GetVertexShaderConstantB returned %#lx.\n", hret);
+
+ } else {
+ hret = IDirect3DDevice9_GetPixelShaderConstantI(device, index, scdata->int_constant, 1);
+ ok(hret == D3D_OK, "GetPixelShaderConstantI returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_GetPixelShaderConstantF(device, index, scdata->float_constant, 1);
+ ok(hret == D3D_OK, "GetPixelShaderConstantF returned %#lx.\n", hret);
+ hret = IDirect3DDevice9_GetPixelShaderConstantB(device, index, scdata->bool_constant, 4);
+ ok(hret == D3D_OK, "GetPixelShaderConstantB returned %#lx.\n", hret);
+ }
+}
+
+static const shader_constant_data shader_constant_poison_data = {
+ { 0x1337c0de, 0x1337c0de, 0x1337c0de, 0x1337c0de },
+ { 1.0f, 2.0f, 3.0f, 4.0f },
+ { FALSE, TRUE, FALSE, TRUE }
+};
+
+static const shader_constant_data shader_constant_default_data = {
+ { 0, 0, 0, 0 }, { 0.0f, 0.0f, 0.0f, 0.0f }, { 0, 0, 0, 0 }
+};
+
+static const shader_constant_data shader_constant_test_data = {
+ { 0xdead0000, 0xdead0001, 0xdead0002, 0xdead0003 },
+ { 0.0f, 0.0f, 0.0f, 0.0f },
+ { TRUE, FALSE, FALSE, TRUE }
+};
+
+#define SHADER_CONSTANTS_REQ_BUFFER \
+ (sizeof(shader_constant_data) + sizeof(shader_constant_arg))
+
+static void shader_constants_queue_test(
+ IDirect3DDevice9 *device,
+ state_test* test,
+ void* buffer,
+ BOOL pshader)
+{
+ shader_constant_arg* arg = buffer;
+ shader_constant_data* return_data = (shader_constant_data*) (arg + 1);
+
+ test->test_data_in = &shader_constant_test_data;
+ test->test_data_out = &shader_constant_test_data;
+ test->default_data = &shader_constant_default_data;
+ test->initial_data = &shader_constant_default_data;
+ test->poison_data = &shader_constant_poison_data;
+ test->return_data = return_data;
+ test->data_size = sizeof(shader_constant_data);
+ test->set_handler = shader_constant_set_handler;
+ test->get_handler = shader_constant_get_handler;
+ test->print_handler = shader_constant_print_handler;
+ test->get_arg = test->set_arg = arg;
+ test->test_name = pshader? "set_get_pshader_constants": "set_get_vshader_constants";
+ arg->idx = 0;
+ arg->pshader = pshader;
+}
+
+/* =================== State test: Lights ===================================== */
+
+typedef struct light_data {
+ D3DLIGHT9 light;
+ BOOL enabled;
+ HRESULT get_light_result;
+ HRESULT get_enabled_result;
+} light_data;
+
+typedef struct light_arg {
+ unsigned int idx;
+} light_arg;
+
+static void light_print_handler(
+ const void* data) {
+
+ light_data* ldata = (light_data*) data;
+
+ trace("Get Light return value: %#lx\n", ldata->get_light_result);
+ trace("Get Light enable return value: %#lx\n", ldata->get_enabled_result);
+
+ trace("Light Enabled = %u\n", ldata->enabled);
+ trace("Light Type = %u\n", ldata->light.Type);
+ trace("Light Diffuse = { %f, %f, %f, %f }\n",
+ ldata->light.Diffuse.r, ldata->light.Diffuse.g,
+ ldata->light.Diffuse.b, ldata->light.Diffuse.a);
+ trace("Light Specular = { %f, %f, %f, %f}\n",
+ ldata->light.Specular.r, ldata->light.Specular.g,
+ ldata->light.Specular.b, ldata->light.Specular.a);
+ trace("Light Ambient = { %f, %f, %f, %f }\n",
+ ldata->light.Ambient.r, ldata->light.Ambient.g,
+ ldata->light.Ambient.b, ldata->light.Ambient.a);
+ trace("Light Position = { %f, %f, %f }\n",
+ ldata->light.Position.x, ldata->light.Position.y, ldata->light.Position.z);
+ trace("Light Direction = { %f, %f, %f }\n",
+ ldata->light.Direction.x, ldata->light.Direction.y, ldata->light.Direction.z);
+ trace("Light Range = %f\n", ldata->light.Range);
+ trace("Light Fallof = %f\n", ldata->light.Falloff);
+ trace("Light Attenuation0 = %f\n", ldata->light.Attenuation0);
+ trace("Light Attenuation1 = %f\n", ldata->light.Attenuation1);
+ trace("Light Attenuation2 = %f\n", ldata->light.Attenuation2);
+ trace("Light Theta = %f\n", ldata->light.Theta);
+ trace("Light Phi = %f\n", ldata->light.Phi);
+}
+
+static void light_set_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ light_data* ldata = (light_data*) data;
+ light_arg* larg = (light_arg*) arg;
+ unsigned int index = larg->idx;
+
+ hret = IDirect3DDevice9_SetLight(device, index, &ldata->light);
+ ok(hret == D3D_OK, "SetLight returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_LightEnable(device, index, ldata->enabled);
+ ok(hret == D3D_OK, "SetLightEnable returned %#lx.\n", hret);
+}
+
+static void light_get_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ light_data* ldata = (light_data*) data;
+ light_arg* larg = (light_arg*) arg;
+ unsigned int index = larg->idx;
+
+ hret = IDirect3DDevice9_GetLightEnable(device, index, &ldata->enabled);
+ ldata->get_enabled_result = hret;
+
+ hret = IDirect3DDevice9_GetLight(device, index, &ldata->light);
+ ldata->get_light_result = hret;
+}
+
+static const light_data light_poison_data =
+ { { 0x1337c0de,
+ { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 },
+ { 3.3, 4.4, 5.5 }, { 6.6, 7.7, 8.8 },
+ 12.12, 13.13, 14.14, 15.15, 16.16, 17.17, 18.18 }, 1, 0x1337c0de, 0x1337c0de };
+
+static const light_data light_default_data =
+ { { D3DLIGHT_DIRECTIONAL,
+ { 1.0, 1.0, 1.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 },
+ { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0 },
+ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }, 0, D3D_OK, D3D_OK };
+
+/* This is used for the initial read state (before a write causes side effects)
+ * The proper return status is D3DERR_INVALIDCALL */
+static const light_data light_initial_data =
+ { { 0x1337c0de,
+ { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 }, { 7.0, 4.0, 2.0, 1.0 },
+ { 3.3, 4.4, 5.5 }, { 6.6, 7.7, 8.8 },
+ 12.12, 13.13, 14.14, 15.15, 16.16, 17.17, 18.18 }, 1, D3DERR_INVALIDCALL, D3DERR_INVALIDCALL };
+
+static const light_data light_test_data_in =
+ { { 1,
+ { 2.0, 2.0, 2.0, 2.0 }, { 3.0, 3.0, 3.0, 3.0 }, { 4.0, 4.0, 4.0, 4.0 },
+ { 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
+ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 }, 1, D3D_OK, D3D_OK};
+
+/* SetLight will use 128 as the "enabled" value */
+static const light_data light_test_data_out =
+ { { 1,
+ { 2.0, 2.0, 2.0, 2.0 }, { 3.0, 3.0, 3.0, 3.0 }, { 4.0, 4.0, 4.0, 4.0 },
+ { 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
+ 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 }, 128, D3D_OK, D3D_OK};
+
+#define LIGHTS_REQ_BUFFER \
+ (sizeof(light_data) + sizeof(light_arg))
+
+static void lights_queue_test(
+ IDirect3DDevice9 *device,
+ state_test* test,
+ void* buffer)
{
+ light_arg* arg = buffer;
+ light_data* return_data = (light_data*) (arg + 1);
- D3DLIGHT9 garbage_light = { 1,
- { 2.0, 2.0, 2.0, 2.0 }, { 3.0, 3.0, 3.0, 3.0 }, { 4.0, 4.0, 4.0, 4.0 },
- { 5.0, 5.0, 5.0 }, { 6.0, 6.0, 6.0 },
- 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0 };
+ test->test_data_in = &light_test_data_in;
+ test->test_data_out = &light_test_data_out;
+ test->default_data = &light_default_data;
+ test->initial_data = &light_initial_data;
+ test->poison_data = &light_poison_data;
+ test->return_data = return_data;
+ test->data_size = sizeof(light_data);
+ test->set_handler = light_set_handler;
+ test->get_handler = light_get_handler;
+ test->print_handler = light_print_handler;
+ test->get_arg = test->set_arg = arg;
+ test->test_name = "set_get_light";
+ arg->idx = 0;
+}
- D3DLIGHT9 expected_light = { D3DLIGHT_DIRECTIONAL,
- { 1.0, 1.0, 1.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0, 0.0 },
- { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 1.0 },
- 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
- D3DLIGHT9 result_light;
- BOOL result_light_enable;
+/* =================== State test: Transforms ===================================== */
- HRESULT hret = 0;
- IDirect3DStateBlock9 *state_block_ptr = 0;
+typedef struct transform_data {
- /* Before we make any changes, GetLightEnable should fail, and GetLight should fail */
- hret = IDirect3DDevice9_GetLightEnable(device_ptr, 0, &result_light_enable);
- ok(hret == D3DERR_INVALIDCALL, "GetLightEnable returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n",
- hret, D3DERR_INVALIDCALL);
- if (hret != D3DERR_INVALIDCALL) goto cleanup;
+ D3DMATRIX view;
+ D3DMATRIX projection;
+ D3DMATRIX texture0;
+ D3DMATRIX texture7;
+ D3DMATRIX world0;
+ D3DMATRIX world255;
- hret = IDirect3DDevice9_GetLight(device_ptr, 0, &result_light);
- ok(hret == D3DERR_INVALIDCALL, "GetLight returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n",
- hret, D3DERR_INVALIDCALL);
- if (hret != D3DERR_INVALIDCALL) goto cleanup;
+} transform_data;
- /* Set states to record with garbage data (light, light_enable) */
- hret = IDirect3DDevice9_BeginStateBlock(device_ptr);
- ok(hret == D3D_OK, "BeginStateBlock returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
+static inline void print_matrix(
+ const char* name, D3DMATRIX* matrix) {
- hret = IDirect3DDevice9_SetLight(device_ptr, 0, &garbage_light);
- ok(hret == D3D_OK, "SetLight returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
+ trace("%s Matrix = {\n", name);
+ trace(" %f %f %f %f\n", matrix->m[0][0], matrix->m[1][0], matrix->m[2][0], matrix->m[3][0]);
+ trace(" %f %f %f %f\n", matrix->m[0][1], matrix->m[1][1], matrix->m[2][1], matrix->m[3][1]);
+ trace(" %f %f %f %f\n", matrix->m[0][2], matrix->m[1][2], matrix->m[2][2], matrix->m[3][2]);
+ trace(" %f %f %f %f\n", matrix->m[0][3], matrix->m[1][3], matrix->m[2][3], matrix->m[3][3]);
+ trace("}\n");
+}
- hret = IDirect3DDevice9_LightEnable(device_ptr, 0, TRUE);
- ok(hret == D3D_OK, "SetLightEnable returned: hret 0x%lx, Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
+static void transform_print_handler(
+ const void* data) {
- state_block_ptr = (IDirect3DStateBlock9 *)0xdeadbeef;
- hret = IDirect3DDevice9_EndStateBlock(device_ptr, &state_block_ptr);
- ok(hret == D3D_OK, "EndStateBlock returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
-
- /* Now capture light data */
- hret = IDirect3DStateBlock9_Capture(state_block_ptr);
- ok(hret == D3D_OK, "Capture returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
-
- /* Now apply the resultant stateblock */
- hret = IDirect3DStateBlock9_Apply(state_block_ptr);
- ok(hret == D3D_OK, "Apply returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
-
- /* Now try to fetch the light set by the stateblock.
- * Light enable should have been set to 0, and a default light should have been
- * created as a side effect of that */
- hret = IDirect3DDevice9_GetLightEnable(device_ptr, 0, &result_light_enable);
- ok(hret == D3D_OK, "GetLightEnable returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
- ok(result_light_enable == 0, "Light enabled status was %u, instead of 0\n", result_light_enable);
-
- hret = IDirect3DDevice9_GetLight(device_ptr, 0, &result_light);
- ok(hret == D3D_OK, "GetLight returned: hret 0x%lx. Expected hret 0x%lx. Aborting.\n", hret, D3D_OK);
- if (hret != D3D_OK) goto cleanup;
-
- ok (!memcmp(&expected_light, &result_light, sizeof(D3DLIGHT9)),
- "Light returned = { %u, { %f, %f, %f, %f }, { %f, %f, %f, %f}, { %f, %f, %f, %f }, "
- "{ %f, %f, %f }, { %f, %f, %f }, %f, %f, %f, %f, %f, %f, %f }\n",
-
- result_light.Type,
- result_light.Diffuse.r, result_light.Diffuse.g, result_light.Diffuse.b, result_light.Diffuse.a,
- result_light.Specular.r, result_light.Specular.g, result_light.Specular.b, result_light.Specular.a,
- result_light.Ambient.r, result_light.Ambient.g, result_light.Ambient.b, result_light.Ambient.a,
- result_light.Position.x, result_light.Position.y, result_light.Position.z,
- result_light.Direction.x, result_light.Direction.y, result_light.Direction.z,
- result_light.Range, result_light.Falloff,
- result_light.Attenuation0, result_light.Attenuation1, result_light.Attenuation2,
- result_light.Theta, result_light.Phi);
-
- cleanup:
- if (state_block_ptr) IUnknown_Release( state_block_ptr );
+ transform_data* tdata = (transform_data*) data;
+ print_matrix("View", &tdata->view);
+ print_matrix("Projection", &tdata->projection);
+ print_matrix("Texture0", &tdata->texture0);
+ print_matrix("Texture7", &tdata->texture7);
+ print_matrix("World0", &tdata->world0);
+ print_matrix("World255", &tdata->world255);
+}
+
+static void transform_set_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ transform_data* tdata = (transform_data*) data;
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &tdata->view);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &tdata->projection);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE0, &tdata->texture0);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_TEXTURE7, &tdata->texture7);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_WORLD, &tdata->world0);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_SetTransform(device, D3DTS_WORLDMATRIX(255), &tdata->world255);
+ ok(hret == D3D_OK, "SetTransform returned %#lx.\n", hret);
+}
+
+static void transform_get_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ transform_data* tdata = (transform_data*) data;
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_VIEW, &tdata->view);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_PROJECTION, &tdata->projection);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_TEXTURE0, &tdata->texture0);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_TEXTURE7, &tdata->texture7);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_WORLD, &tdata->world0);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+
+ hret = IDirect3DDevice9_GetTransform(device, D3DTS_WORLDMATRIX(255), &tdata->world255);
+ ok(hret == D3D_OK, "GetTransform returned %#lx.\n", hret);
+}
+
+static const transform_data transform_default_data = {
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } },
+ { { { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 } } }
+};
+
+static const transform_data transform_poison_data = {
+ { { { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
+ 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 } } },
+
+ { { { 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0,
+ 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0 } } },
+
+ { { { 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0,
+ 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0 } } },
+
+ { { { 49.0, 50.0, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0,
+ 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0, 64.0 } } },
+
+ { { { 64.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0,
+ 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0 } } },
+
+ { { { 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0,
+ 89.0, 90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0} } },
+};
+
+static const transform_data transform_test_data = {
+ { { { 1.2, 3.4, -5.6, 7.2, 10.11, -12.13, 14.15, -1.5,
+ 23.56, 12.89, 44.56, -1.0, 2.3, 0.0, 4.4, 5.5 } } },
+
+ { { { 9.2, 38.7, -6.6, 7.2, 10.11, -12.13, 77.15, -1.5,
+ 23.56, 12.89, 14.56, -1.0, 12.3, 0.0, 4.4, 5.5 } } },
+
+ { { { 10.2, 3.4, 0.6, 7.2, 10.11, -12.13, 14.15, -1.5,
+ 23.54, 12.9, 44.56, -1.0, 2.3, 0.0, 4.4, 5.5 } } },
+
+ { { { 1.2, 3.4, -5.6, 7.2, 10.11, -12.13, -14.5, -1.5,
+ 2.56, 12.89, 23.56, -1.0, 112.3, 0.0, 4.4, 2.5 } } },
+
+ { { { 1.2, 31.41, 58.6, 7.2, 10.11, -12.13, -14.5, -1.5,
+ 2.56, 12.89, 11.56, -1.0, 112.3, 0.0, 44.4, 2.5 } } },
+
+ { { { 1.20, 3.4, -5.6, 7.0, 10.11, -12.156, -14.5, -1.5,
+ 2.56, 1.829, 23.6, -1.0, 112.3, 0.0, 41.4, 2.5 } } },
+};
+
+#define TRANSFORMS_REQ_BUFFER (sizeof(transform_data))
+
+static void transform_queue_test(
+ IDirect3DDevice9 *device,
+ state_test* test,
+ void* buffer)
+{
+ transform_data* return_data = buffer;
+
+ test->test_data_in = &transform_test_data;
+ test->test_data_out = &transform_test_data;
+ test->default_data = &transform_default_data;
+ test->initial_data = &transform_default_data;
+ test->poison_data = &transform_poison_data;
+ test->return_data = return_data;
+ test->data_size = sizeof(transform_data);
+ test->set_handler = transform_set_handler;
+ test->get_handler = transform_get_handler;
+ test->print_handler = transform_print_handler;
+ test->get_arg = test->set_arg = NULL;
+ test->test_name = "set_get_transforms";
+}
+
+/* =================== State test: Render States ===================================== */
+
+#define D3D9_RENDER_STATES 102
+const D3DRENDERSTATETYPE render_state_indices[] = {
+
+ D3DRS_ZENABLE,
+ D3DRS_FILLMODE,
+ D3DRS_SHADEMODE,
+ D3DRS_ZWRITEENABLE,
+ D3DRS_ALPHATESTENABLE,
+ D3DRS_LASTPIXEL,
+ D3DRS_SRCBLEND,
+ D3DRS_DESTBLEND,
+ D3DRS_CULLMODE,
+ D3DRS_ZFUNC,
+ D3DRS_ALPHAREF,
+ D3DRS_ALPHAFUNC,
+ D3DRS_DITHERENABLE,
+ D3DRS_ALPHABLENDENABLE,
+ D3DRS_FOGENABLE,
+ D3DRS_SPECULARENABLE,
+ D3DRS_FOGCOLOR,
+ D3DRS_FOGTABLEMODE,
+ D3DRS_FOGSTART,
+ D3DRS_FOGEND,
+ D3DRS_FOGDENSITY,
+ D3DRS_RANGEFOGENABLE,
+ D3DRS_STENCILENABLE,
+ D3DRS_STENCILFAIL,
+ D3DRS_STENCILZFAIL,
+ D3DRS_STENCILPASS,
+ D3DRS_STENCILFUNC,
+ D3DRS_STENCILREF,
+ D3DRS_STENCILMASK,
+ D3DRS_STENCILWRITEMASK,
+ D3DRS_TEXTUREFACTOR,
+ D3DRS_WRAP0,
+ D3DRS_WRAP1,
+ D3DRS_WRAP2,
+ D3DRS_WRAP3,
+ D3DRS_WRAP4,
+ D3DRS_WRAP5,
+ D3DRS_WRAP6,
+ D3DRS_WRAP7,
+ D3DRS_CLIPPING,
+ D3DRS_LIGHTING,
+ D3DRS_AMBIENT,
+ D3DRS_FOGVERTEXMODE,
+ D3DRS_COLORVERTEX,
+ D3DRS_LOCALVIEWER,
+ D3DRS_NORMALIZENORMALS,
+ D3DRS_DIFFUSEMATERIALSOURCE,
+ D3DRS_SPECULARMATERIALSOURCE,
+ D3DRS_AMBIENTMATERIALSOURCE,
+ D3DRS_EMISSIVEMATERIALSOURCE,
+ D3DRS_VERTEXBLEND,
+ D3DRS_CLIPPLANEENABLE,
+#if 0 /* Driver dependent, increase array size to enable */
+ D3DRS_POINTSIZE,
+#endif
+ D3DRS_POINTSIZE_MIN,
+ D3DRS_POINTSPRITEENABLE,
+ D3DRS_POINTSCALEENABLE,
+ D3DRS_POINTSCALE_A,
+ D3DRS_POINTSCALE_B,
+ D3DRS_POINTSCALE_C,
+ D3DRS_MULTISAMPLEANTIALIAS,
+ D3DRS_MULTISAMPLEMASK,
+ D3DRS_PATCHEDGESTYLE,
+ D3DRS_DEBUGMONITORTOKEN,
+ D3DRS_POINTSIZE_MAX,
+ D3DRS_INDEXEDVERTEXBLENDENABLE,
+ D3DRS_COLORWRITEENABLE,
+ D3DRS_TWEENFACTOR,
+ D3DRS_BLENDOP,
+ D3DRS_POSITIONDEGREE,
+ D3DRS_NORMALDEGREE,
+ D3DRS_SCISSORTESTENABLE,
+ D3DRS_SLOPESCALEDEPTHBIAS,
+ D3DRS_ANTIALIASEDLINEENABLE,
+ D3DRS_MINTESSELLATIONLEVEL,
+ D3DRS_MAXTESSELLATIONLEVEL,
+ D3DRS_ADAPTIVETESS_X,
+ D3DRS_ADAPTIVETESS_Y,
+ D3DRS_ADAPTIVETESS_Z,
+ D3DRS_ADAPTIVETESS_W,
+ D3DRS_ENABLEADAPTIVETESSELLATION,
+ D3DRS_TWOSIDEDSTENCILMODE,
+ D3DRS_CCW_STENCILFAIL,
+ D3DRS_CCW_STENCILZFAIL,
+ D3DRS_CCW_STENCILPASS,
+ D3DRS_CCW_STENCILFUNC,
+ D3DRS_COLORWRITEENABLE1,
+ D3DRS_COLORWRITEENABLE2,
+ D3DRS_COLORWRITEENABLE3,
+ D3DRS_BLENDFACTOR,
+ D3DRS_SRGBWRITEENABLE,
+ D3DRS_DEPTHBIAS,
+ D3DRS_WRAP8,
+ D3DRS_WRAP9,
+ D3DRS_WRAP10,
+ D3DRS_WRAP11,
+ D3DRS_WRAP12,
+ D3DRS_WRAP13,
+ D3DRS_WRAP14,
+ D3DRS_WRAP15,
+ D3DRS_SEPARATEALPHABLENDENABLE,
+ D3DRS_SRCBLENDALPHA,
+ D3DRS_DESTBLENDALPHA,
+ D3DRS_BLENDOPALPHA,
+};
+
+typedef struct render_state_data {
+ DWORD states[D3D9_RENDER_STATES];
+} render_state_data;
+
+static void render_state_set_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ render_state_data* rsdata = (render_state_data*) data;
+ unsigned int i;
+
+ for (i = 0; i < D3D9_RENDER_STATES; i++) {
+ hret = IDirect3DDevice9_SetRenderState(device, render_state_indices[i], rsdata->states[i]);
+ ok(hret == D3D_OK, "SetRenderState returned %#lx.\n", hret);
+ }
+}
+
+static void render_state_get_handler(
+ IDirect3DDevice9* device, const void* data, void* arg) {
+
+ HRESULT hret;
+ render_state_data* rsdata = (render_state_data*) data;
+ unsigned int i = 0;
+
+ for (i = 0; i < D3D9_RENDER_STATES; i++) {
+ hret = IDirect3DDevice9_GetRenderState(device, render_state_indices[i], &rsdata->states[i]);
+ ok(hret == D3D_OK, "GetRenderState returned %#lx.\n", hret);
+ }
+}
+
+static void render_state_print_handler(
+ const void* data) {
+
+ render_state_data* rsdata = (render_state_data*) data;
+ unsigned int i;
+ for (i = 0; i < D3D9_RENDER_STATES; i++)
+ trace("Index = %u, Value = %#lx\n", i, rsdata->states[i]);
+}
+
+static inline DWORD to_dword(float fl) {
+ return *((DWORD*) &fl);
+}
+
+static void render_state_default_data_init(
+ D3DPRESENT_PARAMETERS* device_pparams,
+ render_state_data* data) {
+
+ unsigned int idx = 0;
+
+ data->states[idx++] = device_pparams->EnableAutoDepthStencil?
+ D3DZB_TRUE : D3DZB_FALSE; /* ZENABLE */
+ data->states[idx++] = D3DFILL_SOLID; /* FILLMODE */
+ data->states[idx++] = D3DSHADE_GOURAUD; /* SHADEMODE */
+ data->states[idx++] = TRUE; /* ZWRITEENABLE */
+ data->states[idx++] = FALSE; /* ALPHATESTENABLE */
+ data->states[idx++] = TRUE; /* LASTPIXEL */
+ data->states[idx++] = D3DBLEND_ONE; /* SRCBLEND */
+ data->states[idx++] = D3DBLEND_ZERO; /* DESTBLEND */
+ data->states[idx++] = D3DCULL_CCW; /* CULLMODE */
+ data->states[idx++] = D3DCMP_LESSEQUAL; /* ZFUNC */
+ data->states[idx++] = 0; /* ALPHAREF */
+ data->states[idx++] = D3DCMP_ALWAYS; /* ALPHAFUNC */
+ data->states[idx++] = FALSE; /* DITHERENABLE */
+ data->states[idx++] = FALSE; /* ALPHABLENDENABLE */
+ data->states[idx++] = FALSE; /* FOGENABLE */
+ data->states[idx++] = FALSE; /* SPECULARENABLE */
+ data->states[idx++] = 0; /* FOGCOLOR */
+ data->states[idx++] = D3DFOG_NONE; /* FOGTABLEMODE */
+ data->states[idx++] = to_dword(0.0f); /* FOGSTART */
+ data->states[idx++] = to_dword(1.0f); /* FOGEND */
+ data->states[idx++] = to_dword(1.0f); /* FOGDENSITY */
+ data->states[idx++] = FALSE; /* RANGEFOGENABLE */
+ data->states[idx++] = FALSE; /* STENCILENABLE */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* STENCILFAIL */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* STENCILZFAIL */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* STENCILPASS */
+ data->states[idx++] = D3DCMP_ALWAYS; /* STENCILFUNC */
+ data->states[idx++] = 0; /* STENCILREF */
+ data->states[idx++] = 0xFFFFFFFF; /* STENCILMASK */
+ data->states[idx++] = 0xFFFFFFFF; /* STENCILWRITEMASK */
+ data->states[idx++] = 0xFFFFFFFF; /* TEXTUREFACTOR */
+ data->states[idx++] = 0; /* WRAP 0 */
+ data->states[idx++] = 0; /* WRAP 1 */
+ data->states[idx++] = 0; /* WRAP 2 */
+ data->states[idx++] = 0; /* WRAP 3 */
+ data->states[idx++] = 0; /* WRAP 4 */
+ data->states[idx++] = 0; /* WRAP 5 */
+ data->states[idx++] = 0; /* WRAP 6 */
+ data->states[idx++] = 0; /* WRAP 7 */
+ data->states[idx++] = TRUE; /* CLIPPING */
+ data->states[idx++] = TRUE; /* LIGHTING */
+ data->states[idx++] = 0; /* AMBIENT */
+ data->states[idx++] = D3DFOG_NONE; /* FOGVERTEXMODE */
+ data->states[idx++] = TRUE; /* COLORVERTEX */
+ data->states[idx++] = TRUE; /* LOCALVIEWER */
+ data->states[idx++] = FALSE; /* NORMALIZENORMALS */
+ data->states[idx++] = D3DMCS_COLOR1; /* DIFFUSEMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_COLOR2; /* SPECULARMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_MATERIAL; /* AMBIENTMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_MATERIAL; /* EMISSIVEMATERIALSOURCE */
+ data->states[idx++] = D3DVBF_DISABLE; /* VERTEXBLEND */
+ data->states[idx++] = 0; /* CLIPPLANEENABLE */
+#if 0 /* Driver dependent, increase array size to enable */
+ data->states[idx++] = to_dword(1.0f); /* POINTSIZE */
+#endif
+ data->states[idx++] = to_dword(1.0f); /* POINTSIZEMIN */
+ data->states[idx++] = FALSE; /* POINTSPRITEENABLE */
+ data->states[idx++] = FALSE; /* POINTSCALEENABLE */
+ data->states[idx++] = to_dword(1.0f); /* POINTSCALE_A */
+ data->states[idx++] = to_dword(0.0f); /* POINTSCALE_B */
+ data->states[idx++] = to_dword(0.0f); /* POINTSCALE_C */
+ data->states[idx++] = TRUE; /* MULTISAMPLEANTIALIAS */
+ data->states[idx++] = 0xFFFFFFFF; /* MULTISAMPLEMASK */
+ data->states[idx++] = D3DPATCHEDGE_DISCRETE; /* PATCHEDGESTYLE */
+ data->states[idx++] = 0xbaadcafe; /* DEBUGMONITORTOKEN */
+ data->states[idx++] = to_dword(64.0f); /* POINTSIZE_MAX */
+ data->states[idx++] = FALSE; /* INDEXEDVERTEXBLENDENABLE */
+ data->states[idx++] = 0x0000000F; /* COLORWRITEENABLE */
+ data->states[idx++] = to_dword(0.0f); /* TWEENFACTOR */
+ data->states[idx++] = D3DBLENDOP_ADD; /* BLENDOP */
+ data->states[idx++] = D3DDEGREE_CUBIC; /* POSITIONDEGREE */
+ data->states[idx++] = D3DDEGREE_LINEAR; /* NORMALDEGREE */
+ data->states[idx++] = FALSE; /* SCISSORTESTENABLE */
+ data->states[idx++] = to_dword(0.0f); /* SLOPESCALEDEPTHBIAS */
+ data->states[idx++] = FALSE; /* ANTIALIASEDLINEENABLE */
+ data->states[idx++] = to_dword(1.0f); /* MINTESSELATIONLEVEL */
+ data->states[idx++] = to_dword(1.0f); /* MAXTESSELATIONLEVEL */
+ data->states[idx++] = to_dword(0.0f); /* ADAPTIVETESS_X */
+ data->states[idx++] = to_dword(0.0f); /* ADAPTIVETESS_Y */
+ data->states[idx++] = to_dword(1.0f); /* ADAPTIVETESS_Z */
+ data->states[idx++] = to_dword(0.0f); /* ADAPTIVETESS_W */
+ data->states[idx++] = FALSE; /* ENABLEADAPTIVETESSELATION */
+ data->states[idx++] = FALSE; /* TWOSIDEDSTENCILMODE */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* CCW_STENCILFAIL */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* CCW_STENCILZFAIL */
+ data->states[idx++] = D3DSTENCILOP_KEEP; /* CCW_STENCILPASS */
+ data->states[idx++] = D3DCMP_ALWAYS; /* CCW_STENCILFUNC */
+ data->states[idx++] = 0x0000000F; /* COLORWRITEENABLE1 */
+ data->states[idx++] = 0x0000000F; /* COLORWRITEENABLE2 */
+ data->states[idx++] = 0x0000000F; /* COLORWRITEENABLE3 */
+ data->states[idx++] = 0xFFFFFFFF; /* BLENDFACTOR */
+ data->states[idx++] = 0; /* SRGBWRITEENABLE */
+ data->states[idx++] = to_dword(0.0f); /* DEPTHBIAS */
+ data->states[idx++] = 0; /* WRAP8 */
+ data->states[idx++] = 0; /* WRAP9 */
+ data->states[idx++] = 0; /* WRAP10 */
+ data->states[idx++] = 0; /* WRAP11 */
+ data->states[idx++] = 0; /* WRAP12 */
+ data->states[idx++] = 0; /* WRAP13 */
+ data->states[idx++] = 0; /* WRAP14 */
+ data->states[idx++] = 0; /* WRAP15 */
+ data->states[idx++] = FALSE; /* SEPARATEALPHABLENDENABLE */
+ data->states[idx++] = D3DBLEND_ONE; /* SRCBLENDALPHA */
+ data->states[idx++] = D3DBLEND_ZERO; /* DESTBLENDALPHA */
+ data->states[idx++] = TRUE; /* BLENDOPALPHA */
+}
+
+static void render_state_poison_data_init(
+ render_state_data* data) {
+
+ unsigned int i;
+ for (i = 0; i < D3D9_RENDER_STATES; i++)
+ data->states[i] = 0x1337c0de;
+}
+
+static void render_state_test_data_init(
+ render_state_data* data) {
+
+ unsigned int idx = 0;
+ data->states[idx++] = D3DZB_USEW; /* ZENABLE */
+ data->states[idx++] = D3DFILL_WIREFRAME; /* FILLMODE */
+ data->states[idx++] = D3DSHADE_PHONG; /* SHADEMODE */
+ data->states[idx++] = FALSE; /* ZWRITEENABLE */
+ data->states[idx++] = TRUE; /* ALPHATESTENABLE */
+ data->states[idx++] = FALSE; /* LASTPIXEL */
+ data->states[idx++] = D3DBLEND_SRCALPHASAT; /* SRCBLEND */
+ data->states[idx++] = D3DBLEND_INVDESTALPHA; /* DESTBLEND */
+ data->states[idx++] = D3DCULL_CW; /* CULLMODE */
+ data->states[idx++] = D3DCMP_NOTEQUAL; /* ZFUNC */
+ data->states[idx++] = 10; /* ALPHAREF */
+ data->states[idx++] = D3DCMP_GREATER; /* ALPHAFUNC */
+ data->states[idx++] = TRUE; /* DITHERENABLE */
+ data->states[idx++] = TRUE; /* ALPHABLENDENABLE */
+ data->states[idx++] = TRUE; /* FOGENABLE */
+ data->states[idx++] = TRUE; /* SPECULARENABLE */
+ data->states[idx++] = 255 << 31; /* FOGCOLOR */
+ data->states[idx++] = D3DFOG_EXP; /* FOGTABLEMODE */
+ data->states[idx++] = to_dword(0.1f); /* FOGSTART */
+ data->states[idx++] = to_dword(0.8f); /* FOGEND */
+ data->states[idx++] = to_dword(0.5f); /* FOGDENSITY */
+ data->states[idx++] = TRUE; /* RANGEFOGENABLE */
+ data->states[idx++] = TRUE; /* STENCILENABLE */
+ data->states[idx++] = D3DSTENCILOP_INCRSAT; /* STENCILFAIL */
+ data->states[idx++] = D3DSTENCILOP_REPLACE; /* STENCILZFAIL */
+ data->states[idx++] = D3DSTENCILOP_INVERT; /* STENCILPASS */
+ data->states[idx++] = D3DCMP_LESS; /* STENCILFUNC */
+ data->states[idx++] = 10; /* STENCILREF */
+ data->states[idx++] = 0xFF00FF00; /* STENCILMASK */
+ data->states[idx++] = 0x00FF00FF; /* STENCILWRITEMASK */
+ data->states[idx++] = 0xF0F0F0F0; /* TEXTUREFACTOR */
+ data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_2; /* WRAP 0 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3; /* WRAP 1 */
+ data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 2 */
+ data->states[idx++] = D3DWRAPCOORD_3 | D3DWRAPCOORD_0; /* WRAP 4 */
+ data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2; /* WRAP 5 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3 | D3DWRAPCOORD_2; /* WRAP 6 */
+ data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_1 | D3DWRAPCOORD_0; /* WRAP 7 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_0 | D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 8 */
+ data->states[idx++] = FALSE; /* CLIPPING */
+ data->states[idx++] = FALSE; /* LIGHTING */
+ data->states[idx++] = 255 << 16; /* AMBIENT */
+ data->states[idx++] = D3DFOG_EXP2; /* FOGVERTEXMODE */
+ data->states[idx++] = FALSE; /* COLORVERTEX */
+ data->states[idx++] = FALSE; /* LOCALVIEWER */
+ data->states[idx++] = TRUE; /* NORMALIZENORMALS */
+ data->states[idx++] = D3DMCS_COLOR2; /* DIFFUSEMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_MATERIAL; /* SPECULARMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_COLOR1; /* AMBIENTMATERIALSOURCE */
+ data->states[idx++] = D3DMCS_COLOR2; /* EMISSIVEMATERIALSOURCE */
+ data->states[idx++] = D3DVBF_3WEIGHTS; /* VERTEXBLEND */
+ data->states[idx++] = 0xf1f1f1f1; /* CLIPPLANEENABLE */
+#if 0 /* Driver dependent, increase array size to enable */
+ data->states[idx++] = to_dword(32.0f); /* POINTSIZE */
+#endif
+ data->states[idx++] = to_dword(0.7f); /* POINTSIZEMIN */
+ data->states[idx++] = TRUE; /* POINTSPRITEENABLE */
+ data->states[idx++] = TRUE; /* POINTSCALEENABLE */
+ data->states[idx++] = to_dword(0.7f); /* POINTSCALE_A */
+ data->states[idx++] = to_dword(0.5f); /* POINTSCALE_B */
+ data->states[idx++] = to_dword(0.4f); /* POINTSCALE_C */
+ data->states[idx++] = FALSE; /* MULTISAMPLEANTIALIAS */
+ data->states[idx++] = 0xABCDDBCA; /* MULTISAMPLEMASK */
+ data->states[idx++] = D3DPATCHEDGE_CONTINUOUS; /* PATCHEDGESTYLE */
+ data->states[idx++] = D3DDMT_DISABLE; /* DEBUGMONITORTOKEN */
+ data->states[idx++] = to_dword(77.0f); /* POINTSIZE_MAX */
+ data->states[idx++] = TRUE; /* INDEXEDVERTEXBLENDENABLE */
+ data->states[idx++] = 0x00000009; /* COLORWRITEENABLE */
+ data->states[idx++] = to_dword(0.2f); /* TWEENFACTOR */
+ data->states[idx++] = D3DBLENDOP_REVSUBTRACT;/* BLENDOP */
+ data->states[idx++] = D3DDEGREE_LINEAR; /* POSITIONDEGREE */
+ data->states[idx++] = D3DDEGREE_CUBIC; /* NORMALDEGREE */
+ data->states[idx++] = TRUE; /* SCISSORTESTENABLE */
+ data->states[idx++] = to_dword(0.33f); /* SLOPESCALEDEPTHBIAS */
+ data->states[idx++] = TRUE; /* ANTIALIASEDLINEENABLE */
+ data->states[idx++] = to_dword(0.8f); /* MINTESSELATIONLEVEL */
+ data->states[idx++] = to_dword(0.8f); /* MAXTESSELATIONLEVEL */
+ data->states[idx++] = to_dword(0.2f); /* ADAPTIVETESS_X */
+ data->states[idx++] = to_dword(0.3f); /* ADAPTIVETESS_Y */
+ data->states[idx++] = to_dword(0.6f); /* ADAPTIVETESS_Z */
+ data->states[idx++] = to_dword(0.4f); /* ADAPTIVETESS_W */
+ data->states[idx++] = TRUE; /* ENABLEADAPTIVETESSELATION */
+ data->states[idx++] = TRUE; /* TWOSIDEDSTENCILMODE */
+ data->states[idx++] = D3DSTENCILOP_ZERO; /* CCW_STENCILFAIL */
+ data->states[idx++] = D3DSTENCILOP_DECR; /* CCW_STENCILZFAIL */
+ data->states[idx++] = D3DSTENCILOP_INCR; /* CCW_STENCILPASS */
+ data->states[idx++] = D3DCMP_ALWAYS; /* CCW_STENCILFUNC */
+ data->states[idx++] = 0x00000007; /* COLORWRITEENABLE1 */
+ data->states[idx++] = 0x00000008; /* COLORWRITEENABLE2 */
+ data->states[idx++] = 0x00000004; /* COLORWRITEENABLE3 */
+ data->states[idx++] = 0xF0F1F2F3; /* BLENDFACTOR */
+ data->states[idx++] = 1; /* SRGBWRITEENABLE */
+ data->states[idx++] = to_dword(0.3f); /* DEPTHBIAS */
+ data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_2; /* WRAP 8 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3; /* WRAP 9 */
+ data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 10 */
+ data->states[idx++] = D3DWRAPCOORD_3 | D3DWRAPCOORD_0; /* WRAP 11 */
+ data->states[idx++] = D3DWRAPCOORD_0 | D3DWRAPCOORD_1 | D3DWRAPCOORD_2; /* WRAP 12 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_3 | D3DWRAPCOORD_2; /* WRAP 13 */
+ data->states[idx++] = D3DWRAPCOORD_2 | D3DWRAPCOORD_1 | D3DWRAPCOORD_0; /* WRAP 14 */
+ data->states[idx++] = D3DWRAPCOORD_1 | D3DWRAPCOORD_0 | D3DWRAPCOORD_2 | D3DWRAPCOORD_3; /* WRAP 15 */
+ data->states[idx++] = TRUE; /* SEPARATEALPHABLENDENABLE */
+ data->states[idx++] = D3DBLEND_ZERO; /* SRCBLENDALPHA */
+ data->states[idx++] = D3DBLEND_ONE; /* DESTBLENDALPHA */
+ data->states[idx++] = FALSE; /* BLENDOPALPHA */
+}
+
+#define RENDER_STATES_REQ_BUFFER (sizeof(render_state_data) * 4)
+
+static void render_states_queue_test(
+ IDirect3DDevice9 *device,
+ D3DPRESENT_PARAMETERS *device_pparams,
+ state_test* test,
+ void* buffer)
+{
+ render_state_data* return_data = buffer;
+ render_state_data* default_data = return_data + 1;
+ render_state_data* test_data = default_data + 1;
+ render_state_data* poison_data = test_data + 1;
+
+ render_state_default_data_init(device_pparams, default_data);
+ render_state_test_data_init(test_data);
+ render_state_poison_data_init(poison_data);
+
+ test->test_data_in = test_data;
+ test->test_data_out = test_data;
+ test->default_data = default_data;
+ test->initial_data = default_data;
+ test->poison_data = poison_data;
+ test->return_data = return_data;
+ test->data_size = sizeof(render_state_data);
+ test->set_handler = render_state_set_handler;
+ test->get_handler = render_state_get_handler;
+ test->print_handler = render_state_print_handler;
+ test->get_arg = test->set_arg = NULL;
+ test->test_name = "set_get_render_states";
+}
+
+/* =================== Main state tests function =============================== */
+
+static void test_state_management(
+ IDirect3DDevice9 *device,
+ D3DPRESENT_PARAMETERS *device_pparams) {
+
+ HRESULT hret;
+ D3DCAPS9 caps;
+
+ /* Test count: 2 for shader constants
+ 1 for lights
+ 1 for transforms
+ 1 for render states
+ */
+ const int max_tests = 2 + 1 + 1 + 1;
+ const int max_buffer = SHADER_CONSTANTS_REQ_BUFFER * 2 +
+ LIGHTS_REQ_BUFFER +
+ TRANSFORMS_REQ_BUFFER +
+ RENDER_STATES_REQ_BUFFER;
+
+ unsigned int tcount = 0;
+ unsigned int bcount = 0;
+
+ state_test tests[max_tests];
+ BYTE buffer[max_buffer];
+
+ hret = IDirect3DDevice9_GetDeviceCaps(device, &caps);
+ ok(hret == D3D_OK, "GetDeviceCaps returned %#lx.\n", hret);
+ if (hret != D3D_OK) return;
+
+ if (caps.VertexShaderVersion & 0xffff) {
+ shader_constants_queue_test(device, &tests[tcount], &buffer[bcount], FALSE);
+ bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ tcount++;
+ }
+
+ if (caps.PixelShaderVersion & 0xffff) {
+ shader_constants_queue_test(device, &tests[tcount], &buffer[bcount], TRUE);
+ bcount += SHADER_CONSTANTS_REQ_BUFFER;
+ tcount++;
+ }
+
+ lights_queue_test(device, &tests[tcount], &buffer[bcount]);
+ bcount += LIGHTS_REQ_BUFFER;
+ tcount++;
+
+ transform_queue_test(device, &tests[tcount], &buffer[bcount]);
+ bcount += TRANSFORMS_REQ_BUFFER;
+ tcount++;
+
+ render_states_queue_test(device, device_pparams, &tests[tcount], &buffer[bcount]);
+ bcount += RENDER_STATES_REQ_BUFFER;
+ tcount++;
+
+ execute_test_chain_all(device, tests, tcount);
}
START_TEST(stateblock)
{
- IDirect3DDevice9 *device_ptr;
+ IDirect3DDevice9 *device_ptr = NULL;
+ D3DPRESENT_PARAMETERS device_pparams;
+ HRESULT hret;
d3d9_handle = LoadLibraryA("d3d9.dll");
if (!d3d9_handle)
@@ -189,9 +1357,11 @@ START_TEST(stateblock)
return;
}
- device_ptr = init_d3d9();
- if (!device_ptr) return;
+ hret = init_d3d9(&device_ptr, &device_pparams);
+ if (hret != D3D_OK) return;
test_begin_end_state_block(device_ptr);
- test_missing_light_recording(device_ptr);
+ test_state_management(device_ptr, &device_pparams);
+
+ if (device_ptr) IUnknown_Release(device_ptr);
}
--
1.3.3
More information about the wine-patches
mailing list