Re: wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Stefan Dösinger]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Hi,

I have tested your patches on my various systems. I have replaced
C_IGNORE in the d3d8 test with C_FOGGED. The test passes on Nvidia
cards, but fails (also in d3d9) on my AMD cards. As far as I can see
AMD cards clamp the fog coord.

I have attached results from a Radeon 9000 (WinXP), Radeon X1600
(Win7) and Radeon HD 5770 (Win7). The Radeon 9000 driver crashes in
the tests. Windows somehow restores it, but the screen resolution is
broken until the next reboot (Can't set back the native resolution of
1400x1050.)

I haven't quite understood yet what you're doing with quad2/quad3, so
I can't comment on the code yet.

Cheers,
Stefan

Am 2014-10-22 09:43, schrieb Joachim Priesner:
> Supersedes 107021. (The title of that patch really was not fitting
> any more.)
>
> The FFP fog coordinate is not vertex.z, but the absolute value of
> it. The patch fixes that and adds a test.
>
> The tests also suggest that the vertex shader side clamp of oFog
> is incorrect. The test results are clear on that for d3d9, but vary
> across different Windows machines for d3d8. Therefore, the d3d8
> oFog clamp tests are disabled for now.
>
> Tested on openSuse 13.1 and Windows 8.1 (VMware, Wine test bot,
> real machine with nVidia graphics card). --- 
> dlls/d3d8/tests/visual.c   | 335
> +++++++++++++++++++++++++++++++++++++ dlls/d3d9/tests/visual.c   |
> 399 +++++++++++++++++++++++++++++++++++++++++++++ 
> dlls/ddraw/tests/ddraw7.c  | 186 +++++++++++++++++++++ 
> dlls/wined3d/glsl_shader.c |   4 +- 4 files changed, 922
> insertions(+), 2 deletions(-)
>
> diff --git a/dlls/d3d8/tests/visual.c b/dlls/d3d8/tests/visual.c 
> index ba73bb6..42d3e97 100644 --- a/dlls/d3d8/tests/visual.c +++
> b/dlls/d3d8/tests/visual.c @@ -696,6 +696,340 @@ done: 
> DestroyWindow(window); }
>
> +/* This test tests fog in combination with negative vertex z
> coordinates. */ +static void fog_negative_z_test(void) +{ +
> enum +    { +        C_ALPHA_0x00  = 0x00000000, +        C_CLEAR
> = 0xffff00ff, +        C_FOGGED      = 0x0000ff00, +
> C_HALF_FOGGED = 0x00808000, +        C_UNFOGGED    = 0x00ff0000, +
> C_IGNORE      = 0xdeadbeef +    }; + +    /* 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, y; +    D3DCOLOR color, expected_middle_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; +    } +    quad1[] = +    { +
> {{-1.0f, -1.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{-1.0f,  0.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 1.0f, -1.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 1.0f,
> 0.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +    }, +    quad2[] = +
> { +        {{-1.0f,  0.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{-1.0f,  1.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 0.0f,  0.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 0.0f,
> 1.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +    }, +    quad3[] = +
> { +        {{ 0.0f,  0.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{ 0.0f,  1.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 1.0f,  0.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 1.0f,
> 1.0f,  1.0f}, C_UNFOGGED, C_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_middle_top; +        DWORD
> color_middle_bottom; +        DWORD color_right; +    } +
> test_data[] = +    { +        /* Using z-based fog, the bottom quad
> should have a gradient UNFOGGED->FOGGED +         * for table fog,
> and be completely fogged for vertex fog. +         * When the fog
> coordinate returned by the vertex shader is used instead, +
> * the result is a gradient FOGGED->UNFOGGED. */ + +        /* No
> vertex shader */ +        {0, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {0,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {0, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_UNFOGGED,    C_FOGGED,      C_FOGGED}, +        {0,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_FOGGED}, + +        /* Vertex shader without vertex fog
> computation */ +        {1, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {1,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {1, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_FOGGED,      C_FOGGED,      C_FOGGED}, +        {1,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_FOGGED}, + +        /* Vertex shader with vertex fog
> computation. +         * Ignore the bottom middle color as test
> results vary on different Windows machines. */ +        {2,
> D3DFOG_NONE,   D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {2, D3DFOG_LINEAR,
> D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED,
> C_FOGGED}, +        {2, D3DFOG_LINEAR, D3DFOG_NONE,   C_FOGGED,
> C_FOGGED,      C_IGNORE,      C_UNFOGGED}, +        {2,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_IGNORE,
> C_UNFOGGED}, +    }; +    /* Affine projection matrix for z-near =
> -1, z-far = 1. */ +    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, 0.5f, 0.0f, +        0.0f, 0.0f, 0.5f, 1.0f +    }}}; +
> /* Transposed version of proj_mat to pass to the vertex shaders.
> */ +    static const D3DMATRIX proj_mat_transposed = +    {{{ +
> 1.0f, 0.0f, 0.0f, 0.0f, +        0.0f, 1.0f, 0.0f, 0.0f, +
> 0.0f, 0.0f, 0.5f, 0.5f, +        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. */ +
> 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_transposed, 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,
> D3DZB_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, C_FOGGED); +    ok(SUCCEEDED(hr), "Setting fog
> color failed (%#x)\n", hr); + +    /* We are using an affine
> projection matrix, so fog start and end are in device space
> coords. +     * This corresponds to a fog from z=-1 to z=1. */ +
> start.f = 0.0f; +    end.f = 1.0f; + +    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,
> C_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,
> &quad1[0], sizeof(quad1[0])); +            ok(SUCCEEDED(hr),
> "DrawPrimitiveUP failed (%#x)\n", hr); +            hr =
> IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,
> &quad2[0], sizeof(quad2[0])); +            ok(SUCCEEDED(hr),
> "DrawPrimitiveUP failed (%#x)\n", hr); +            hr =
> IDirect3DDevice8_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,
> &quad3[0], sizeof(quad3[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. */ +            for (y = 120; y <= 360; y
> += 240) +            { +                color =
> getPixelColor(device, 2, y); +                ok(color_match(color,
> test_data[i].color_left, 13), +                        "fog vs%i
> ps%i fvm%i ftm%i, y=%i: got left color %08x, expected
> %08x+-5%%\n", +                        test_data[i].vshader, ps,
> test_data[i].vfog, test_data[i].tfog, y, +
> color, test_data[i].color_left); +
> expected_middle_color = +                        (y == 120 ?
> test_data[i].color_middle_top : test_data[i].color_middle_bottom); 
> +                if (expected_middle_color != C_IGNORE) +
> { +                    color = getPixelColor(device, 320, y); +
> ok(color_match(color, expected_middle_color, 13), +
> "fog vs%i ps%i fvm%i ftm%i, y=%i: got middle color %08x, expected
> %08x+-5%%\n", +                            test_data[i].vshader,
> ps, test_data[i].vfog, test_data[i].tfog, y, +
> color, expected_middle_color); +                } +
> color = getPixelColor(device, 638, y); +
> ok(color_match(color, test_data[i].color_right, 13), +
> "fog vs%i ps%i fvm%i ftm%i, y=%i: got right color %08x, expected
> %08x+-5%%\n", +                        test_data[i].vshader, ps,
> test_data[i].vfog, test_data[i].tfog, y, +
> 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 +5426,7 @@
> START_TEST(visual) offscreen_test(); alpha_test(); 
> test_scalar_instructions(); +    fog_negative_z_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..421cae0 100644 --- a/dlls/d3d9/tests/visual.c +++
> b/dlls/d3d9/tests/visual.c @@ -1825,6 +1825,404 @@ done: 
> DestroyWindow(window); }
>
> +/* This test tests fog in combination with negative vertex z
> coordinates. */ +static void fog_negative_z_test(void) +{ +
> enum +    { +        C_ALPHA_0x00  = 0x00000000, +        C_CLEAR
> = 0xffff00ff, +        C_FOGGED      = 0x0000ff00, +
> C_HALF_FOGGED = 0x00808000, +        C_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, y; 
> +    IDirect3D9 *d3d; +    ULONG refcount; +    D3DCAPS9 caps; +
> DWORD color, expected_middle_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; +    } +    quad1[] = +    { +
> {{-1.0f, -1.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{-1.0f,  0.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 1.0f, -1.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 1.0f,
> 0.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +    }, +    quad2[] = +
> { +        {{-1.0f,  0.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{-1.0f,  1.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 0.0f,  0.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 0.0f,
> 1.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +    }, +    quad3[] = +
> { +        {{ 0.0f,  0.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +
> {{ 0.0f,  1.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 1.0f,  0.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 1.0f,
> 1.0f,  1.0f}, C_UNFOGGED, C_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_middle_top; +        DWORD color_middle_bottom; +
> DWORD color_right; +    } +    test_data[] = +    { +        /*
> Using z-based fog, the bottom quad should have a gradient
> UNFOGGED->FOGGED +         * for table fog, and be completely
> fogged for vertex fog. +         * When the fog coordinate returned
> by the vertex shader is used instead, +         * the result is a
> gradient FOGGED->UNFOGGED in the right half of the screen. */ + +
> /* No vertex shader */ +        {0, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {0,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {0, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_UNFOGGED,    C_FOGGED,      C_FOGGED}, +        {0,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_FOGGED}, + +        /* Vertex shader without vertex fog
> computation */ +        {1, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {1,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {1, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_FOGGED,      C_FOGGED,      C_FOGGED}, +        {1,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_FOGGED}, + +        /* Vertex shader vs_1_1 with vertex fog
> computation */ +        {2, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {2,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {2, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_FOGGED,      C_FOGGED,      C_UNFOGGED}, +        {2,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_UNFOGGED}, + +        /* Vertex shader vs_2_0 with vertex fog
> computation */ +        {3, D3DFOG_NONE,   D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +        {3,
> D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {3, D3DFOG_LINEAR, D3DFOG_NONE,
> C_FOGGED,   C_FOGGED,      C_FOGGED,      C_UNFOGGED}, +        {3,
> D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,
> C_UNFOGGED}, +    }; +    /* Affine projection matrix for z-near =
> -1, z-far = 1. */ +    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, 0.5f, 0.0f, +        0.0f, 0.0f, 0.5f, 1.0f, +    }}}; 
> +    /* Transposed version of proj_mat to pass to the vertex
> shaders. */ +    static const D3DMATRIX proj_mat_transposed = +
> {{{ +        1.0f, 0.0f, 0.0f, 0.0f, +        0.0f, 1.0f, 0.0f,
> 0.0f, +        0.0f, 0.0f, 0.5f, 0.5f, +        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. */ +        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_transposed, 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,
> D3DZB_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, C_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); 
> + +    /* We are using an affine projection matrix, so fog start
> and end are in device space coords. +     * This corresponds to a
> fog from z=-1 to z=1. */ +    start.f = 0.0f; +    end.f = 1.0f; + 
> +    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,
> C_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,
> &quad1[0], sizeof(quad1[0])); +            ok(SUCCEEDED(hr),
> "DrawPrimitiveUP failed (%#x)\n", hr); +            hr =
> IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,
> &quad2[0], sizeof(quad2[0])); +            ok(SUCCEEDED(hr),
> "DrawPrimitiveUP failed (%#x)\n", hr); +            hr =
> IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2,
> &quad3[0], sizeof(quad3[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. */ +            for (y = 120; y <= 360; y
> += 240) +            { +                color =
> getPixelColor(device, 2, y); +                ok(color_match(color,
> test_data[i].color_left, 13), +                        "fog vs%i
> ps%i fvm%i ftm%i, y=%i: got left color %08x, expected
> %08x+-5%%\n", +                        test_data[i].vshader, ps,
> test_data[i].vfog, test_data[i].tfog, y, +
> color, test_data[i].color_left); +                color =
> getPixelColor(device, 320, y); +
> expected_middle_color = +                        (y == 120 ?
> test_data[i].color_middle_top : test_data[i].color_middle_bottom); 
> +                ok(color_match(color, expected_middle_color, 13), 
> +                        "fog vs%i ps%i fvm%i ftm%i, y=%i: got
> middle color %08x, expected %08x+-5%%\n", +
> test_data[i].vshader, ps, test_data[i].vfog, test_data[i].tfog, y, 
> +                        color, expected_middle_color); +
> color = getPixelColor(device, 638, y); +
> ok(color_match(color, test_data[i].color_right, 13), +
> "fog vs%i ps%i fvm%i ftm%i, y=%i: got right color %08x, expected
> %08x+-5%%\n", +                        test_data[i].vshader, ps,
> test_data[i].vfog, test_data[i].tfog, y, +
> 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 +17127,7 @@
> START_TEST(visual) test_vshader_input(); test_vshader_float16(); 
> stream_test(); +    fog_negative_z_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..286b828 100644 --- a/dlls/ddraw/tests/ddraw7.c +++
> b/dlls/ddraw/tests/ddraw7.c @@ -3384,6 +3384,191 @@ static void
> test_fog_special(void) DestroyWindow(window); }
>
> +/* This test tests fog in combination with negative vertex z
> coordinates. */ +static void test_fog_negative_z(void) +{ +
> enum +    { +        C_ALPHA_0x00  = 0x00000000, +        C_CLEAR
> = 0xffff00ff, +        C_FOGGED      = 0x0000ff00, +
> C_HALF_FOGGED = 0x00808000, +        C_UNFOGGED    = 0x00ff0000 +
> }; + +    D3DCOLOR color, expected_middle_color; +    HRESULT hr; +
> ULONG refcount; +    BOOL has_table_fog_support; +    unsigned int
> i, y; +    HWND window; +    IDirect3DDevice7 *device; +
> IDirectDrawSurface7 *rt; +    D3DDEVICEDESC7 caps; + +    union +
> { +        float f; +        DWORD d; +    } start, end; + +
> static struct +    { +        struct vec3 position; +
> D3DCOLOR diffuse; +        D3DCOLOR specular; +    } +    quad1[]
> = +    { +        {{-1.0f,  0.0f, -1.0f}, C_UNFOGGED,
> C_ALPHA_0x00}, +        {{ 1.0f,  0.0f,  1.0f}, C_UNFOGGED,
> C_ALPHA_0x00}, +        {{-1.0f, -1.0f, -1.0f}, C_UNFOGGED,
> C_ALPHA_0x00}, +        {{ 1.0f, -1.0f,  1.0f}, C_UNFOGGED,
> C_ALPHA_0x00}, +    }, +    quad2[] = +    { +        {{-1.0f,
> 1.0f, -1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 0.0f,  1.0f,
> 0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{-1.0f,  0.0f, -1.0f},
> C_UNFOGGED, C_ALPHA_0x00}, +        {{ 0.0f,  0.0f,  0.0f},
> C_UNFOGGED, C_ALPHA_0x00}, +    }, +    quad3[] = +    { +
> {{ 0.0f,  1.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{
> 1.0f,  1.0f,  1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 0.0f,
> 0.0f,  0.0f}, C_UNFOGGED, C_ALPHA_0x00}, +        {{ 1.0f,  0.0f,
> 1.0f}, C_UNFOGGED, C_ALPHA_0x00}, +    }; +    static const struct
> test_data_t +    { +        DWORD vertexmode, tablemode; +
> D3DCOLOR color_left, color_middle_top, color_middle_bottom,
> color_right; +    } +    test_data[] = +    { +
> {D3DFOG_NONE,   D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED,
> C_HALF_FOGGED, C_FOGGED}, +        {D3DFOG_LINEAR, D3DFOG_LINEAR,
> C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED}, +
> {D3DFOG_LINEAR, D3DFOG_NONE,   C_FOGGED,   C_UNFOGGED,    C_FOGGED,
> C_FOGGED}, +        {D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,
> C_FOGGED,      C_FOGGED,      C_FOGGED}, +    }; +    /* Affine
> projection matrix for z-near = -1, z-far = 1. */ +    static
> D3DMATRIX proj_mat = +    { +        1.0f, 0.0f, 0.0f, 0.0f, +
> 0.0f, 1.0f, 0.0f, 0.0f, +        0.0f, 0.0f, 0.5f, 0.0f, +
> 0.0f, 0.0f, 0.5f, 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,
> C_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); + +    /* We are using an affine projection
> matrix, so fog start and end are in device space coords. +     *
> This corresponds to a fog from z=-1 to z=1. */ +    start.f =
> 0.0f; +    end.f = 1.0f; + +    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, C_CLEAR, 1.0f, 0); +        ok(SUCCEEDED(hr),
> "Failed to clear render target, i=%d, hr %#x.\n", i, hr); + +
> hr = IDirect3DDevice7_SetRenderState(device,
> D3DRENDERSTATE_FOGVERTEXMODE, test_data[i].vertexmode); +
> ok(SUCCEEDED(hr), "Failed to set fog vertex mode, i=%d, hr %#x.\n",
> i, hr); +        hr = IDirect3DDevice7_SetRenderState(device,
> D3DRENDERSTATE_FOGTABLEMODE, test_data[i].tablemode); +
> ok(SUCCEEDED(hr), "Failed to set fog table mode, i=%d, hr %#x.\n",
> i, hr); + +        hr = IDirect3DDevice7_BeginScene(device); +
> ok(SUCCEEDED(hr), "Failed to begin scene, i=%d, hr %#x.\n", i,
> hr); +        hr = IDirect3DDevice7_DrawPrimitive(device,
> D3DPT_TRIANGLESTRIP, +                D3DFVF_XYZ | D3DFVF_DIFFUSE |
> D3DFVF_SPECULAR, quad1, 4, 0); +        ok(SUCCEEDED(hr), "Failed
> to draw, i=%d, hr %#x.\n", i, hr); +        hr =
> IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, +
> D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, quad2, 4, 0); +
> ok(SUCCEEDED(hr), "Failed to draw, i=%d, hr %#x.\n", i, hr); +
> hr = IDirect3DDevice7_DrawPrimitive(device, D3DPT_TRIANGLESTRIP, +
> D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, quad3, 4, 0); +
> ok(SUCCEEDED(hr), "Failed to draw, i=%d, hr %#x.\n", i, hr); +
> hr = IDirect3DDevice7_EndScene(device); +        ok(SUCCEEDED(hr),
> "Failed to end scene, i=%d, hr %#x.\n", i, hr); + +        /* Use
> 5% tolerance on the colors since there may be a gradient +
> * between left and right vertices. */ +        for (y = 120; y <=
> 360; y += 240) +        { +            color =
> get_surface_color(rt, 2, y); +            ok(compare_color(color,
> test_data[i].color_left, 13), +                    "fog fvm%i ftm%i
> y=%i: got left color %08x, expected %08x+-5%%.\n", +
> test_data[i].vertexmode, test_data[i].tablemode, color, y, +
> test_data[i].color_left); +            color =
> get_surface_color(rt, 320, y); +            expected_middle_color
> = +                    (y == 120 ? test_data[i].color_middle_top :
> test_data[i].color_middle_bottom); +
> ok(compare_color(color, expected_middle_color, 13), +
> "fog fvm%i ftm%i y=%i: got middle color %08x, expected
> %08x+-5%%.\n", +                    test_data[i].vertexmode,
> test_data[i].tablemode, y, +                    color,
> expected_middle_color); +            color = get_surface_color(rt,
> 638, y); +            ok(compare_color(color,
> test_data[i].color_right, 13), +                    "fog fvm%i
> ftm%i y=%i: got right color %08x, expected %08x+-5%%.\n", +
> test_data[i].vertexmode, test_data[i].tablemode, y, +
> 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 +7856,7 @@ START_TEST(ddraw7) 
> test_clear_rect_count(); test_coop_level_versions(); 
> test_fog_special(); +    test_fog_negative_z(); 
> 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 7379ba2..b78e59e 100644 ---
> a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@
> -4352,7 +4352,7 @@ static GLhandleARB
> generate_param_reorder_function(struct wined3d_shader_buffer } else
> if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_FOG)) 
> { -                shader_addline(buffer, "gl_FogFragCoord =
> clamp(vs_out[%u].%c, 0.0, 1.0);\n", i, reg_mask[1]); +
> shader_addline(buffer, "gl_FogFragCoord = vs_out[%u].%c;\n", i,
> reg_mask[1]); } } shader_addline(buffer, "}\n"); @@ -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:

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQIcBAEBAgAGBQJUR5+HAAoJEN0/YqbEcdMwkzAP/Rr0nW6/UhcjbrhTWFapJgu1
yofwZuo6jh6hWeqYJQKmI+ltYY+D6zX8yjaAZv8b+JbW5QbNAAUkH8UR1DakrvuY
ZxBKxOURffVifx3cC1K6c8Joy2j/0TLKMGBtB5MMNZKpRaROPa+jGo6Yp7B3lyqr
V3V0OfOSyduQTSpFdXLTkQzXK0qu4Knk1tGqg3IuuLERMZC8ClYnrTMnwO1nU93J
PLXT+AVF0/h6/pHOyyXJm63w5+j8ZQGScqEVaqaT+Js3Yl2KKc+IgiOCo81VdCF+
AcTh2ReRSxQLIp+5qcGw36/dw/+RSq+Hld54OsnDZlgpLd1nYs3Bs6DBae7aaQZ8
QUEzc74DThOssKcOmObfuplzAEcg1VP7Asb7aHxWAzRUrnpLJS5L+NAJYtzzOld3
1dLTjXoQO+B+RCwh5Ea5gbSLbhX8h5U2amA6IEract8rKU5EMWlGmJ7l2TX+3HY9
5hiBMXSEeARTfkwXTqhf+NTpL4A0kXudd25/9RgubfOJusZT5vWKMJryMbW/H5Ah
TKpYDiFYC7bBGaTlsxHb1CWoOweFIRm1ord4vob7IB3KBE9VCvm2j+3ZxHmm2dld
J4WyhbrErJq86Qxa6tToh9ELZlg4UkJxvUOxjdD7ra4qo2isd9ABkbxhxoHgcvY2
PqVs5A384cEgYrNgBe55
=hu36
-----END PGP SIGNATURE-----

wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Joachim Priesner]

Hi,

thanks for testing -- unfortunately I can only test on one Nvidia system and on VMware.
> I have tested your patches on my various systems. I have replaced
> C_IGNORE in the d3d8 test with C_FOGGED. The test passes on Nvidia
> cards, but fails (also in d3d9) on my AMD cards. As far as I can see
> AMD cards clamp the fog coord.

Okay, so the fog clamp is not wrong. I'll be happy to re-add it and modify the test so it accepts both variants.
> I haven't quite understood yet what you're doing with quad2/quad3, so
> I can't comment on the code yet.

These are not strictly necessary, but the idea is to make sure quad1 being fully fogged when using vertex fog is not some kind of artifact. Basically, I "split" quad1 at z=0, so quad2/quad3 should have a gradient FOGGED -> UNFOGGED -> FOGGED.

If you think they do more harm than good by cluttering the test, I can remove it without the abs() bug not being detected.

Joachim

wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Stefan Dösinger]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Am 2014-10-22 14:53, schrieb Joachim Priesner:
> Okay, so the fog clamp is not wrong. I'll be happy to re-add it and modify the test so it accepts both variants.
> There's D3DPMISCCAPS_FOGVERTEXCLAMPED. I can't find any docs with a quick google search, but it sounds related.
> +        /* No vertex shader */
> +        {0, D3DFOG_NONE,   D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED},
> +        {0, D3DFOG_LINEAR, D3DFOG_LINEAR, C_UNFOGGED, C_HALF_FOGGED, C_HALF_FOGGED, C_FOGGED},
> +        {0, D3DFOG_LINEAR, D3DFOG_NONE,   C_FOGGED,   C_UNFOGGED,    C_FOGGED,      C_FOGGED},
> +        {0, D3DFOG_NONE,   D3DFOG_NONE,   C_FOGGED,   C_FOGGED,      C_FOGGED,      C_FOGGED},
> I am wondering about the table fog = linear cases. As far as I understand it they are different from the table fog = none, vertex fog = linear case because of the "w fog" functionality, which is called ortho_fog in wined3d.

The trouble is that the vfog=linear, tfog=none case has an open question: What exactly do the d3d docs mean with "applies fog calculations at each vertex in a polygon". Does that mean no fog factor (oFog) is written by the fixed function pipeline, and the fog color merged into oD0 right away? In other words, assume fixed function vertex processing with an 1.x pixel shader. The vertex input color is red, the fog color green, the Z coordinate results in a fully fogged quad and the pixel shader writes blue. Does that produce a blue or green output? (We may have a test that deliberately or accidentally tests this. I will check.)

If you bypass the W fog thing e.g. by using 1.000001f in proj_matrix[3][3] you get a fully fogged quad in the table fog case as well. But then your sanity check with quad2/quad3 is fully green as well, and I don't yet understand why.

Gosh this is complicated. So much for a simple abs().

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQIcBAEBAgAGBQJUR76hAAoJEN0/YqbEcdMwyVgP/jRyHlc+MT7IDYFmHEBpqPOD
TD0Uqi6MRQAFmV68Gb38KGqwxQJGUPEjOI+cUPEfaZMSa8UzrD6zpHmUz0CGxpHy
2e28m105HoHqi+JIWdkIN+SK8brSSrkqtW4qDxsndCahdREFfJvBbaUq9C64KUDR
ecSwiZLD6MeoSbBHeWYcntNtqwNfI2DdrwTYQYG5hgBbhIQ0rFE60WTdywpf6Fj4
mdkJFY8TkBewQ4zzfT0cox3UOFMqZdCwPLV7K+Q1w4QmpK1w6QAPUz8NflSgAEa7
b6cVfoCLQUkhZmWEh74/LSp90hJ+9AABx7ck4kRkIsalcOn3ysQ0DY937J1NJzgl
WKYrOzR7o75lupYGpKHBFw9iU+SLMMJcIO6ZFSRhony1NSU2TxhNex/gptP02jKh
sJxTyV1+klyanbTHuC4osK8+OuX6BDy0Jw/WVFrLzbi7x6rJ5XXK3uN/9gq60qsS
WGEnbaQWN550mFxC0RthwKCmPxcg6NkKS4Tr9q0PiFVtKcrkOddIQAAn5swtYio0
HPwOpKhYmiALHWnTK0ZP0tgpltfoxQDARg/COosiIZ9ppiirEahz/ls7US6kqCul
+5MJ62JdL9O/jZIU6MHNpaUT75WWdn++HdczKIMx4uZJbobHmrkiChhbzTn2rrbs
DPaPifzYm9AmAxeyxFue
=Yhnk
-----END PGP SIGNATURE-----

wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Joachim Priesner]

> There's D3DPMISCCAPS_FOGVERTEXCLAMPED. I can't find any docs with a quick google search, but it sounds related.

That flag doesn't exist prior to d3d9. The tests differ on d3d8 too, and I haven't found a matching flag there. (If you think it's worth a look: What is the value of this flag for your AMD cards?)


By the way, I found this regarding clamping: http://msdn.microsoft.com/en-us/library/windows/hardware/ff539405%28v=vs.85%...

"Because the driver clamps the fog intensity value on a per-pixel basis, the runtime for DirectX 9.0 and later no longer clamps the fog intensity value before sending it to the driver."

This suggests that the clamping behavior should be different for d3d8 and d3d9. The D3DPMISCCAPS_FOGINFVF flag could probably be used to differentiate the behavior for d3d9, but again it does not exist on d3d8.
> Gosh this is complicated. So much for a simple abs().

Definitely, so thanks for your help. The tests for abs() should now be sufficient [in theory -- e.g. I have no idea what to do about them crashing on your Radeon 9000].

Testing the oFog clamp behavior is a nice extra -- I wouldn't be unhappy if a version of the patch that leaves that out could be committed.

Best
Joachim

wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Stefan Dösinger]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Am 2014-10-24 23:03, schrieb Joachim Priesner:
> That flag doesn't exist prior to d3d9. The tests differ on d3d8
> too, and I haven't found a matching flag there. (If you think it's
> worth a look: What is the value of this flag for your AMD cards?)
> All my Radeon cards set it.

If it's not too much effort I suggest this: Modify
dlls/wined3d/directx.c to set the flag in a separate one-liner patch.
Make the d3d9 tests test expect colors according to the flag and make
d3d8 accept both results. If there are any other unforeseen issues
ignore the vertex clamping behavior.
> By the way, I found this regarding clamping: 
> http://msdn.microsoft.com/en-us/library/windows/hardware/ff539405%28v=vs.85%...

"Because the driver clamps the fog intensity value on a per-pixel
> basis, the runtime for DirectX 9.0 and later no longer clamps the
> fog intensity value before sending it to the driver."
> I think this only affects the fixed function vertex pipeline and not
> shaders. There are two ways to pass custom fog factors in the fixed
> function pipeline. One is the specular alpha, the other one is a
> separate D3DFVF_FOG field. We don't support D3DFVF_FOG, and I don't
> know about any game that uses it.

MSDN talks about software vertex shaders on this page. I don't really
know how they work, but I suspect from a driver point of view they
pass pretransformed vertices (D3DFVF_XYZRHW or D3DDECLUSAGE_POSITIONT).
> This suggests that the clamping behavior should be different for
> d3d8 and d3d9. The D3DPMISCCAPS_FOGINFVF flag could probably be
> used to differentiate the behavior for d3d9, but again it does not
> exist on d3d8.
> My guess is that prior to shader model 2, the register used to pass
> fog values was a fixed point register that supported values from 0.0
> to 1.0, so it was a hardware limitation that enforced the clamp. With
> Shader Model 2 the register turned into a float register, so d3d9
> needed a way for the driver to specify the behavior, maybe with the
> idea that old hardware clamps and new hardware does not. In that sense
> it would be a bug that Nvidia does not clamp when d3d8.dll is used
> with d3d9+ hardware and that AMD clamps when d3d9.dll is used with
> d3d9+ hardware.

For the sake of curiosity it would be interesting to know what Shader
Model 1 Nvidia hardware (Geforce 3/4) does, but I don't have such a
card. I also don't think it is too important because we didn't run
into a game that depends on either behavior. But we also didn't run
into a game that needs the fixed function abs() before...

Shader model 3 does away with the fixed varying semantics. It has just
10 general purpose unclamped float4 registers.
> Definitely, so thanks for your help. The tests for abs() should
> now be sufficient [in theory -- e.g. I have no idea what to do
> about them crashing on your Radeon 9000].
> Don't worry about the 9000. I'll investigate this when I have time.
> Testing the oFog clamp behavior is a nice extra -- I wouldn't be 
> unhappy if a version of the patch that leaves that out could be 
> committed.
> I'll do some investigation regarding vertex fog + a fragment
> processing setup that just replaces the color, but otherwise I agree.
> -----BEGIN PGP SIGNATURE-----
> Version: GnuPG v2
> Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQIcBAEBAgAGBQJUTjmeAAoJEN0/YqbEcdMwyWMP/1Q397z6qC+Ao/whYAWQQjeh
lu1820mJBJk9Lvek/NMXZvXpnXBeGCe9BWIU+Pn8Pixu1pvbHTbzWY9n+mQdNr35
oIr2z3OdTI57ZxDFriGQizgvI3LczuuL6rIAuih5fQQhxNz8xidiacRxRYd/D7rf
XXOA/JXb4FdMWlMoCqm3iDKH3eGbf1CGygU+wxgD3AfU+NWL1bV16XzJtY93Wzf0
Q0RSOIBDHFf9CO2+aBeM/XwaNvWIy6MRhUbWPVezaP3fNt69Qck6Eq/Jl+UTH9G2
3NlOs622d20B2/OIzyGqOX8KUI3GpOCq5CKm9ym6Gsrxqn5TenHu9eFZi2n4wqDT
iLHBGv/fK5jMgZucq8SLHJ4ft+oK8H04TC0P852GH6gXoqsLfn89mVYLqa7aOdGq
wSb9/g2kQYdXWgILY8xaIU2Q3VFni57SegZCmNVnZ0BvtLHyaZNqpRY+3DGfBbSV
7xThRE1Mpcvo4DQhtT86D2GVJ1pe4QxS1XfkHB3jXo/KY6K+weTlljPZXlfTF5k/
H1p9dTaezUvqwueCn+SOpE0zxQ0rbfkNyN0KQWEr7WeYohMoVtrej8AMzCKjbD02
Ln3kQ6+VW3+uJFKpl+9GvAQ3VdiDJJq1VdxUkswbxYuVhvp0pSkHBOinq480h9Og
+okc0UPMBzSLlbwCIgt9
=pMud
-----END PGP SIGNATURE-----

wined3d: Take abs() of vertex z coordinate as FFP fog coordinate and remove oFog clamp for vertex shaders

[Stefan Dösinger]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Am 2014-10-27 13:25, schrieb Stefan Dösinger:
> > Testing the oFog clamp behavior is a nice extra -- I wouldn't be
> >  unhappy if a version of the patch that leaves that out could be
> >  committed.
> > I'll do some investigation regarding vertex fog + a fragment 
> > processing setup that just replaces the color, but otherwise I
> > agree.
> > The attached test combined with your test should show that fixed
> > function vertex fog indeed output a fog coordinate of abs(z) and does
> > not merge the fog color into the diffuse color prior to fragment
> > processing. (no d3d8 and ddraw versions yet)
> > -----BEGIN PGP SIGNATURE-----
> > Version: GnuPG v2
> > Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iQIcBAEBAgAGBQJUTkeHAAoJEN0/YqbEcdMw4fYP/intJBx+BZem3ev9vMk+ytVw
ok7+rLvWgLCB0+otKqTtcz4C1wXcna07BC4HYMExRclmZKRj3jf2rN6nwLfXzN2n
4ETIXpj9gHP8S4XFM98LXlf43FsmNcNdgJ1RxaA1vIk8IfXSo+knVs6pxSXGUcuL
FPkR7VE1WTkHybNTrseWbNg3vkAmgZBZGiXKvEVbVvrcsS45vC0bI0/L8bHk6tOc
+68/58JDxo+kEee14CrrFarezqxtloNTK3U/jek1hZCje407PG+RL2C++sVBHAQe
unZaXAr7YYkWj5APrSY7xl0aoSV7eeAD3nD7Zv7BMwOiwT2KW1MVTN5txAdaFh54
90qDmSgjm9p5ogXrFh6SOMsEU1+lT6RRDyNmKdRTlpqMWy/dydEJmhE2ncaGZag+
m5MbhSnB123YkihOdmP4/ntUgRHeleeqXMJHhI+FNatoUIVfVueS4RN+x/qkZDq+
9yDENZYt2RC8lP6rxo9JM0RpuehDuYr/8wOKkWVcYNhf9pGOjmF+gR7XF+e5f+fP
hKMfGsBFmPhyEX5Xw2TYYY8iipt8bWZvgJjg1PEUBRQSl4UhRAqNC5PCM+eSVlUW
z2J/2APenE4hRDPxKt2WFKyTTd1M/qdaKA9bq/8pezeXQK10O8LQeO2lYA6nvA72
eAx+qaN90LxFVbcrPsuz
=haWb
-----END PGP SIGNATURE-----