[PATCH v3 1/4] d3d9/tests: Add Fetch4 tests
DarkZeros
mailszeros at gmail.com
Sun Feb 3 19:59:43 CST 2019
Hi,
I managed to get FETCH4 working on 3dmark06 as well.
I got minor vertex explosions on the firefly test, i am unsure if this is
fetch4 related, or the hack I did to make fetch4 be used. (disabling some
big chunk of formats)
However, all lights looked ok on the tests.
I tested using stencil, and without stencil. Got same performance results,
but I agree that DF24 has no stencil,
so I am changing that in next patch version
.
Also, I tested with ATI1/ATI2/INTZ, but no luck getting FETCH4 working on
ATI1/2.
I may have set the texture values wrong, i will give it a more thorough
test tomorrow.
Regarding the INTZ. Interestingly.... Intel does support FETCH4 on it!
I also need to double check it, since maybe I tested it wrong.
If it is true that is on, it is quite an interesting edge case, a vendor
specific format using another vendor specific sampling.
We should test it on AMD as well.
BR,
Daniel
El sáb., 2 feb. 2019 a las 20:16, DarkZeros (<mailszeros at gmail.com>)
escribió:
> Good point about the other 1 channel textures. I will add them to the
> lists of tests.
> I was just not sure how many texture formats have fetch4 enabled. Took
> just the ones that existed in D3D9 + DF16/DF24.
>
> I think if the current state of tests will not pass on nine we can change
> them. Or set them as todo() or broken() if they fail on a platform that is
> not wine. Because anyway, it is not a failure we can fix if it os not
> running in wine.
> That will also cover possible cases that fail in the future on windows
> implementations of fetch4.
>
> BR,
> Daniel
>
> On Sat, 2 Feb 2019, 20:07 Axel Davy <davyaxel0 at gmail.com wrote:
>
>> Hi,
>>
>> L8 is xxx1, thus sampling it with FETCH4 is different for the A
>> coordinate.
>>
>> I understand your point for disabling it in wine for complex cases.
>> But from what I'm used to in visual tests, nine doesn't do always the
>> same things as wine but it isn't a problem as the wine behavior is not
>> specifically checked when on wine. And we pass some wine_todo. With your
>> approach we would fail even if we implement a correct behavior.
>> But, of course, it is up to wine developers, if they want wine tests to
>> fail on nine because it doesn't do exactly like wine.
>>
>> You didn't comment on ATI1 and INTZ. Both have only one channel, so I
>> would assume it's an interesting thing to test for FETCH4.
>>
>> Axel
>>
>>
>> On 02/02/2019 20:50, DarkZeros wrote:
>>
>> Hi Axel,
>>
>> Thanks for testing with 3dmark06. I tried to run it without luck
>> yesterday, apparently there is some winetrick that i am missing...
>>
>> Regarding the linear sampler state. I havent seen any case where setting
>> the filters to LINEAR disables fetch4. From the tests, it only changes
>> slightly the results on R500 AMD by changing the 0.5 texel offset.
>>
>> My guess, is that all apps that use fetch4 have that into account, and
>> disable it with LODBIAS explicitly.
>> Sampling a 1x1 L8 texture with fetch4 will return the same value on RGBA,
>> which is similar to a normal sample.
>>
>> Regarding 3D textures, all implementations behave differently. Since 3D
>> textures have 8 texels, returning the 4 texels used for linear sampling is
>> quite ambiguous.
>> Intel decides to sample at .xy0 and ignore the Z axis.
>> Some AMD devices disable fetch4, some others sample at the nearest z
>> coordinate.
>>
>> In my opinion, we are hitting implementation bugs/corner cases. It is
>> simpler to just keep fetch4 off there. Especially since implementing it is
>> quite difficult.
>>
>> The tests of 3D textures in wine are just testing that fetch4 is off (no
>> todo, it should be always off).
>> But on windows, it tests that some of the 4 possibles cases seen on AMD
>> and intel is obtained.
>> How useful those tests are, i am not sure. I just left them there for
>> reference.
>>
>>
>> Maybe we should remove those tests on windows, or even add todo in some
>> of the cases for 3d. But in that case, what implementation do we want to
>> follow?
>>
>> Best regards,
>> Daniel
>>
>>
>> On Sat, 2 Feb 2019, 19:14 Axel Davy <davyaxel0 at gmail.com wrote:
>>
>>> Hi,
>>>
>>> Apparently 3DMark06 believes somehow that LINEAR disables FETCH4.
>>> It sets MIPFILTER, MINFILTER and MAGFILTER to LINEAR,
>>> and resets ADDRESSV, ADDRESSU and MIPMAPLODBIAS (1, 1, 0 respectively)
>>> then behaves as if FETCH4 was disabled (it later disables it definitely
>>> with the MIPMAPLODBIAS setting).
>>>
>>> I don't see any obvious visual glitch, though. The texture sampled with
>>> FETCH4 which isn't meant to be sampled with it (looking at how the
>>> shader values are used) is a D3DFMT_L8 of size 1x1...
>>>
>>> I think all this points out that one has to be very careful about FETCH4
>>> corner cases.
>>>
>>> Thus I would suggest adding more formats and checks to your code, like
>>> for example INTZ, ATI1, ATI2 ?
>>>
>>>
>>> For the part "Currently unimplemented on wine due to lack of GL
>>> functionality to cast 3D->2DArray",
>>> shouldn't the test be with a wine_todo rather than a isWin check ?
>>>
>>>
>>> Axel
>>>
>>> On 01/02/2019 01:56, Daniel Ansorregui wrote:
>>> > - Test texld/texldp/texldd/texldb/texldl in PS and FFP
>>> > - Test supported/unsupported texture formats on FFP/texld/texldp
>>> > - Test 3dtextures (Disabled, each platform has different results)
>>> > - Test depth textures DF16/DF24 with fetch4 on PS (FFP is broken on
>>> windows)
>>> >
>>> > Signed-off-by: Daniel Ansorregui <mailszeros at gmail.com>
>>> > ---
>>> > dlls/d3d9/tests/visual.c | 644
>>> +++++++++++++++++++++++++++++++++++++++
>>> > 1 file changed, 644 insertions(+)
>>> >
>>> > diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c
>>> > index c06acb77d4..028fc23078 100644
>>> > --- a/dlls/d3d9/tests/visual.c
>>> > +++ b/dlls/d3d9/tests/visual.c
>>> > @@ -15234,6 +15234,649 @@ done:
>>> > DestroyWindow(window);
>>> > }
>>> >
>>> > +static void fetch4_test(void)
>>> > +{
>>> > + static const DWORD vs_code[] =
>>> > + {
>>> > + 0xfffe0300,
>>> /* vs_3_0 */
>>> > + 0x0200001f, 0x80000000, 0x900f0000,
>>> /* dcl_position v0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0001,
>>> /* dcl_texcoord v1 */
>>> > + 0x0200001f, 0x80000000, 0xe00f0000,
>>> /* dcl_position o0 */
>>> > + 0x0200001f, 0x80000005, 0xe00f0001,
>>> /* dcl_texcoord o1 */
>>> > + 0x02000001, 0xe00f0000, 0x90e40000,
>>> /* mov o0, v0 */
>>> > + 0x02000001, 0xe00f0001, 0x90e40001,
>>> /* mov o1, v1 */
>>> > + 0x0000ffff
>>> > + };
>>> > + static const DWORD ps_code_texld[] =
>>> > + {
>>> > + /* Test texld */
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0x90000000, 0xa00f0800,
>>> /* dcl_2d s0 */
>>> > + 0x03000042, 0x800f0000, 0x90e40000, 0xa0e40800,
>>> /* texld r0, v0, s0 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff
>>> /* end */
>>> > + };
>>> > + static const DWORD ps_code_texldp[] =
>>> > + {
>>> > + /* Test texldp : AMD and Wine uses the projection on Fetch4,
>>> Intel UHD 620 does not apply it */
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0x90000000, 0xa00f0800,
>>> /* dcl_2d s0 */
>>> > + 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x00000000,
>>> 0x40000000, /* def c0, 0.0, 0.0, 0.0, 2.0 */
>>> > + 0x02000001, 0x80030000, 0x90540000,
>>> /* mov r0.xy, v0.xyyy */
>>> > + 0x02000001, 0x800c0000, 0xa0fe0000,
>>> /* mov r0.zw, c0.zwww */
>>> > + 0x03010042, 0x800f0000, 0x80e40000, 0xa0e40800,
>>> /* texldp r0, r0, s0 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff,
>>> /* end */
>>> > + };
>>> > + static const DWORD ps_code_texldd[] =
>>> > + {
>>> > + /* Test texldd : Fetch4 uses the same D3D state as LOD bias,
>>> therefore disables LOD.
>>> > + * Sampling LOD gradient should be ignored.
>>> Same result as texld */
>>> > + /* NOTE: Radeon HD 5700 driver 8.17.10.1404 disables Fetch4
>>> on texldb */
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0x90000000, 0xa00f0800,
>>> /* dcl_2d s0 */
>>> > + 0x05000051, 0xa00f0000, 0x3f000000, 0x3f000000, 0x3f000000,
>>> 0x3f000000, /* def c0, 0.5, 0.5, 0.5, 0.5 */
>>> > + 0x05000051, 0xa00f0001, 0x3f800000, 0x3f800000, 0x3f800000,
>>> 0x3f800000, /* def c0, 1.0, 1.0, 1.0, 1.0 */
>>> > + 0x02000001, 0x800f0002, 0xa0e40000,
>>> /* mov r2, c0 */
>>> > + 0x0500005d, 0x800f0000, 0x90e40000, 0xa0e40800, 0xa0e40000,
>>> 0x80e40002, /* texldd r0, v0, s0, c0, r2 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff,
>>> /* end */
>>> > + };
>>> > + static const DWORD ps_code_texldb[] =
>>> > + {
>>> > + /* Test texldb : Fetch4 uses the same D3D state as LOD bias,
>>> therefore disables LOD.
>>> > + * Same result as texld */
>>> > + /* NOTE: Radeon HD 5700 driver 8.17.10.1404 disables Fetch4
>>> on texldb */
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0x90000000, 0xa00f0800,
>>> /* dcl_2d s0 */
>>> > + 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x40a00000,
>>> 0x40a00000, /* def c0, 0.0, 0.0, 5.0, 5.0 */
>>> > + 0x03000002, 0x800f0000, 0x90e40000, 0xa0e40000,
>>> /* add r0, v0, c0 */
>>> > + 0x03020042, 0x800f0000, 0x80e40000, 0xa0e40800,
>>> /* texldb r0, r0, s0 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff,
>>> /* end */
>>> > + };
>>> > + static const DWORD ps_code_texldl[] =
>>> > + {
>>> > + /* Test texldl : Fetch4 uses the same D3D state as LOD bias,
>>> therefore disables LOD.
>>> > + * The explicit LOD level is then ignored. Same
>>> result as texld */
>>> > + /* NOTE: Radeon HD 5700 driver 8.17.10.1404 disables Fetch4
>>> on texldl */
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0x90000000, 0xa00f0800,
>>> /* dcl_2d s0 */
>>> > + 0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x3f000000,
>>> 0x3f000000, /* def c0, 0.0, 0.0, 0.5, 0.5 */
>>> > + 0x03000002, 0x800f0000, 0x90e40000, 0xa0e40000,
>>> /* add r0, v0, c0 */
>>> > + 0x0300005f, 0x800f0000, 0x80e40000, 0xa0e40800,
>>> /* texldl r0, r0, s0 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff,
>>> /* end */
>>> > + };
>>> > + static const DWORD ps_code_3d[] =
>>> > + {
>>> > + 0xffff0300,
>>> /* ps_3_0 */
>>> > + 0x0200001f, 0x80000005, 0x900f0000,
>>> /* dcl_texcoord v0 */
>>> > + 0x0200001f, 0xa0000000, 0xa00f0800,
>>> /* dcl_volume s0 */
>>> > + 0x03000042, 0x800f0000, 0x90e40000, 0xa0e40800,
>>> /* texld r0, v0, s0 */
>>> > + 0x02000001, 0x800f0800, 0x80e40000,
>>> /* mov oC0, r0 */
>>> > + 0x0000ffff
>>> /* end */
>>> > + };
>>> > +
>>> > + static const struct
>>> > + {
>>> > + struct vec3 position;
>>> > + struct vec3 texcoord;
>>> > + }
>>> > + quad[] =
>>> > + {
>>> > + /* Tilted on Z axis to get a depth gradient in the depth test
>>> */
>>> > + /* NOTE: Using 0.55f-0.6f to avoid rounding errors on depth
>>> tests */
>>> > + {{-1.0f, 1.0f, 1.0f}, {0.0f,0.0f,0.6f} },
>>> > + {{ 1.0f, 1.0f, 0.0f}, {1.0f,0.0f,0.6f} },
>>> > + {{-1.0f,-1.0f, 0.0f}, {0.0f,1.0f,0.6f} },
>>> > + {{ 1.0f,-1.0f, 0.0f}, {1.0f,1.0f,0.6f} }
>>> > + };
>>> > +
>>> > + static const struct
>>> > + {
>>> > + UINT x[4], y[4]; /* Matrix Sampling positions */
>>> > + D3DCOLOR color_amd[16]; /* AMD original implementation
>>> swizzle with -0.5 texel coord */
>>> > + D3DCOLOR color_intel[16]; /* Intel UHD 620 implementation
>>> swizzle with no texel coord correction */
>>> > + /* Wine follows the AMD immplementation, and consider an
>>> error the Intel one results
>>> > + * However, the test will accept as valid the intel only if
>>> running on windows */
>>> > + D3DCOLOR color_3d_fetch4_off[16];
>>> > + D3DCOLOR color_fetch4_off[16];
>>> > + }
>>> > + expected_colors =
>>> > + {
>>> > + { 40, 200, 360, 520},
>>> > + { 30, 150, 270, 390},
>>> > + /* AMD implementation - Wine implementation */
>>> > + {0x131202f2, 0x1211f2f1, 0x1110f101, 0x10130102,
>>> > + 0x02f204f4, 0xf2f1f4f3, 0xf101f303, 0x01020304,
>>> > + 0x04f42322, 0xf4f32221, 0xf3032120, 0x03042023,
>>> > + 0x23221312, 0x22211211, 0x21201110, 0x20231013},
>>> > + /* Intel UHD 620 implementation */
>>> > + {0x23102013, 0x22132312, 0x21122211, 0x20112110,
>>> > + 0x13011002, 0x120213f2, 0x11f212f1, 0x10f11101,
>>> > + 0x02030104, 0xf20402f4, 0xf1f4f2f3, 0x01f3f103,
>>> > + 0x04200323, 0xf4230422, 0xf322f421, 0x0321f320},
>>> > + /* Fetch4 off on 3D textures */
>>> > + {0xff020202, 0xfff2f2f2, 0xfff1f1f1, 0xff010101,
>>> > + 0xff050505, 0xfff4f4f4, 0xfff3f3f3, 0xff030303,
>>> > + 0xff232323, 0xff222222, 0xff212121, 0xff202020,
>>> > + 0xff131313, 0xff121212, 0xff111111, 0xff101010},
>>> > + /* Fetch4 off on 2D texture */
>>> > + {0x13131313, 0x12121212, 0x11111111, 0x10101010,
>>> > + 0x02020202, 0xf2f2f2f2, 0xf1f1f1f1, 0x01010101,
>>> > + 0x04040404, 0xf4f4f4f4, 0xf3f3f3f3, 0x03030303,
>>> > + 0x23232323, 0x22222222, 0x21212121, 0x20202020}
>>> > + };
>>> > +
>>> > + static const DWORD fetch4_data[] = {0x10111213,
>>> > + 0x01f1f202,
>>> > + 0x03f3f404,
>>> > + 0x20212223};
>>> > +
>>> > + static struct
>>> > + {
>>> > + IDirect3DVertexShader9 *vs;
>>> > + IDirect3DPixelShader9 *ps;
>>> > + const DWORD *ps_code;
>>> > + const char *name;
>>> > + BOOL projection; /* The results should be
>>> projected (zoomed by 2) */
>>> > + BOOL allow_off; /* Do not enforce Fetch4 enabled
>>> on this one on Windows */
>>> > + }
>>> > + shaders[] =
>>> > + {
>>> > + {NULL, NULL, NULL, "FFP", FALSE, FALSE},
>>> > + {NULL, NULL, ps_code_texld, "texld", FALSE, FALSE},
>>> > + {NULL, NULL, ps_code_texldp, "texldp", TRUE, FALSE},
>>> > + {NULL, NULL, ps_code_texldd, "texldd", FALSE, TRUE},
>>> > + {NULL, NULL, ps_code_texldb, "texldb", FALSE, TRUE},
>>> > + {NULL, NULL, ps_code_texldl, "texldl", FALSE, TRUE},
>>> > + };
>>> > +
>>> > + static const struct
>>> > + {
>>> > + D3DFORMAT format; /* The format of the texture */
>>> > + DWORD data; /* The data we will write to the
>>> first line */
>>> > + UINT x, y; /* Where we expect the color to
>>> be */
>>> > + BOOL broken_wine; /* Do not check it on wine
>>> because is known ot be broken */
>>> > + D3DCOLOR color_amd[3]; /* Wine results. Results on AMD
>>> swizzle + texture offset */
>>> > + D3DCOLOR color_intel[3]; /* Results with intel UHD 620,
>>> intel swizzle + no texel offset */
>>> > + }
>>> > + format_tests[] =
>>> > + {
>>> > + /* Enabled formats */
>>> > + {D3DFMT_L8, 0xff804010, 360, 270, FALSE,
>>> > + {0x00004010, 0x00004010, 0x10400000},
>>> > + {0x40001000, 0x40001000, 0x40001000}
>>> > + },
>>> > + {D3DFMT_L16, 0xff804010, 360, 270, FALSE,
>>> > + {0x0000ff40, 0x0000ff40, 0x40ff0000},
>>> > + {0xff004000, 0xff004000, 0xff004000}
>>> > + },
>>> > + {D3DFMT_R16F, 0x38003c00, 360, 270, FALSE,
>>> > + {0x000080ff, 0x000080ff, 0xff800000},
>>> > + {0x8000ff00, 0x8000ff00, 0x8000ff00}
>>> > + },
>>> > + {D3DFMT_R32F, 0x3f000000, 360, 270, FALSE,
>>> > + {0x00000080, 0x00000080, 0x80000000},
>>> > + {0x00008000, 0x00008000, 0x00008000}
>>> > + },
>>> > +
>>> > + /* Disabled format on Intel, enabled on AMD, broken on wine
>>> > + * since it is implemented with GL_ALPHA, and fetch4 will
>>> fetch RED value */
>>> > + {D3DFMT_A8, 0xff804010, 360, 270, TRUE,
>>> > + {0x00004010, 0x00004010, 0x10400000},
>>> > + {0x00000000, 0x00000000, 0x00000000}
>>> > + },
>>> > +
>>> > + /* Disabled format */
>>> > + {D3DFMT_A8R8G8B8, 0xff804010, 360, 270, FALSE,
>>> > + {0x00000000, 0x00000000, 0xff804010},
>>> > + {0x00000000, 0x00000000, 0xff804010}
>>> > + },
>>> > + };
>>> > +
>>> > + static const struct
>>> > + {
>>> > + D3DCOLOR color_off, color_amd, color_intel;
>>> > + UINT x, y;
>>> > + }
>>> > + expected_depth[][4] =
>>> > + {
>>> > + {
>>> > + /* This is the expected result for shadow samplers */
>>> > + {0xffffffff,0xffffffff,0xffffffff, 20, 15},
>>> > + {0xffffffff,0xffffffff,0xffffffff,260, 15},
>>> > + {0x00000000,0x00000000,0x00000000, 20,255},
>>> > + {0x00000000,0x00000000,0x00000000,260,135},
>>> > + },
>>> > + {
>>> > + /* This is the expected result with DF16 */
>>> > + {0xfffe0000,0xfedfdfbf,0x202000ff, 20, 15},
>>> > + {0xff9f0000,0x9f7f7f5f,0x00bf009f,260, 15},
>>> > + {0xff800000,0x7f5f5f3f,0x9f000080, 20,255},
>>> > + {0xff600000,0x5f3f3f1f,0x80809f60,260,135},
>>> > + },
>>> > + {
>>> > + /* This is the expected result with DF24 */
>>> > + {0xffff0000,0xffdfdfbf,0x202000ff, 20, 15},
>>> > + {0xff9f0000,0x9f7f7f5f,0x00bf009f,260, 15},
>>> > + {0xff800000,0x7f5f5f3f,0x9f000080, 20,255},
>>> > + {0xff600000,0x5f3f3f1f,0x80809f60,260,135},
>>> > + }
>>> > + };
>>> > +
>>> > + static const struct
>>> > + {
>>> > + D3DFORMAT format;
>>> > + const char *name;
>>> > + UINT index;
>>> > + }
>>> > + depth_tests[] =
>>> > + {
>>> > + {D3DFMT_D16_LOCKABLE, "D16_LOCKABLE", 0},
>>> > + {D3DFMT_D32, "D32", 0},
>>> > + {D3DFMT_D15S1, "D15S1", 0},
>>> > + {D3DFMT_D24S8, "D24S8", 0},
>>> > + {D3DFMT_D24X8, "D24X8", 0},
>>> > + {D3DFMT_D24X4S4, "D24X4S4", 0},
>>> > + {D3DFMT_D16, "D16", 0},
>>> > + {D3DFMT_D32F_LOCKABLE, "D32F_LOCKABLE", 0},
>>> > + {D3DFMT_D24FS8, "D24FS8", 0},
>>> > + {MAKEFOURCC('D','F','1','6'), "DF16", 1},
>>> > + {MAKEFOURCC('D','F','2','4'), "DF24", 2},
>>> > + };
>>> > +
>>> > + const BOOL isWin = strcmp(winetest_platform, "wine");
>>> > +
>>> > + IDirect3DSurface9 *original_ds, *original_rt, *rt;
>>> > + IDirect3DVolumeTexture9 *texture3D;
>>> > + IDirect3DPixelShader9 *ps_3d;
>>> > + struct surface_readback rb;
>>> > + IDirect3DVertexShader9 *vs;
>>> > + IDirect3DTexture9 *texture;
>>> > + IDirect3DDevice9 *device;
>>> > + D3DLOCKED_RECT lr;
>>> > + D3DLOCKED_BOX lb;
>>> > + IDirect3D9 *d3d;
>>> > + ULONG refcount;
>>> > + D3DCAPS9 caps;
>>> > + UINT i, j, k;
>>> > + HWND window;
>>> > + HRESULT hr;
>>> > +
>>> > + window = create_window();
>>> > + d3d = Direct3DCreate9(D3D_SDK_VERSION);
>>> > + ok(!!d3d, "Failed to create a D3D object.\n");
>>> > + if (FAILED(IDirect3D9_CheckDeviceFormat(d3d, D3DADAPTER_DEFAULT,
>>> D3DDEVTYPE_HAL,
>>> > + D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE,
>>> MAKEFOURCC('D','F','2','4'))))
>>> > + {
>>> > + skip("No DF24 support, skipping FETCH4 test.\n");
>>> > + goto done;
>>> > + }
>>> > + 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), "GetDeviceCaps failed, hr %#x.\n", hr);
>>> > + if (caps.PixelShaderVersion < D3DPS_VERSION(3, 0))
>>> > + {
>>> > + skip("No pixel shader 3.0 support, skipping FETCH4 test.\n");
>>> > + IDirect3DDevice9_Release(device);
>>> > + goto done;
>>> > + }
>>> > + hr = IDirect3DDevice9_GetRenderTarget(device, 0, &original_rt);
>>> > + ok(SUCCEEDED(hr), "GetRenderTarget failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_GetDepthStencilSurface(device,
>>> &original_ds);
>>> > + ok(SUCCEEDED(hr), "GetDepthStencilSurface failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_CreateRenderTarget(device, 8, 8,
>>> D3DFMT_A8R8G8B8,
>>> > + D3DMULTISAMPLE_NONE, 0, FALSE, &rt, NULL);
>>> > + ok(SUCCEEDED(hr), "CreateRenderTarget failed, hr %#x.\n", hr);
>>> > +
>>> > + /* Create our texture for FETCH4 shader testing */
>>> > + hr = IDirect3DDevice9_CreateTexture(device, 4, 4, 1, 0,
>>> D3DFMT_L8, D3DPOOL_MANAGED, &texture, NULL);
>>> > + ok(hr == D3D_OK, "Failed to create texture, hr %#x.\n", hr);
>>> > + hr = IDirect3DTexture9_LockRect(texture, 0, &lr, NULL, 0);
>>> > + ok(hr == D3D_OK, "Failed to lock texture, hr %#x.\n", hr);
>>> > + for (i = 0; i < ARRAY_SIZE(fetch4_data); ++i)
>>> > + memcpy((BYTE *)lr.pBits + i*lr.Pitch, &fetch4_data[i],
>>> sizeof(fetch4_data[i]));
>>> > + hr = IDirect3DTexture9_UnlockRect(texture, 0);
>>> > + ok(hr == D3D_OK, "Failed to unlock texture, hr %#x.\n", hr);
>>> > +
>>> > + /* Create vertex shader */
>>> > + hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vs);
>>> > + ok(hr == D3D_OK, "IDirect3DDevice9_CreateVertexShader returned
>>> %08x\n", hr);
>>> > + /* Prepare the pixel shaders */
>>> > + for (i = 0; i < ARRAY_SIZE(shaders); ++i)
>>> > + {
>>> > + if (shaders[i].ps_code)
>>> > + {
>>> > + hr = IDirect3DDevice9_CreatePixelShader(device,
>>> shaders[i].ps_code, &shaders[i].ps);
>>> > + ok(SUCCEEDED(hr), "CreatePixelShader failed, hr %#x.\n",
>>> hr);
>>> > + /* Copy vertex shader pointer if a PS is present */
>>> > + shaders[i].vs = vs;
>>> > + }
>>> > + }
>>> > + hr = IDirect3DDevice9_CreatePixelShader(device, ps_code_3d,
>>> &ps_3d);
>>> > + ok(SUCCEEDED(hr), "CreatePixelShader failed, hr %#x.\n", hr);
>>> > +
>>> > + hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1 |
>>> D3DFVF_TEXCOORDSIZE3(0));
>>> > + ok(SUCCEEDED(hr), "SetFVF failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE,
>>> D3DZB_TRUE);
>>> > + ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZFUNC,
>>> D3DCMP_ALWAYS);
>>> > + ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZWRITEENABLE,
>>> TRUE);
>>> > + ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_LIGHTING,
>>> FALSE);
>>> > + ok(SUCCEEDED(hr), "SetRenderState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0,
>>> (IDirect3DBaseTexture9 *)texture);
>>> > + ok(hr == D3D_OK, "Failed to set texture, hr %#x.\n", hr);
>>> > +
>>> > + /* According to the spec, FETCH4 is enabled when
>>> D3DSAMP_MIPMAPLODBIAS == GET4 and also
>>> > + * D3DSAMP_MAGFILTER == D3DTEXF_POINT. But apparently only GET4
>>> is needed for it to get active.
>>> > + * However, AMD HW r500 samples always as if POINT (nearest
>>> filtering) is selected with FETCH4
>>> > + * the driver later on corrected this by adding -0.5 texel coord.
>>> */
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> D3DSAMP_MIPMAPLODBIAS, MAKEFOURCC('G','E','T','4'));
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> D3DSAMP_MAGFILTER, D3DTEXF_POINT);
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> D3DSAMP_MINFILTER, D3DTEXF_POINT);
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> D3DSAMP_MIPFILTER, D3DTEXF_POINT);
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
>>> > +
>>> > +
>>> /***********************************************************************
>>> > + * Tests for FFP/PS correctness when using L8 texture with
>>> fetch4. *
>>> > +
>>> ***********************************************************************/
>>> > +
>>> > + /* Render with fetch4 and test if we obtain proper results for
>>> all sampler FFP/PS instructions */
>>> > + for (i = 0; i < ARRAY_SIZE(shaders); ++i)
>>> > + {
>>> > + hr = IDirect3DDevice9_SetVertexShader(device, shaders[i].vs);
>>> > + ok(SUCCEEDED(hr), "Failed to set vertex shader, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_SetPixelShader(device, shaders[i].ps);
>>> > + ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr);
>>> > +
>>> > + hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET
>>> | D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
>>> > + ok(SUCCEEDED(hr), "Clear failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_BeginScene(device);
>>> > + ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_DrawPrimitiveUP(device,
>>> D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
>>> > + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_EndScene(device);
>>> > + ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
>>> > +
>>> > + get_rt_readback(original_rt, &rb);
>>> > + for (j = 0; j < ARRAY_SIZE(expected_colors.color_amd); ++j)
>>> > + {
>>> > + UINT x = expected_colors.x[j % 4];
>>> > + UINT y = expected_colors.y[j / 4];
>>> > + D3DCOLOR color = get_readback_color(&rb, x, y);
>>> > + D3DCOLOR color_amd =
>>> expected_colors.color_amd[shaders[i].projection ? (j/4/2*4 + (j%4)/2) : j];
>>> > + D3DCOLOR color_intel = expected_colors.color_intel[j];
>>> > + ok(color_match(color, color_amd, 1)
>>> > + || (isWin && (color_match(color, color_intel, 1)
>>> || shaders[i].allow_off)),
>>> > + "Test %s Expected color 0x%08x at (%u, %u), got
>>> 0x%08x.\n", shaders[i].name,
>>> > + color_amd, x, y, color);
>>> > + }
>>> > + release_surface_readback(&rb);
>>> > +
>>> > + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
>>> > + ok(SUCCEEDED(hr), "Present failed, hr %#x.\n", hr);
>>> > + }
>>> > +
>>> > +
>>> /***************************************************************************
>>> > + * Tests for fetch4 enable/disable with different texture formats
>>> in FFP/PS. *
>>> > +
>>> ***************************************************************************/
>>> > +
>>> > + /* Create the textures to test FETCH4 does work/not work there as
>>> expected */
>>> > + for (i = 0; i < ARRAY_SIZE(format_tests); ++i)
>>> > + {
>>> > + IDirect3DTexture9 *tex;
>>> > + hr = IDirect3DDevice9_CreateTexture(device, 2, 2, 1, 0,
>>> format_tests[i].format,
>>> > + D3DPOOL_MANAGED, &tex, NULL);
>>> > + ok(hr == D3D_OK, "Failed to create texture, hr %#x.\n", hr);
>>> > + hr = IDirect3DTexture9_LockRect(tex, 0, &lr, NULL, 0);
>>> > + ok(hr == D3D_OK, "Failed to lock texture, hr %#x.\n", hr);
>>> > + memcpy(lr.pBits, &format_tests[i].data, 4);
>>> > + hr = IDirect3DTexture9_UnlockRect(tex, 0);
>>> > + ok(hr == D3D_OK, "Failed to unlock texture, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0,
>>> (IDirect3DBaseTexture9 *)tex);
>>> > + ok(hr == D3D_OK, "Failed to set texture, hr %#x.\n", hr);
>>> > +
>>> > + /* Test if FETCH4 is enabled/disabled when different textures
>>> are used with FFP/texld/texldp */
>>> > + for (j = 0; j < ARRAY_SIZE(format_tests[i].color_amd); ++j)
>>> > + {
>>> > + hr = IDirect3DDevice9_SetVertexShader(device,
>>> shaders[j].vs);
>>> > + ok(SUCCEEDED(hr), "Failed to set vertex shader, hr
>>> %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetPixelShader(device,
>>> shaders[j].ps);
>>> > + ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr);
>>> > +
>>> > + hr = IDirect3DDevice9_Clear(device, 0, NULL,
>>> D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
>>> > + ok(SUCCEEDED(hr), "Clear failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_BeginScene(device);
>>> > + ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_DrawPrimitiveUP(device,
>>> D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
>>> > + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_EndScene(device);
>>> > + ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
>>> > +
>>> > + get_rt_readback(original_rt, &rb);
>>> > + D3DCOLOR color = get_readback_color(&rb,
>>> format_tests[i].x, format_tests[i].y);
>>> > + D3DCOLOR color_amd = format_tests[i].color_amd[j];
>>> > + D3DCOLOR color_intel = format_tests[i].color_intel[j];
>>> > + todo_wine_if(format_tests[i].broken_wine)
>>> ok(color_match(color, color_amd, 1)
>>> > + || (isWin && color_match(color, color_intel, 1)),
>>> > + "Test %d,%s expected color 0x%08x at (%u, %u),
>>> got 0x%08x.\n", i, shaders[j].name,
>>> > + color_amd, format_tests[i].x, format_tests[i].y,
>>> color);
>>> > + release_surface_readback(&rb);
>>> > +
>>> > + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL,
>>> NULL);
>>> > + ok(SUCCEEDED(hr), "Present failed, hr %#x.\n", hr);
>>> > + }
>>> > + IDirect3DTexture9_Release(tex);
>>> > + }
>>> > +
>>> > + /**************************************************
>>> > + * Tests that fetch4 works with 3D textures. *
>>> > + **************************************************/
>>> > +
>>> > + /* Create volume (3D) texture */
>>> > + IDirect3DDevice9_CreateVolumeTexture(device, 4, 4, 2, 1, 0,
>>> D3DFMT_L8, D3DPOOL_MANAGED, &texture3D, NULL );
>>> > + ok(hr == D3D_OK, "Failed to create volume texture, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DVolumeTexture9_LockBox(texture3D, 0, &lb, NULL, 0);
>>> > + ok(hr == D3D_OK, "Failed to lock texture3D, hr %#x.\n", hr);
>>> > + for (i = 0; i < ARRAY_SIZE(fetch4_data); ++i)
>>> > + {
>>> > + memcpy((BYTE *)lb.pBits + i*lb.RowPitch, &fetch4_data[i],
>>> sizeof(fetch4_data[i]));
>>> > + /* Shift the lower level, to keep it different */
>>> > + memcpy((BYTE *)lb.pBits + i*lb.RowPitch + lb.SlicePitch,
>>> &fetch4_data[(i+1)%4], sizeof(fetch4_data[i]));
>>> > + }
>>> > + hr = IDirect3DVolumeTexture9_UnlockBox(texture3D, 0);
>>> > + ok(hr == D3D_OK, "Failed to unlock texture3D, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0,
>>> (IDirect3DBaseTexture9 *)texture3D);
>>> > + ok(hr == D3D_OK, "Failed to set texture3D, hr %#x.\n", hr);
>>> > +
>>> > + /* Test FFP and texld with dcl_volume (ps_3d) */
>>> > + for (i = 0; i < 2; ++i)
>>> > + {
>>> > + hr = IDirect3DDevice9_SetVertexShader(device, i ? vs : NULL);
>>> > + ok(SUCCEEDED(hr), "Failed to set vertex shader, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_SetPixelShader(device, i ? ps_3d :
>>> NULL);
>>> > + ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr);
>>> > +
>>> > + hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET
>>> | D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
>>> > + ok(SUCCEEDED(hr), "Clear failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_BeginScene(device);
>>> > + ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_DrawPrimitiveUP(device,
>>> D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
>>> > + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_EndScene(device);
>>> > + ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
>>> > + get_rt_readback(original_rt, &rb);
>>> > + for (j = 0; j < ARRAY_SIZE(expected_colors.color_amd); ++j)
>>> > + {
>>> > + UINT x = expected_colors.x[j % 4];
>>> > + UINT y = expected_colors.y[j / 4];
>>> > + D3DCOLOR color = get_readback_color(&rb, x, y);
>>> > + D3DCOLOR color_amd = expected_colors.color_amd[j];
>>> > + D3DCOLOR color_intel = expected_colors.color_intel[j];
>>> > + D3DCOLOR color_off =
>>> expected_colors.color_3d_fetch4_off[j];
>>> > + D3DCOLOR color_zround = expected_colors.color_amd[(j+4) %
>>> ARRAY_SIZE(expected_colors.color_amd)];
>>> > + /* FIXME: Fetch4 on 3D textures have different results
>>> based on the vendor/driver
>>> > + * - AMD "HD 5700" rounds to nearest "z" texel, and does
>>> fetch4 normally on .xy
>>> > + * - AMD "R500" has fetch4 disabled
>>> > + * - AMD "R580" has fetch4 enabled sampling at .xy0
>>> > + * - Intel UHD 620 sample with fetch4 at .xy0
>>> > + * Currently unimplemented on wine due to lack of GL
>>> functionality to cast 3D->2DArray
>>> > + * Wine produces same results as if fetch4 is not enabled
>>> (which probably is better)
>>> > + * Test will pass on windows if either one of the allowed
>>> results is returned */
>>> > + if(isWin)
>>> > + ok(color_match(color, color_zround, 2) ||
>>> color_match(color, color_off, 2)
>>> > + || color_match(color, color_intel, 2) ||
>>> color_match(color, color_amd, 2),
>>> > + "Test 3D %s Expected colors 0x%08x || 0x%08x
>>> || 0x%08x || 0x%08x at (%u, %u), got 0x%08x.\n",
>>> > + shaders[i].name, color_amd, color_zround,
>>> color_off, color_intel, x, y, color);
>>> > + else
>>> > + ok(color_match(color, color_off, 2),
>>> > + "Test 3D %s Expected color 0x%08x at (%u,
>>> %u), got 0x%08x.\n", shaders[i].name,
>>> > + color_off, x, y, color);
>>> > + }
>>> > + release_surface_readback(&rb);
>>> > + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL);
>>> > + ok(SUCCEEDED(hr), "Present failed, hr %#x.\n", hr);
>>> > + }
>>> > +
>>> > + /********************************************************
>>> > + * Tests for fetch4 enable/disable with depth textures. *
>>> > + ********************************************************/
>>> > +
>>> > + for (i = 0; i < ARRAY_SIZE(depth_tests); ++i)
>>> > + {
>>> > + D3DFORMAT format = depth_tests[i].format;
>>> > + IDirect3DTexture9 *depth_texture;
>>> > + IDirect3DSurface9 *ds;
>>> > +
>>> > + if (FAILED(IDirect3D9_CheckDeviceFormat(d3d,
>>> D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
>>> > + D3DFMT_X8R8G8B8, D3DUSAGE_DEPTHSTENCIL,
>>> D3DRTYPE_TEXTURE, format)))
>>> > + continue;
>>> > +
>>> > + hr = IDirect3DDevice9_CreateTexture(device, 8, 8, 1,
>>> > + D3DUSAGE_DEPTHSTENCIL, format, D3DPOOL_DEFAULT,
>>> &depth_texture, NULL);
>>> > + ok(SUCCEEDED(hr), "CreateTexture failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DTexture9_GetSurfaceLevel(depth_texture, 0, &ds);
>>> > + ok(SUCCEEDED(hr), "GetSurfaceLevel failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetDepthStencilSurface(device, ds);
>>> > + ok(SUCCEEDED(hr), "SetDepthStencilSurface failed, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_SetRenderTarget(device, 0, rt);
>>> > + ok(SUCCEEDED(hr), "SetRenderTarget failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetVertexShader(device, NULL);
>>> > + ok(SUCCEEDED(hr), "Failed to set vertex shader, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_SetPixelShader(device, NULL);
>>> > + ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0,
>>> (IDirect3DBaseTexture9 *)texture);
>>> > + ok(hr == D3D_OK, "Failed to set texture3D, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> > + D3DSAMP_MIPMAPLODBIAS, MAKEFOURCC('G','E','T','1'));
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
>>> > +
>>> > + /* Setup the depth/stencil surface. */
>>> > + hr = IDirect3DDevice9_Clear(device, 0, NULL,
>>> D3DCLEAR_ZBUFFER, 0, 0.0f, 0);
>>> > + ok(SUCCEEDED(hr), "Clear failed, hr %#x.\n", hr);
>>> > +
>>> > + /* Render to the depth surface */
>>> > + hr = IDirect3DDevice9_BeginScene(device);
>>> > + ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_DrawPrimitiveUP(device,
>>> D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
>>> > + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_EndScene(device);
>>> > + ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
>>> > +
>>> > + hr = IDirect3DDevice9_SetDepthStencilSurface(device, NULL);
>>> > + ok(SUCCEEDED(hr), "SetDepthStencilSurface failed, hr %#x.\n",
>>> hr);
>>> > + IDirect3DSurface9_Release(ds);
>>> > + hr = IDirect3DDevice9_SetRenderTarget(device, 0, original_rt);
>>> > + ok(SUCCEEDED(hr), "SetRenderTarget failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0,
>>> (IDirect3DBaseTexture9 *)depth_texture);
>>> > + ok(SUCCEEDED(hr), "SetTexture failed, hr %#x.\n", hr);
>>> > +
>>> > + /* Set a shader for depth sampling, otherwise windows does
>>> not show anything */
>>> > + hr = IDirect3DDevice9_SetVertexShader(device, vs);
>>> > + ok(SUCCEEDED(hr), "Failed to set vertex shader, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_SetPixelShader(device, shaders[1].ps);
>>> /* same as texld */
>>> > + ok(SUCCEEDED(hr), "SetPixelShader failed, hr %#x.\n", hr);
>>> > +
>>> > + for (j = 0; j < 2; ++j){
>>> > + hr = IDirect3DDevice9_SetSamplerState(device, 0,
>>> > + D3DSAMP_MIPMAPLODBIAS, MAKEFOURCC('G','E','T', j
>>> ? '4' : '1' ));
>>> > + ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n",
>>> hr);
>>> > +
>>> > + /* Do the actual shadow mapping. */
>>> > + hr = IDirect3DDevice9_BeginScene(device);
>>> > + ok(SUCCEEDED(hr), "BeginScene failed, hr %#x.\n", hr);
>>> > + hr = IDirect3DDevice9_DrawPrimitiveUP(device,
>>> D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad));
>>> > + ok(SUCCEEDED(hr), "DrawPrimitiveUP failed, hr %#x.\n",
>>> hr);
>>> > + hr = IDirect3DDevice9_EndScene(device);
>>> > + ok(SUCCEEDED(hr), "EndScene failed, hr %#x.\n", hr);
>>> > +
>>> > + get_rt_readback(original_rt, &rb);
>>> > + for (k = 0; k <
>>> ARRAY_SIZE(expected_depth[depth_tests[i].index]); ++k)
>>> > + {
>>> > + UINT x = expected_depth[depth_tests[i].index][k].x;
>>> > + UINT y = expected_depth[depth_tests[i].index][k].y;
>>> > + D3DCOLOR color_off =
>>> expected_depth[depth_tests[i].index][k].color_off;
>>> > + D3DCOLOR color_amd =
>>> expected_depth[depth_tests[i].index][k].color_amd;
>>> > + D3DCOLOR color_intel =
>>> expected_depth[depth_tests[i].index][k].color_intel;
>>> > + D3DCOLOR color = get_readback_color(&rb, x, y);
>>> > + /* When Fetch4 is OFF, ignore G and B channels on
>>> windows.
>>> > + * Some implementations will copy R=G=B, some will
>>> set them to 0 */
>>> > + if(j == 0)
>>> > + ok((isWin && color_match(color & 0xffff0000,
>>> color_off & 0xffff0000, 2))
>>> > + || color_match(color, color_off, 2),
>>> > + "Test OFF Expected color 0x%08x at (%u,
>>> %u) for format %s, got 0x%08x.\n",
>>> > + color_off, x, y, depth_tests[i].name,
>>> color);
>>> > + else
>>> > + ok(color_match(color, color_amd, 2)
>>> > + || (isWin && color_match(color,
>>> color_intel, 2)),
>>> > + "Test ON Expected colors 0x%08x || 0x%08x
>>> at (%u, %u) for format %s, got 0x%08x.\n",
>>> > + color_amd, color_intel, x, y,
>>> depth_tests[i].name, color);
>>> > + }
>>> > + release_surface_readback(&rb);
>>> > +
>>> > + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL,
>>> NULL);
>>> > + ok(SUCCEEDED(hr), "Present failed, hr %#x.\n", hr);
>>> > + }
>>> > +
>>> > + hr = IDirect3DDevice9_SetTexture(device, 0, NULL);
>>> > + ok(SUCCEEDED(hr), "SetTexture failed, hr %#x.\n", hr);
>>> > + IDirect3DTexture9_Release(depth_texture);
>>> > + }
>>> > +
>>> > + IDirect3DVolumeTexture9_Release(texture3D);
>>> > + IDirect3DTexture9_Release(texture);
>>> > + for (i = 0; i < ARRAY_SIZE(shaders); ++i)
>>> > + if (shaders[i].ps)
>>> > + IDirect3DPixelShader9_Release(shaders[i].ps);
>>> > + IDirect3DPixelShader9_Release(ps_3d);
>>> > + IDirect3DVertexShader9_Release(vs);
>>> > + IDirect3DSurface9_Release(rt);
>>> > + IDirect3DSurface9_Release(original_ds);
>>> > + IDirect3DSurface9_Release(original_rt);
>>> > + refcount = IDirect3DDevice9_Release(device);
>>> > + ok(!refcount, "Device has %u references left.\n", refcount);
>>> > +done:
>>> > + IDirect3D9_Release(d3d);
>>> > + DestroyWindow(window);
>>> > +}
>>> > +
>>> > static void shadow_test(void)
>>> > {
>>> > static const DWORD ps_code[] =
>>> > @@ -24660,6 +25303,7 @@ START_TEST(visual)
>>> > depth_buffer2_test();
>>> > depth_blit_test();
>>> > intz_test();
>>> > + fetch4_test();
>>> > shadow_test();
>>> > fp_special_test();
>>> > depth_bounds_test();
>>>
>>>
>>>
>>>
>>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.winehq.org/pipermail/wine-devel/attachments/20190204/16aca085/attachment-0001.html>
More information about the wine-devel
mailing list