From: Joachim Priesner Subject: wined3d: Correctly display fog for right-handed projection matrix (try 7) Message-Id: <201410121708.14856.joachim.priesner@web.de> Date: Sun, 12 Oct 2014 17:08:09 +0200 When using a right-handed projection matrix, z coordinates of transformed vertices may be negative. This is not considered in the code generating the GLSL shader for fixed-function fog. The patch fixes that and adds a test. Tested on openSUSE 13.1 and Windows 8.1. Try 6 that fixes more issues pointed out by Stefan Doesinger (thanks again for the review). NOTE: The ddraw7 test fails for me on Windows 8.1, even without this patch. The newly added test runs fine on Windows 8.1. --- dlls/d3d8/tests/visual.c | 287 ++++++++++++++++++++++++++++++++++++ dlls/d3d9/tests/visual.c | 355 +++++++++++++++++++++++++++++++++++++++++++++ dlls/ddraw/tests/ddraw7.c | 149 +++++++++++++++++++ dlls/wined3d/glsl_shader.c | 2 +- 4 files changed, 792 insertions(+), 1 deletion(-) diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c index ba73bb6..9490b2a 100644 --- a/dlls/d3d8/tests/visual.c +++ b/dlls/d3d8/tests/visual.c @@ -696,6 +696,292 @@ done: DestroyWindow(window); } +/* This test tests fog in combination with a right-handed projection matrix. */ +static void fog_righthanded_test(void) +{ + enum + { + COLOR_ALPHA_0x00 = 0x00000000, + COLOR_CLEAR = 0xffff00ff, + COLOR_FOGGED = 0x0000ff00, + COLOR_UNFOGGED = 0x00ff0000 + }; + + /* Fill the null-shader entry with the FVF (SetVertexShader is "overloaded" on d3d8). */ + DWORD vertex_shader[3] = {D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, 0, 0}; + DWORD pixel_shader[2] = {0, 0}; + IDirect3D8 *d3d; + IDirect3DDevice8 *device; + BOOL has_vs_support, has_ps_support, has_table_fog_support; + unsigned int i, ps; + D3DCOLOR color; + ULONG refcount; + D3DCAPS8 caps; + HWND window; + HRESULT hr; + union + { + float f; + DWORD i; + } start, end; + + /* For all vertex shaders the view matrix goes in registers c0...c3, + * the projection matrix goes in registers c4...c7. */ + + /* Basic vertex shader without fog computation ("non foggy") */ + static const DWORD vertex_shader_code1[] = + { + 0xfffe0100, /* vs_1_0 */ + /* output.Pos = mul(input.Pos, View) */ + 0x00000009, 0x80010000, 0x90e40000, 0xa0e40000, /* dp4 r0.x, v0, c0 */ + 0x00000009, 0x80020000, 0x90e40000, 0xa0e40001, /* dp4 r0.y, v0, c1 */ + 0x00000009, 0x80040000, 0x90e40000, 0xa0e40002, /* dp4 r0.z, v0, c2 */ + 0x00000009, 0x80080000, 0x90e40000, 0xa0e40003, /* dp4 r0.w, v0, c3 */ + /* output.Pos = mul(output.Pos, Projection) */ + 0x00000009, 0xc0010000, 0x80e40000, 0xa0e40004, /* dp4 oPos.x, r0, c4 */ + 0x00000009, 0xc0020000, 0x80e40000, 0xa0e40005, /* dp4 oPos.y, r0, c5 */ + 0x00000009, 0xc0040000, 0x80e40000, 0xa0e40006, /* dp4 oPos.z, r0, c6 */ + 0x00000009, 0xc0080000, 0x80e40000, 0xa0e40007, /* dp4 oPos.w, r0, c7 */ + /* output.Color = input.Color */ + 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */ + 0x0000ffff, /* END */ + }; + + /* Basic vertex shader with fog computation ("foggy"). + * Using the vertex' x coordinate as fog coordinate so that all test cases that use vertex fog + * will have a gradient from fully fogged (green, left) to unfogged (red, right). */ + static const DWORD vertex_shader_code2[] = + { + 0xfffe0100, /* vs_1_0 */ + /* output.Pos = mul(input.Pos, View) */ + 0x00000009, 0x80010000, 0x90e40000, 0xa0e40000, /* dp4 r0.x, v0, c0 */ + 0x00000009, 0x80020000, 0x90e40000, 0xa0e40001, /* dp4 r0.y, v0, c1 */ + 0x00000009, 0x80040000, 0x90e40000, 0xa0e40002, /* dp4 r0.z, v0, c2 */ + 0x00000009, 0x80080000, 0x90e40000, 0xa0e40003, /* dp4 r0.w, v0, c3 */ + /* output.Pos = mul(output.Pos, Projection) */ + 0x00000009, 0xc0010000, 0x80e40000, 0xa0e40004, /* dp4 oPos.x, r0, c4 */ + 0x00000009, 0xc0020000, 0x80e40000, 0xa0e40005, /* dp4 oPos.y, r0, c5 */ + 0x00000009, 0xc0040000, 0x80e40000, 0xa0e40006, /* dp4 oPos.z, r0, c6 */ + 0x00000009, 0xc0080000, 0x80e40000, 0xa0e40007, /* dp4 oPos.w, r0, c7 */ + /* output.Color = input.Color */ + 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */ + /* output.Fog = input.Pos.x */ + 0x00000001, 0xc00f0001, 0x90000000, /* mov oFog, v0.x */ + 0x0000ffff, /* END */ + }; + + /* Basic pixel shader */ + static const DWORD pixel_shader_code[] = + { + 0xffff0101, /* ps_1_1 */ + 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */ + 0x0000ffff + }; + + static const struct + { + struct vec3 position; + DWORD diffuse; + DWORD specular; + } + quad[] = + { + {{-1.0f, -1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{-1.0f, 1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, -1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, 1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + }; + static const DWORD vertex_decl[] = + { + D3DVSD_STREAM(0), + D3DVSD_REG(0, D3DVSDT_FLOAT3), /* position, v0 */ + D3DVSD_REG(1, D3DVSDT_D3DCOLOR), /* diffuse color, v1 */ + D3DVSD_REG(2, D3DVSDT_D3DCOLOR), /* specular color, v2 */ + D3DVSD_END() + }; + static const struct test_data_t + { + int vshader; + D3DFOGMODE vfog; + D3DFOGMODE tfog; + DWORD color_left; + DWORD color_right; + } + test_data[] = + { + /* Using z-based fog, the quad should have a gradient UNFOGGED->FOGGED. + * When the fog coordinate returned by the vertex shader is used, + * a gradient FOGGED->UNFOGGED is used instead. */ + + /* No vertex shader */ + {0, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + + /* Vertex shader without vertex fog computation */ + {1, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {1, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {1, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + {1, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + + /* Vertex shader with vertex fog computation */ + {2, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {2, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {2, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + {2, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + }; + static const D3DMATRIX proj_mat = + {{{ + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }}}; + static const D3DMATRIX view_mat = + {{{ + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }}}; + + window = CreateWindowA("static", "d3d8_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, + 0, 0, 640, 480, NULL, NULL, NULL, NULL); + d3d = Direct3DCreate8(D3D_SDK_VERSION); + ok(!!d3d, "Failed to create a D3D object\n"); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests\n"); + goto done; + } + + hr = IDirect3DDevice8_GetDeviceCaps(device, &caps); + ok(SUCCEEDED(hr), "Failed to get device caps (%#x)\n", hr); + + has_table_fog_support = caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE; + if (!has_table_fog_support) + skip("No table fog support, skipping some fog tests\n"); + + has_ps_support = caps.PixelShaderVersion >= D3DPS_VERSION(1, 1); + if (has_ps_support) + { + hr = IDirect3DDevice8_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]); + ok(SUCCEEDED(hr), "CreatePixelShader failed (%#x)\n", hr); + } + else + { + skip("No ps_1_1 support, skipping some fog tests\n"); + } + + has_vs_support = caps.VertexShaderVersion >= D3DVS_VERSION(1, 0); + if (has_vs_support) + { + hr = IDirect3DDevice8_CreateVertexShader(device, vertex_decl, vertex_shader_code1, &vertex_shader[1], 0); + ok(SUCCEEDED(hr), "CreateVertexShader failed (%#x)\n", hr); + hr = IDirect3DDevice8_CreateVertexShader(device, vertex_decl, vertex_shader_code2, &vertex_shader[2], 0); + ok(SUCCEEDED(hr), "CreateVertexShader failed (%#x)\n", hr); + + /* Note: Shaders expect matrices in column-major form, so they have + * to be transposed if they are not symmetrical (which is the case at the moment). */ + hr = IDirect3DDevice8_SetVertexShaderConstant(device, 0, &view_mat, 4); + ok(SUCCEEDED(hr), "SetVertexShaderConstant (view matrix) failed (%#x)\n", hr); + hr = IDirect3DDevice8_SetVertexShaderConstant(device, 4, &proj_mat, 4); + ok(SUCCEEDED(hr), "SetVertexShaderConstant (projection matrix) failed (%#x)\n", hr); + } + else + { + skip("No vs_1_0 support, skipping some fog tests\n"); + } + + /* Setup initial states: No depth test, no lighting, fog on, fog color */ + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_ZENABLE, FALSE); + ok(SUCCEEDED(hr), "Turning off depth test failed (%#x)\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_LIGHTING, FALSE); + ok(SUCCEEDED(hr), "Turning off lighting failed (%#x)\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGENABLE, TRUE); + ok(SUCCEEDED(hr), "Turning on fog calculations failed (%#x)\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGCOLOR, COLOR_FOGGED); + ok(SUCCEEDED(hr), "Setting fog color failed (%#x)\n", hr); + + start.f = 0.1f; + end.f = 0.9f; + + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGSTART, start.i); + ok(SUCCEEDED(hr), "Setting fog start failed (%#x)\n", hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGEND, end.i); + ok(SUCCEEDED(hr), "Setting fog end failed (%#x)\n", hr); + + hr = IDirect3DDevice8_SetTransform(device, D3DTS_PROJECTION, &proj_mat); + ok(SUCCEEDED(hr), "Failed to set projection transform (%#x)\n", hr); + hr = IDirect3DDevice8_SetTransform(device, D3DTS_VIEW, &view_mat); + ok(SUCCEEDED(hr), "Failed to set view transform (%#x)\n", hr); + + for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++) + { + if (test_data[i].vshader != 0 && !vertex_shader[test_data[i].vshader]) + continue; + if (test_data[i].tfog != D3DFOG_NONE && !has_table_fog_support) + continue; + + hr = IDirect3DDevice8_SetVertexShader(device, vertex_shader[test_data[i].vshader]); + ok(SUCCEEDED(hr), "SetVertexShader failed (%#x)\n", hr); + + for (ps = 0; ps < sizeof(pixel_shader)/sizeof(pixel_shader[0]); ps++) + { + if (ps != 0 && !pixel_shader[ps]) + continue; + + if (has_ps_support) + { + hr = IDirect3DDevice8_SetPixelShader(device, pixel_shader[ps]); + ok(SUCCEEDED(hr), "SetPixelShader failed (%#x)\n", hr); + } + + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog); + ok(SUCCEEDED(hr), "Setting fog vertex mode to %d failed (%#x)\n", test_data[i].vfog, hr); + hr = IDirect3DDevice8_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog); + ok(SUCCEEDED(hr), "Setting fog table mode to %d failed (%#x)\n", test_data[i].tfog, hr); + + hr = IDirect3DDevice8_Clear(device, 0, NULL, D3DCLEAR_TARGET, COLOR_CLEAR, 1.0f, 0); + ok(SUCCEEDED(hr), "Clear failed (%#x)\n", hr); + hr = IDirect3DDevice8_BeginScene(device); + ok(SUCCEEDED(hr), "BeginScene failed (%#x)\n", hr); + hr = IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0])); + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%#x)\n", hr); + hr = IDirect3DDevice8_EndScene(device); + ok(SUCCEEDED(hr), "EndScene failed (%#x)\n", hr); + + /* Use 5% tolerance on the colors since there may be a gradient + * between left and right vertices. */ + color = getPixelColor(device, 10, 240); + ok(color_match(color, test_data[i].color_left, 13), + "fog vs%i ps%i fvm%i ftm%i: got left color %08x, expected %08x+-5%%\n", + test_data[i].vshader, ps, test_data[i].vfog, test_data[i].tfog, + color, test_data[i].color_left); + color = getPixelColor(device, 630, 240); + ok(color_match(color, test_data[i].color_right, 13), + "fog vs%i ps%i fvm%i ftm%i: got right color %08x, expected %08x+-5%%\n", + test_data[i].vshader, ps, test_data[i].vfog, test_data[i].tfog, + color, test_data[i].color_right); + + hr = IDirect3DDevice8_Present(device, NULL, NULL, NULL, NULL); + ok(SUCCEEDED(hr), "Present failed (%#x)\n", hr); + } + } + for (i = 0; i < sizeof(vertex_shader)/sizeof(vertex_shader[0]); i++) + if (vertex_shader[i]) + IDirect3DDevice8_DeleteVertexShader(device, vertex_shader[i]); + for (i = 0; i < sizeof(pixel_shader)/sizeof(pixel_shader[0]); i++) + if (pixel_shader[i]) + IDirect3DDevice8_DeletePixelShader(device, pixel_shader[i]); + refcount = IDirect3DDevice8_Release(device); + ok(!refcount, "Device has %u references left\n", refcount); +done: + IDirect3D8_Release(d3d); + DestroyWindow(window); +} + /* This tests fog in combination with shaders. * What's tested: linear fog (vertex and table) with pixel shader * linear table fog with non foggy vertex shader @@ -5092,6 +5378,7 @@ START_TEST(visual) offscreen_test(); alpha_test(); test_scalar_instructions(); + fog_righthanded_test(); fog_with_shader_test(); cnd_test(); p8_texture_test(); diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 117c8eb..c51aaa4 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -1825,6 +1825,360 @@ done: DestroyWindow(window); } +/* This test tests fog in combination with a right-handed projection matrix. */ +static void fog_righthanded_test(void) +{ + enum + { + COLOR_ALPHA_0x00 = 0x00000000, + COLOR_CLEAR = 0xffff00ff, + COLOR_FOGGED = 0x0000ff00, + COLOR_UNFOGGED = 0x00ff0000 + }; + + IDirect3DVertexShader9 *vertex_shader[4] = {NULL, NULL, NULL, NULL}; + IDirect3DPixelShader9 *pixel_shader[3] = {NULL, NULL, NULL}; + IDirect3DVertexDeclaration9 *vertex_declaration = NULL; + IDirect3DDevice9 *device; + BOOL has_vs_support, has_ps_support, has_table_fog_support; + unsigned int i, ps; + IDirect3D9 *d3d; + ULONG refcount; + D3DCAPS9 caps; + DWORD color; + HWND window; + HRESULT hr; + union + { + float f; + DWORD i; + } start, end; + + /* For all vertex shaders the view matrix goes in registers c0...c3, + * the projection matrix goes in registers c4...c7. */ + + /* Basic vertex shader without fog computation ("non foggy") */ + static const DWORD vertex_shader_code1[] = + { + 0xfffe0101, /* vs_1_1 */ + 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position0 v0 */ + 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */ + /* output.Pos = mul(input.Pos, View) */ + 0x00000009, 0x80010000, 0x90e40000, 0xa0e40000, /* dp4 r0.x, v0, c0 */ + 0x00000009, 0x80020000, 0x90e40000, 0xa0e40001, /* dp4 r0.y, v0, c1 */ + 0x00000009, 0x80040000, 0x90e40000, 0xa0e40002, /* dp4 r0.z, v0, c2 */ + 0x00000009, 0x80080000, 0x90e40000, 0xa0e40003, /* dp4 r0.w, v0, c3 */ + /* output.Pos = mul(output.Pos, Projection) */ + 0x00000009, 0xc0010000, 0x80e40000, 0xa0e40004, /* dp4 oPos.x, r0, c4 */ + 0x00000009, 0xc0020000, 0x80e40000, 0xa0e40005, /* dp4 oPos.y, r0, c5 */ + 0x00000009, 0xc0040000, 0x80e40000, 0xa0e40006, /* dp4 oPos.z, r0, c6 */ + 0x00000009, 0xc0080000, 0x80e40000, 0xa0e40007, /* dp4 oPos.w, r0, c7 */ + /* output.Color = input.Color */ + 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */ + 0x0000ffff, /* END */ + }; + + /* Basic vertex shader with fog computation ("foggy"). + * Using the vertex' x coordinate as fog coordinate so that all test cases that use vertex fog + * will have a gradient from fully fogged (green, left) to unfogged (red, right). */ + static const DWORD vertex_shader_code2[] = + { + 0xfffe0101, /* vs_1_1 */ + 0x0000001f, 0x80000000, 0x900f0000, /* dcl_position0 v0 */ + 0x0000001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */ + /* output.Pos = mul(input.Pos, View) */ + 0x00000009, 0x80010000, 0x90e40000, 0xa0e40000, /* dp4 r0.x, v0, c0 */ + 0x00000009, 0x80020000, 0x90e40000, 0xa0e40001, /* dp4 r0.y, v0, c1 */ + 0x00000009, 0x80040000, 0x90e40000, 0xa0e40002, /* dp4 r0.z, v0, c2 */ + 0x00000009, 0x80080000, 0x90e40000, 0xa0e40003, /* dp4 r0.w, v0, c3 */ + /* output.Pos = mul(output.Pos, Projection) */ + 0x00000009, 0xc0010000, 0x80e40000, 0xa0e40004, /* dp4 oPos.x, r0, c4 */ + 0x00000009, 0xc0020000, 0x80e40000, 0xa0e40005, /* dp4 oPos.y, r0, c5 */ + 0x00000009, 0xc0040000, 0x80e40000, 0xa0e40006, /* dp4 oPos.z, r0, c6 */ + 0x00000009, 0xc0080000, 0x80e40000, 0xa0e40007, /* dp4 oPos.w, r0, c7 */ + /* output.Color = input.Color */ + 0x00000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */ + /* output.Fog = input.Pos.x */ + 0x00000001, 0xc00f0001, 0x90000000, /* mov oFog, v0.x */ + 0x0000ffff, /* END */ + }; + + /* Basic vertex shader with fog computation ("foggy"), vs_2_0 */ + static const DWORD vertex_shader_code3[] = + { + 0xfffe0200, /* vs_2_0 */ + 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position0 v0 */ + 0x0200001f, 0x8000000a, 0x900f0001, /* dcl_color0 v1 */ + /* output.Pos = mul(input.Pos, View) */ + 0x03000009, 0x80010000, 0x90e40000, 0xa0e40000, /* dp4 r0.x, v0, c0 */ + 0x03000009, 0x80020000, 0x90e40000, 0xa0e40001, /* dp4 r0.y, v0, c1 */ + 0x03000009, 0x80040000, 0x90e40000, 0xa0e40002, /* dp4 r0.z, v0, c2 */ + 0x03000009, 0x80080000, 0x90e40000, 0xa0e40003, /* dp4 r0.w, v0, c3 */ + /* output.Pos = mul(output.Pos, Projection) */ + 0x03000009, 0xc0010000, 0x80e40000, 0xa0e40004, /* dp4 oPos.x, r0, c4 */ + 0x03000009, 0xc0020000, 0x80e40000, 0xa0e40005, /* dp4 oPos.y, r0, c5 */ + 0x03000009, 0xc0040000, 0x80e40000, 0xa0e40006, /* dp4 oPos.z, r0, c6 */ + 0x03000009, 0xc0080000, 0x80e40000, 0xa0e40007, /* dp4 oPos.w, r0, c7 */ + /* output.Color = input.Color */ + 0x02000001, 0xd00f0000, 0x90e40001, /* mov oD0, v1 */ + /* output.Fog = input.Pos.x */ + 0x02000001, 0xc00f0001, 0x90000000, /* mov oFog, v0.x */ + 0x0000ffff, /* END */ + }; + + /* Basic pixel shader */ + static const DWORD pixel_shader_code[] = + { + 0xffff0101, /* ps_1_1 */ + 0x00000001, 0x800f0000, 0x90e40000, /* mov r0, v0 */ + 0x0000ffff + }; + static const DWORD pixel_shader_code2[] = + { + 0xffff0200, /* ps_2_0 */ + 0x0200001f, 0x80000000, 0x900f0000, /* dcl v0 */ + 0x02000001, 0x800f0800, 0x90e40000, /* mov oC0, v0 */ + 0x0000ffff + }; + static const struct + { + struct vec3 position; + D3DCOLOR diffuse; + D3DCOLOR specular; + } + quad[] = + { + {{-1.0f, -1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{-1.0f, 1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, -1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, 1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + }; + static const D3DVERTEXELEMENT9 decl_elements[] = + { + {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, + {0, 12, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0}, /* diffuse */ + {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 1}, /* specular */ + D3DDECL_END() + }; + static const struct test_data_t + { + int vshader; + D3DFOGMODE vfog; + D3DFOGMODE tfog; + DWORD color_left; + DWORD color_right; + } + test_data[] = + { + /* Using z-based fog, the quad should have a gradient UNFOGGED->FOGGED. + * When the fog coordinate returned by the vertex shader is used, + * a gradient FOGGED->UNFOGGED is used instead. */ + + /* No vertex shader */ + {0, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_UNFOGGED, COLOR_FOGGED}, + {0, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + + /* Vertex shader without vertex fog computation */ + {1, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {1, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {1, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + {1, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + + /* Vertex shader vs_1_1 with vertex fog computation */ + {2, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {2, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {2, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + {2, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + + /* Vertex shader vs_2_0 with vertex fog computation */ + {3, D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {3, D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {3, D3DFOG_LINEAR, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + {3, D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_UNFOGGED}, + }; + static const D3DMATRIX proj_mat = + {{{ + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }}}; + static const D3DMATRIX view_mat = + {{{ + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }}}; + + window = CreateWindowA("static", "d3d9_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, + 0, 0, 640, 480, NULL, NULL, NULL, NULL); + d3d = Direct3DCreate9(D3D_SDK_VERSION); + ok(!!d3d, "Failed to create a D3D object\n"); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests\n"); + goto done; + } + + hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); + ok(SUCCEEDED(hr), "Failed to get device caps (%#x)\n", hr); + + has_table_fog_support = caps.RasterCaps & D3DPRASTERCAPS_FOGTABLE; + if (!has_table_fog_support) + skip("No table fog support, skipping some fog tests\n"); + + has_vs_support = caps.VertexShaderVersion >= D3DVS_VERSION(1, 1); + if (has_vs_support) + { + hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code1, &vertex_shader[1]); + ok(SUCCEEDED(hr), "CreateVertexShader failed (%#x)\n", hr); + hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code2, &vertex_shader[2]); + ok(SUCCEEDED(hr), "CreateVertexShader failed (%#x)\n", hr); + + if (caps.VertexShaderVersion >= D3DVS_VERSION(2, 0)) + { + hr = IDirect3DDevice9_CreateVertexShader(device, vertex_shader_code3, &vertex_shader[3]); + ok(SUCCEEDED(hr), "CreateVertexShader failed (%#x)\n", hr); + } + else + { + skip("No vs_2_0 support, skipping some fog tests\n"); + } + + /* Note: Shaders expect matrices in column-major form, so they have + * to be transposed if they are not symmetrical (which is the case at the moment). */ + hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 0, (const float*)&view_mat, 4); + ok(SUCCEEDED(hr), "SetVertexShaderConstantF (view matrix) failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetVertexShaderConstantF(device, 4, (const float*)&proj_mat, 4); + ok(SUCCEEDED(hr), "SetVertexShaderConstantF (projection matrix) failed (%#x)\n", hr); + } + else + { + skip("No vs_1_1 support, skipping some fog tests\n"); + } + + has_ps_support = caps.PixelShaderVersion >= D3DPS_VERSION(1, 1); + if (has_ps_support) + { + hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code, &pixel_shader[1]); + ok(SUCCEEDED(hr), "CreatePixelShader failed (%#x)\n", hr); + + if (caps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) + { + hr = IDirect3DDevice9_CreatePixelShader(device, pixel_shader_code2, &pixel_shader[2]); + ok(SUCCEEDED(hr), "CreatePixelShader failed (%#x)\n", hr); + } + else + { + skip("No ps_2_0 support, skipping some fog tests\n"); + } + } + else + { + skip("No ps_1_1 support, skipping some fog tests\n"); + } + + hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration); + ok(SUCCEEDED(hr), "CreateVertexDeclaration failed (%#x)\n", hr); + + /* Setup initial states: No depth test, no lighting, fog on, fog color */ + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE); + ok(SUCCEEDED(hr), "Turning off depth test failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING, FALSE); + ok(SUCCEEDED(hr), "Turning off lighting failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGENABLE, TRUE); + ok(SUCCEEDED(hr), "Turning on fog calculations failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGCOLOR, COLOR_FOGGED); + ok(SUCCEEDED(hr), "Setting fog color failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration); + ok(SUCCEEDED(hr), "SetVertexDeclaration failed (%#x)\n", hr); + + start.f = 0.1f; + end.f = 0.9f; + + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGSTART, start.i); + ok(SUCCEEDED(hr), "Setting fog start failed (%#x)\n", hr); + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGEND, end.i); + ok(SUCCEEDED(hr), "Setting fog end failed (%#x)\n", hr); + + hr = IDirect3DDevice9_SetTransform(device, D3DTS_PROJECTION, &proj_mat); + ok(SUCCEEDED(hr), "Failed to set projection transform (%#x)\n", hr); + hr = IDirect3DDevice9_SetTransform(device, D3DTS_VIEW, &view_mat); + ok(SUCCEEDED(hr), "Failed to set view transform (%#x)\n", hr); + + for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++) + { + if (test_data[i].vshader != 0 && !vertex_shader[test_data[i].vshader]) + continue; + if (test_data[i].tfog != D3DFOG_NONE && !has_table_fog_support) + continue; + + if (has_vs_support) + { + hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader[test_data[i].vshader]); + ok(SUCCEEDED(hr), "SetVertexShader failed (%#x)\n", hr); + } + + for (ps = 0; ps < sizeof(pixel_shader)/sizeof(pixel_shader[0]); ps++) + { + if (ps != 0 && !pixel_shader[ps]) + continue; + + if (has_ps_support) + { + hr = IDirect3DDevice9_SetPixelShader(device, pixel_shader[ps]); + ok(SUCCEEDED(hr), "SetPixelShader failed (%#x)\n", hr); + } + + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGVERTEXMODE, test_data[i].vfog); + ok( SUCCEEDED(hr), "Setting fog vertex mode to %d failed (%#x)\n", test_data[i].vfog, hr); + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_FOGTABLEMODE, test_data[i].tfog); + ok( SUCCEEDED(hr), "Setting fog table mode to %d failed (%#x)\n", test_data[i].tfog, hr); + + hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, COLOR_CLEAR, 1.0f, 0); + ok(SUCCEEDED(hr), "Clear failed (%#x)\n", hr); + hr = IDirect3DDevice9_BeginScene(device); + ok(SUCCEEDED(hr), "BeginScene failed (%#x)\n", hr); + hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, &quad[0], sizeof(quad[0])); + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed (%#x)\n", hr); + hr = IDirect3DDevice9_EndScene(device); + ok(SUCCEEDED(hr), "EndScene failed (%#x)\n", hr); + + /* Use 5% tolerance on the colors since there may be a gradient + * between left and right vertices. */ + color = getPixelColor(device, 10, 240); + ok(color_match(color, test_data[i].color_left, 13), + "fog vs%i ps%i fvm%i ftm%i: got left color %08x, expected %08x+-5%%\n", + test_data[i].vshader, ps, test_data[i].vfog, test_data[i].tfog, + color, test_data[i].color_left); + color = getPixelColor(device, 630, 240); + ok(color_match(color, test_data[i].color_right, 13), + "fog vs%i ps%i fvm%i ftm%i: got right color %08x, expected %08x+-5%%\n", + test_data[i].vshader, ps, test_data[i].vfog, test_data[i].tfog, + color, test_data[i].color_right); + + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL); + ok(SUCCEEDED(hr), "Present failed (%#x)\n", hr); + } + } + + for (i = 0; i < sizeof(vertex_shader)/sizeof(vertex_shader[0]); i++) + if (vertex_shader[i]) + IDirect3DVertexShader9_Release(vertex_shader[i]); + for (i = 0; i < sizeof(pixel_shader)/sizeof(pixel_shader[0]); i++) + if (pixel_shader[i]) + IDirect3DPixelShader9_Release(pixel_shader[i]); + IDirect3DVertexDeclaration9_Release(vertex_declaration); + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left\n", refcount); +done: + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + /* This test tests fog in combination with shaders. * What's tested: linear fog (vertex and table) with pixel shader * linear table fog with non foggy vertex shader @@ -16729,6 +17083,7 @@ START_TEST(visual) test_vshader_input(); test_vshader_float16(); stream_test(); + fog_righthanded_test(); fog_with_shader_test(); texbem_test(); texdepth_test(); diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c index ec50fb8..d284c67 100644 --- a/dlls/ddraw/tests/ddraw7.c +++ b/dlls/ddraw/tests/ddraw7.c @@ -3384,6 +3384,154 @@ static void test_fog_special(void) DestroyWindow(window); } +/* This test tests fog in combination with a right-handed projection matrix. */ +static void test_fog_righthanded(void) +{ + enum + { + COLOR_ALPHA_0x00 = 0x00000000, + COLOR_CLEAR = 0xffff00ff, + COLOR_FOGGED = 0x0000ff00, + COLOR_UNFOGGED = 0x00ff0000 + }; + + D3DCOLOR color; + HRESULT hr; + ULONG refcount; + BOOL has_table_fog_support; + unsigned int i; + HWND window; + IDirect3DDevice7 *device; + IDirectDrawSurface7 *rt; + D3DDEVICEDESC7 caps; + + union + { + float f; + DWORD d; + } start, end; + + static struct + { + struct vec3 position; + D3DCOLOR diffuse; + D3DCOLOR specular; + } + quad[] = + { + {{-1.0f, 1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, 1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{-1.0f, -1.0f, 0.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + {{ 1.0f, -1.0f, 1.0f}, COLOR_UNFOGGED, COLOR_ALPHA_0x00}, + }; + static const struct test_data_t + { + DWORD vertexmode, tablemode; + D3DCOLOR color_left, color_right; + } + test_data[] = + { + {D3DFOG_NONE, D3DFOG_NONE, COLOR_FOGGED, COLOR_FOGGED}, + {D3DFOG_LINEAR, D3DFOG_NONE, COLOR_UNFOGGED, COLOR_FOGGED}, + {D3DFOG_NONE, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + {D3DFOG_LINEAR, D3DFOG_LINEAR, COLOR_UNFOGGED, COLOR_FOGGED}, + }; + static D3DMATRIX proj_mat = + { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + static D3DMATRIX view_mat = + { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; + + window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + + if (!(device = create_device(window, DDSCL_NORMAL))) + { + skip("Failed to create a 3D device, skipping test.\n"); + DestroyWindow(window); + return; + } + + memset(&caps, 0, sizeof(caps)); + hr = IDirect3DDevice7_GetCaps(device, &caps); + ok(SUCCEEDED(hr), "IDirect3DDevice7_GetCaps failed, hr %#x.\n", hr); + + has_table_fog_support = caps.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_FOGTABLE; + if (!has_table_fog_support) + skip("No table fog support, skipping some fog tests.\n"); + + hr = IDirect3DDevice7_GetRenderTarget(device, &rt); + ok(SUCCEEDED(hr), "Failed to get render target, hr %#x.\n", hr); + + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGENABLE, TRUE); + ok(SUCCEEDED(hr), "Failed to enable fog, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGCOLOR, COLOR_FOGGED); + ok(SUCCEEDED(hr), "Failed to set fog color, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_LIGHTING, FALSE); + ok(SUCCEEDED(hr), "Failed to disable lighting, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_ZENABLE, D3DZB_FALSE); + ok(SUCCEEDED(hr), "Failed to disable depth test, hr %#x.\n", hr); + + start.f = 0.1f; + end.f = 0.9f; + + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGSTART, start.d); + ok(SUCCEEDED(hr), "Failed to set fog start, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGEND, end.d); + ok(SUCCEEDED(hr), "Failed to set fog end, hr %#x.\n", hr); + + hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_PROJECTION, &proj_mat); + ok(SUCCEEDED(hr), "Failed to set projection transform, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetTransform(device, D3DTRANSFORMSTATE_VIEW, &view_mat); + ok(SUCCEEDED(hr), "Failed to set view transform, hr %#x.\n", hr); + + for (i = 0; i < sizeof(test_data)/sizeof(test_data[0]); i++) + { + if (test_data[i].tablemode != D3DFOG_NONE && !has_table_fog_support) + continue; + + hr = IDirect3DDevice7_Clear(device, 0, NULL, D3DCLEAR_TARGET, COLOR_CLEAR, 1.0f, 0); + ok(SUCCEEDED(hr), "Failed to clear render target, hr %#x.\n", hr); + + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGVERTEXMODE, test_data[i].vertexmode); + ok(SUCCEEDED(hr), "Failed to set fog vertex mode, hr %#x.\n", hr); + hr = IDirect3DDevice7_SetRenderState(device, D3DRENDERSTATE_FOGTABLEMODE, test_data[i].tablemode); + ok(SUCCEEDED(hr), "Failed to set fog table mode, hr %#x.\n", hr); + + hr = IDirect3DDevice7_BeginScene(device); + ok(SUCCEEDED(hr), "Failed to begin scene, hr %#x.\n", hr); + hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, + D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, quad, 4, 0); + ok(SUCCEEDED(hr), "Failed to draw, hr %#x.\n", hr); + hr = IDirect3DDevice7_EndScene(device); + ok(SUCCEEDED(hr), "Failed to end scene, hr %#x.\n", hr); + + /* Use 5% tolerance on the colors since there may be a gradient + * between left and right vertices. */ + color = get_surface_color(rt, 10, 240); + ok(compare_color(color, test_data[i].color_left, 13), + "fog fvm%i ftm%i: got left color %08x, expected %08x+-5%%.\n", + test_data[i].vertexmode, test_data[i].tablemode, color, test_data[i].color_left); + color = get_surface_color(rt, 630, 240); + ok(compare_color(color, test_data[i].color_right, 13), + "fog fvm%i ftm%i: got right color %08x, expected %08x+-5%%.\n", + test_data[i].vertexmode, test_data[i].tablemode, color, test_data[i].color_right); + } + + IDirectDrawSurface7_Release(rt); + refcount = IDirect3DDevice7_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + DestroyWindow(window); +} static void test_lighting_interface_versions(void) { IDirect3DDevice7 *device; @@ -7671,6 +7819,7 @@ START_TEST(ddraw7) test_clear_rect_count(); test_coop_level_versions(); test_fog_special(); + test_fog_righthanded(); test_lighting_interface_versions(); test_coop_level_activateapp(); test_texturemanage(); diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 34cc567..f158ee2 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -5005,7 +5005,7 @@ static GLhandleARB shader_glsl_generate_ffp_vertex_shader(struct wined3d_shader_ /* Need to undo the [0.0 - 1.0] -> [-1.0 - 1.0] transformation from D3D to GL coordinates. */ shader_addline(buffer, "gl_FogFragCoord = gl_Position.z * 0.5 + 0.5;\n"); else - shader_addline(buffer, "gl_FogFragCoord = ec_pos.z;\n"); + shader_addline(buffer, "gl_FogFragCoord = abs(ec_pos.z);\n"); break; default: -- 1.8.4.5