26 Feb
2019
26 Feb
'19
8:13 p.m.
Hi,
This version passes on all 3 of my Radeons!
Stefan
Am 25.02.19 um 00:44 schrieb Daniel Ansorregui:
- Test fetch4 with point filtering and wrapping mode = clamp
- Test texld/texldp/texldd/texldb/texldl in PS and FFP
- Test FFP D3DTTFF projection works on fetch4 with COUNT3/COUNT4
- Test supported/unsupported texture formats on FFP/texld/texldp
- Test 3dtextures (Disabled on wine, each platform has different results)
- Test depth textures, DF16/DF24/INTZ with fetch4 on PS (FFP is broken on windows)
Signed-off-by: Daniel Ansorregui mailszeros@gmail.com
dlls/d3d9/tests/visual.c | 714 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 714 insertions(+)
diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index 52d67c8199..7448fae257 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -15396,6 +15396,719 @@ 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 *//* The idea here is that if we project from z, we get a 4x zoom. From w a 2x zoom */0x05000051, 0xa00f0000, 0x00000000, 0x00000000, 0x40800000, 0x40000000, /* def c0, 0.0, 0.0, 4.0, 2.0 */0x02000001, 0x80030000, 0x90f40000, /* mov r0.xy, v0.xyww */0x02000001, 0x800c0000, 0xa0e00000, /* mov r0.zw, c0.xxzw */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 DWORD ps_code_swizzle[] =
- {
/* Test texld when sampling with a swizzle .yzwx*/0xffff0300, /* ps_3_0 */0x0200001f, 0x80000005, 0x900f0000, /* dcl_texcoord v0 */0x0200001f, 0x90000000, 0xa00f0800, /* dcl_2d s0 */0x03000042, 0x800f0000, 0x90e40000, 0xa0390800, /* texld r0, v0, s0.yzwx */0x02000001, 0x800f0800, 0x80e40000, /* mov oC0, r0 */0x0000ffff /* end */- };
- static const struct
- {
struct vec3 position;struct vec4 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,0.0f} },{{ 1.0f, 1.0f, 0.0f}, {1.0f,0.0f,0.6f,0.0f} },{{-1.0f,-1.0f, 0.0f}, {0.0f,1.0f,0.6f,0.0f} },{{ 1.0f,-1.0f, 0.0f}, {1.0f,1.0f,0.6f,0.0f} }- },
- quad_proj[] =
- {
/* Using during the PS/FFP 2D tests to test projection on z/w */{{-1.0f, 1.0f, 1.0f}, {0.0f,0.0f,4.0f,2.0f} },{{ 1.0f, 1.0f, 0.0f}, {1.0f,0.0f,4.0f,2.0f} },{{-1.0f,-1.0f, 0.0f}, {0.0f,1.0f,4.0f,2.0f} },{{ 1.0f,-1.0f, 0.0f}, {1.0f,1.0f,4.0f,2.0f} }- };
- 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 wit0x3f800000h no texel coord correction *//* Wine follows the AMD implementation, 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];D3DCOLOR color_3d_amd_zround[16];- }
- expected_colors =
- {
{ 40, 200, 360, 520},{ 30, 150, 270, 390},/* AMD implementation - Wine implementation */{0x131202f2, 0x1211f2f1, 0x1110f101, 0x10100101,0x02f204f4, 0xf2f1f4f3, 0xf101f303, 0x01010303,0x04f42322, 0xf4f32221, 0xf3032120, 0x03032020,0x23222322, 0x22212221, 0x21202120, 0x20202020},/* Intel UHD 620 implementation */{0x13131313, 0x12131312, 0x11121211, 0x10111110,0x13021302, 0x120213f2, 0x11f212f1, 0x10f11101,0x02040204, 0xf20402f4, 0xf1f4f2f3, 0x01f3f103,0x04230423, 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},/* Fetch4 on, 3d texture withou nearest z rounding */{0x02f204f4, 0xf2f1f4f3, 0xf101f303, 0x01010303,0x04f42322, 0xf4f32221, 0xf3032120, 0x03032020,0x23221312, 0x22211211, 0x21201110, 0x20201010,0x13121312, 0x12111211, 0x11101110, 0x10101010}- };
- static const DWORD fetch4_data[] = {0x10111213,
0x01f1f202,0x03f3f404,0x20212223};- static struct
- {
IDirect3DVertexShader9 *vs;IDirect3DPixelShader9 *ps;const DWORD *ps_code;const char *name;UINT projection; /* The results should be projected (zoomed by the value) */BOOL swizzled; /* The result will be shifted by the swizzle */DWORD ttff_flags; /* For FFP projection check */- }
- shaders[] =
- {
{NULL, NULL, NULL, "FFP", 0, FALSE, 0},{NULL, NULL, ps_code_texld, "texld", 0, FALSE, 0},{NULL, NULL, ps_code_texldp, "texldp", 2, FALSE, 0},{NULL, NULL, ps_code_texldd, "texldd", 0, FALSE, 0},{NULL, NULL, ps_code_texldb, "texldb", 0, FALSE, 0},{NULL, NULL, ps_code_texldl, "texldl", 0, FALSE, 0},{NULL, NULL, ps_code_swizzle, "texld_yzwx", 0, TRUE, 0},{NULL, NULL, NULL, "FFP_proj", 2, FALSE, D3DTTFF_PROJECTED},{NULL, NULL, NULL, "FFP_proj3", 4, FALSE, D3DTTFF_COUNT3 | D3DTTFF_PROJECTED},- };
- static const struct
- {
BOOL todo_in_wine; /* Do not check thorougly on wine because is known to be wrong */const char *name; /* The name of the texture format */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 */UINT w, h; /* Texture size */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 */{FALSE, "L8", D3DFMT_L8,0xff804010, 360, 30, 2, 2,{0x40400000, 0x40400000, 0x10400000},{0x40101040, 0x40101040, 0x40101040}},{FALSE, "L16", D3DFMT_L16,0xff804010, 360, 30, 2, 2,{0xffff0000, 0xffff0000, 0x40ff0000},{0xff4040ff, 0xff4040ff, 0xff4040ff}},{FALSE, "R16F", D3DFMT_R16F,0x38003c00, 360, 30, 2, 2,{0x80800000, 0x80800000, 0xff800000},{0x80ffff80, 0x80ffff80, 0x80ffff80}},{FALSE, "R32F", D3DFMT_R32F,0x3f000000, 360, 30, 2, 2,{0x00000000, 0x00000000, 0x80000000},{0x00808000, 0x00808000, 0x00808000}},{FALSE, "ATI1", MAKEFOURCC('A','T','I','1'),0xb97700ff, 360, 30, 4, 4,{0x6d6d6d6d, 0x6d6d6d6d, 0x49494949},{0xff6d00ff, 0xff6d00ff, 0xff4900ff}},/* Disabled format on Intel, enabled on AMD, broken on wine* since it is implemented with GL_ALPHA, and fetch4 will fetch RED value */{TRUE, "A8", D3DFMT_A8,0xff804010, 360, 30, 2, 2,{0x40400000, 0x40400000, 0x10400000},{0x00000000, 0x00000000, 0x00000000}},/* Disabled format */{FALSE, "A8R8G8B8", D3DFMT_A8R8G8B8,0xff804010, 360, 270, 2, 2,{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,0xffffffff, 20, 15},{0xff9f0000,0x9f7f7f5f,0x9fbfbf9f,260, 15},{0xff800000,0x7f5f5f3f,0x9f809f80, 20,255},{0xff600000,0x5f3f3f1f,0x80809f60,260,135},},{/* This is the expected result with DF24 */{0xffff0000,0xffdfdfbf,0xffffffff, 20, 15},{0xff9f0000,0x9f7f7f5f,0x9fbfbf9f,260, 15},{0xff800000,0x7f5f5f3f,0x9f809f80, 20,255},{0xff600000,0x5f3f3f1f,0x80809f60,260,135},},{/* This is the expected result with INTZ */{0xffffffff,0xffdfdfbf,0xffffffff, 20, 15},{0x9f9f9f9f,0x9f7f7f5f,0x9fbfbf9f,260, 15},{0x7f7f7f7f,0x7f5f5f3f,0x9f809f80, 20,255},{0x5f5f5f5f,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},{MAKEFOURCC('I','N','T','Z'), "INTZ", 3},- };
- IDirect3DSurface9 *original_ds, *original_rt, *rt;
- IDirect3DVertexShader9 *vs, *vs_proj;
- IDirect3DVolumeTexture9 *texture3D;
- IDirect3DPixelShader9 *ps_3d;
- struct surface_readback rb;
- 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 shaders */
- 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_TEXCOORDSIZE4(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);
- /* Fetch4 should work with any texture wrapping mode, and does in wine.
* However RX 580 devices forces clamping when fetch4 in on* No other driver/HW does it, but to avoid problems, we test with CLAMP on */- hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
- ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
- hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
- ok(SUCCEEDED(hr), "SetSamplerState failed, hr %#x.\n", hr);
- hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);
- 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_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, shaders[i].ttff_flags);ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\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_proj, sizeof(*quad_proj));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/shaders[i].projection*4 + (j%4)/shaders[i].projection) : j];D3DCOLOR color_intel = expected_colors.color_intel[j];D3DCOLOR color_off = expected_colors.color_fetch4_off[j];if (shaders[i].swizzled)color_amd = ((color_amd << 8) & 0xffffff00) + ((color_amd >> 24) & 0x000000ff);/* In some AMD cards (HD5700) texldd/texldl have fetch4 off on windows */ok(color_match(color, color_amd, 1) || broken(color_match(color, color_intel, 1))|| broken(color_match(color, color_off, 1)),"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);- }
- hr = IDirect3DDevice9_SetTextureStageState(device, 0, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
- ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTextureStageState failed (%08x)\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, format_tests[i].w, format_tests[i].h,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){D3DCOLOR color_amd = format_tests[i].color_amd[j];D3DCOLOR color_intel = format_tests[i].color_intel[j];D3DCOLOR color;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);color = get_readback_color(&rb, format_tests[i].x, format_tests[i].y);/* On windows just test the R channel, since G/B might be 0xff or 0x00 */todo_wine_if(format_tests[i].todo_in_wine) ok(color_match(color, color_amd, 2)|| broken(color_match(color, color_intel, 2))|| broken(color_match(color & 0x00ff0000, color_amd & 0x00ff0000, 2)),"Test %s on %s expected color 0x%08x at (%u, %u), got 0x%08x.\n", format_tests[i].name,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_3d_amd_zround[j];/* Note: 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 */ok(color_match(color, color_off, 2)|| broken(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 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))){skip("Skipping %s depth test, unsuported format.\n", depth_tests[i].name);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(color_match(color, color_off, 2)|| broken(color_match(color & 0x00ff0000, color_off & 0x00ff0000, 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);elseok(color_match(color, color_amd, 2)|| broken(color_match(color, color_intel, 2)),"Test ON Expected colors 0x%08x at (%u, %u) for format %s, got 0x%08x.\n",color_amd, 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[] = @@ -24849,6 +25562,7 @@ START_TEST(visual) depth_buffer2_test(); depth_blit_test(); intz_test();
- fetch4_test(); shadow_test(); fp_special_test(); depth_bounds_test();