From 0c9713bb65ca679c701123fc07b79883fc6d4e07 Mon Sep 17 00:00:00 2001 From: Henri Verbeet Date: Fri, 11 Jan 2013 12:07:50 +0100 Subject: [PATCH] d3d9/tests: Merge texture.c into device.c. --- dlls/d3d9/tests/Makefile.in | 1 - dlls/d3d9/tests/device.c | 540 ++++++++++++++++++++++++++++++++++++ dlls/d3d9/tests/texture.c | 452 ------------------------------ 3 files changed, 540 insertions(+), 453 deletions(-) delete mode 100644 dlls/d3d9/tests/texture.c diff --git a/dlls/d3d9/tests/Makefile.in b/dlls/d3d9/tests/Makefile.in index 58820a0aee3..fd0b5614090 100644 --- a/dlls/d3d9/tests/Makefile.in +++ b/dlls/d3d9/tests/Makefile.in @@ -6,7 +6,6 @@ C_SRCS = \ device.c \ stateblock.c \ surface.c \ - texture.c \ vertexdeclaration.c \ visual.c diff --git a/dlls/d3d9/tests/device.c b/dlls/d3d9/tests/device.c index 8456964d8f0..9b2858d9a33 100644 --- a/dlls/d3d9/tests/device.c +++ b/dlls/d3d9/tests/device.c @@ -4490,6 +4490,540 @@ float4 main(const float4 color : COLOR) : SV_TARGET DestroyWindow(window); } +/* Test the default texture stage state values */ +static void test_texture_stage_states(void) +{ + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + unsigned int i; + ULONG refcount; + D3DCAPS9 caps; + DWORD value; + HWND window; + HRESULT hr; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); + ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr); + + for (i = 0; i < caps.MaxTextureBlendStages; ++i) + { + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_COLOROP, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == (i ? D3DTOP_DISABLE : D3DTOP_MODULATE), + "Got unexpected value %#x for D3DTSS_COLOROP, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_COLORARG1, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_TEXTURE, "Got unexpected value %#x for D3DTSS_COLORARG1, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_COLORARG2, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_CURRENT, "Got unexpected value %#x for D3DTSS_COLORARG2, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_ALPHAOP, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == (i ? D3DTOP_DISABLE : D3DTOP_SELECTARG1), + "Got unexpected value %#x for D3DTSS_ALPHAOP, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_ALPHAARG1, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_TEXTURE, "Got unexpected value %#x for D3DTSS_ALPHAARG1, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_ALPHAARG2, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_CURRENT, "Got unexpected value %#x for D3DTSS_ALPHAARG2, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVMAT00, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVMAT00, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVMAT01, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVMAT01, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVMAT10, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVMAT10, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVMAT11, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVMAT11, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_TEXCOORDINDEX, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == i, "Got unexpected value %#x for D3DTSS_TEXCOORDINDEX, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVLSCALE, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVLSCALE, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_BUMPENVLOFFSET, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_BUMPENVLOFFSET, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_TEXTURETRANSFORMFLAGS, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTTFF_DISABLE, + "Got unexpected value %#x for D3DTSS_TEXTURETRANSFORMFLAGS, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_COLORARG0, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_CURRENT, "Got unexpected value %#x for D3DTSS_COLORARG0, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_ALPHAARG0, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_CURRENT, "Got unexpected value %#x for D3DTSS_ALPHAARG0, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_RESULTARG, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(value == D3DTA_CURRENT, "Got unexpected value %#x for D3DTSS_RESULTARG, stage %u.\n", value, i); + hr = IDirect3DDevice9_GetTextureStageState(device, i, D3DTSS_CONSTANT, &value); + ok(SUCCEEDED(hr), "Failed to get texture stage state, hr %#x.\n", hr); + ok(!value, "Got unexpected value %#x for D3DTSS_CONSTANT, stage %u.\n", value, i); + } + + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + +static void test_cube_texture_mipmap_gen(IDirect3DDevice9 *device) +{ + IDirect3DCubeTexture9 *texture; + IDirect3D9 *d3d; + HRESULT hr; + + hr = IDirect3DDevice9_GetDirect3D(device, &d3d); + ok(SUCCEEDED(hr), "Failed to get D3D, hr %#x.\n", hr); + hr = IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, + D3DUSAGE_AUTOGENMIPMAP, D3DRTYPE_CUBETEXTURE, D3DFMT_X8R8G8B8); + IDirect3D9_Release(d3d); + if (FAILED(hr)) + { + skip("No cube mipmap generation support, skipping tests.\n"); + return; + } + + hr = IDirect3DDevice9_CreateCubeTexture(device, 64, 0, (D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP), + D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); + + hr = IDirect3DDevice9_CreateCubeTexture(device, 64, 0, D3DUSAGE_AUTOGENMIPMAP, + D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); +} + +static void test_cube_texture_levels(IDirect3DDevice9 *device) +{ + IDirect3DCubeTexture9 *texture; + IDirect3DSurface9 *surface; + D3DSURFACE_DESC desc; + DWORD levels; + HRESULT hr; + + if (FAILED(IDirect3DDevice9_CreateCubeTexture(device, 64, 0, 0, + D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL))) + { + skip("Failed to create cube texture, skipping tests.\n"); + return; + } + + levels = IDirect3DCubeTexture9_GetLevelCount(texture); + ok(levels == 7, "Got unexpected levels %u.\n", levels); + + hr = IDirect3DCubeTexture9_GetLevelDesc(texture, levels - 1, &desc); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DCubeTexture9_GetLevelDesc(texture, levels, &desc); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DCubeTexture9_GetLevelDesc(texture, levels + 1, &desc); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture, D3DCUBEMAP_FACE_POSITIVE_X, 0, &surface); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + IDirect3DSurface9_Release(surface); + hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture, D3DCUBEMAP_FACE_NEGATIVE_Z + 1, 0, &surface); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture, D3DCUBEMAP_FACE_POSITIVE_X - 1, 0, &surface); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + + IDirect3DCubeTexture9_Release(texture); +} + +static void test_cube_textures(void) +{ + IDirect3DCubeTexture9 *texture; + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + ULONG refcount; + D3DCAPS9 caps; + HWND window; + HRESULT hr; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); + ok(SUCCEEDED(hr), "Failed to get device caps, hr %#x.\n", hr); + + if (caps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP) + { + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); + ok(hr == D3D_OK, "Failed to create D3DPOOL_DEFAULT cube texture, hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL); + ok(hr == D3D_OK, "Failed to create D3DPOOL_MANAGED cube texture, hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &texture, NULL); + ok(hr == D3D_OK, "Failed to create D3DPOOL_SYSTEMMEM cube texture, hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); + } + else + { + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x for D3DPOOL_DEFAULT cube texture.\n", hr); + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x for D3DPOOL_MANAGED cube texture.\n", hr); + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &texture, NULL); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x for D3DPOOL_SYSTEMMEM cube texture.\n", hr); + } + hr = IDirect3DDevice9_CreateCubeTexture(device, 512, 1, 0, D3DFMT_X8R8G8B8, D3DPOOL_SCRATCH, &texture, NULL); + ok(hr == D3D_OK, "Failed to create D3DPOOL_SCRATCH cube texture, hr %#x.\n", hr); + IDirect3DCubeTexture9_Release(texture); + + test_cube_texture_mipmap_gen(device); + test_cube_texture_levels(device); + + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + +static void test_mipmap_gen(void) +{ + D3DTEXTUREFILTERTYPE filter_type; + IDirect3DTexture9 *texture; + IDirect3DSurface9 *surface; + IDirect3DDevice9 *device; + D3DSURFACE_DESC desc; + D3DLOCKED_RECT lr; + IDirect3D9 *d3d; + ULONG refcount; + unsigned int i; + DWORD levels; + HWND window; + HRESULT hr; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + if (FAILED(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, + D3DUSAGE_AUTOGENMIPMAP, D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8))) + { + skip("No mipmap generation support, skipping tests.\n"); + IDirect3D9_Release(d3d); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 0, (D3DUSAGE_RENDERTARGET | D3DUSAGE_AUTOGENMIPMAP), + D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + IDirect3DTexture9_Release(texture); + + hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 0, D3DUSAGE_AUTOGENMIPMAP, + D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + filter_type = IDirect3DTexture9_GetAutoGenFilterType(texture); + ok(filter_type == D3DTEXF_LINEAR /* || broken(filter_type == D3DTEXF_POINT)*/, + "Got unexpected filter_type %#x.\n", filter_type); + hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_NONE); + todo_wine ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_ANISOTROPIC); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + filter_type = IDirect3DTexture9_GetAutoGenFilterType(texture); + ok(filter_type == D3DTEXF_ANISOTROPIC, "Got unexpected filter_type %#x.\n", filter_type); + hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_LINEAR); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + levels = IDirect3DTexture9_GetLevelCount(texture); + ok(levels == 1, "Got unexpected levels %u.\n", levels); + + for (i = 0; i < 6 /* 64 = 2 ^ 6 */; ++i) + { + surface = NULL; + hr = IDirect3DTexture9_GetSurfaceLevel(texture, i, &surface); + ok(hr == (i ? D3DERR_INVALIDCALL : D3D_OK), "Got unexpected hr %#x for level %u.\n", hr, i); + if (surface) + IDirect3DSurface9_Release(surface); + + hr = IDirect3DTexture9_GetLevelDesc(texture, i, &desc); + ok(hr == (i ? D3DERR_INVALIDCALL : D3D_OK), "Got unexpected hr %#x for level %u.\n", hr, i); + + hr = IDirect3DTexture9_LockRect(texture, i, &lr, NULL, 0); + ok(hr == (i ? D3DERR_INVALIDCALL : D3D_OK), "Got unexpected hr %#x for level %u.\n", hr, i); + if (SUCCEEDED(hr)) + { + hr = IDirect3DTexture9_UnlockRect(texture, i); + ok(SUCCEEDED(hr), "Failed to unlock texture, hr %#x.\n", hr); + } + } + IDirect3DTexture9_Release(texture); + + hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 2, D3DUSAGE_AUTOGENMIPMAP, + D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 6, D3DUSAGE_AUTOGENMIPMAP, + D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); + ok(hr == D3DERR_INVALIDCALL, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1, D3DUSAGE_AUTOGENMIPMAP, + D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + levels = IDirect3DTexture9_GetLevelCount(texture); + ok(levels == 1, "Got unexpected levels %u.\n", levels); + IDirect3DTexture9_Release(texture); + + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + +static void test_filter(void) +{ + static const struct + { + DWORD magfilter, minfilter, mipfilter; + BOOL has_texture; + HRESULT result; + } + tests[] = + { + {D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3D_OK }, + {D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, FALSE, D3D_OK }, + + {D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, D3D_OK }, + {D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, TRUE, D3D_OK }, + + {D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_LINEAR, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER}, + {D3DTEXF_LINEAR, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, E_FAIL }, + {D3DTEXF_POINT, D3DTEXF_LINEAR, D3DTEXF_NONE, TRUE, E_FAIL }, + {D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_LINEAR, TRUE, E_FAIL }, + }; + IDirect3DTexture9 *texture; + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + unsigned int i; + ULONG refcount; + DWORD passes; + HWND window; + HRESULT hr; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + if (FAILED(IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, + 0, D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F))) + { + skip("D3DFMT_A32B32G32R32F not supported, skipping tests.\n"); + IDirect3D9_Release(d3d); + return; + } + + if (SUCCEEDED(hr = IDirect3D9_CheckDeviceFormat(d3d, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, + D3DUSAGE_QUERY_FILTER, D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F))) + { + skip("D3DFMT_A32B32G32R32F supports filtering, skipping tests.\n"); + IDirect3D9_Release(d3d); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 0, 0, + D3DFMT_A32B32G32R32F, D3DPOOL_MANAGED, &texture, NULL); + ok(SUCCEEDED(hr), "Failed to create texture, hr %#x.\n", hr); + + /* Needed for ValidateDevice(). */ + hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1); + ok(SUCCEEDED(hr), "Failed to set fvf, hr %#x.\n", hr); + + for (i = 0; i < (sizeof(tests) / sizeof(*tests)); ++i) + { + if (tests[i].has_texture) + { + hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *)texture); + ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr); + } + else + { + hr = IDirect3DDevice9_SetTexture(device, 0, NULL); + ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr); + } + + hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, tests[i].magfilter); + ok(SUCCEEDED(hr), "Failed to set sampler state, hr %#x.\n", hr); + hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, tests[i].minfilter); + ok(SUCCEEDED(hr), "Failed to set sampler state, hr %#x.\n", hr); + hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, tests[i].mipfilter); + ok(SUCCEEDED(hr), "Failed to set sampler state, hr %#x.\n", hr); + + passes = 0xdeadbeef; + hr = IDirect3DDevice9_ValidateDevice(device, &passes); + ok(hr == tests[i].result, + "Got unexpected hr %#x, expected %#x (mag %#x, min %#x, mip %#x, has_texture %#x).\n", + hr, tests[i].result, tests[i].magfilter, tests[i].minfilter, + tests[i].mipfilter, tests[i].has_texture); + if (SUCCEEDED(hr)) + ok(!!passes, "Got unexpected passes %#x.\n", passes); + else + ok(passes == 0xdeadbeef, "Got unexpected passes %#x.\n", passes); + } + + hr = IDirect3DDevice9_SetTexture(device, 0, NULL); + ok(SUCCEEDED(hr), "Failed to set texture, hr %#x.\n", hr); + IDirect3DTexture9_Release(texture); + + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + +static void test_get_texture(void) +{ + IDirect3DBaseTexture9 *texture; + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + ULONG refcount; + HWND window; + HRESULT hr; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + texture = (IDirect3DBaseTexture9 *)0xdeadbeef; + hr = IDirect3DDevice9_SetTexture(device, 0, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_GetTexture(device, 0, &texture); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + ok(!texture, "Got unexpected texture %p.\n", texture); + + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + +static void test_lod(void) +{ + IDirect3DTexture9 *texture; + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + ULONG refcount; + HWND window; + HRESULT hr; + DWORD ret; + + if (!(d3d = pDirect3DCreate9(D3D_SDK_VERSION))) + { + skip("Failed to create D3D object, skipping tests.\n"); + return; + } + + window = CreateWindowA("d3d9_test_wc", "d3d9_test", WS_OVERLAPPEDWINDOW, + 0, 0, 640, 480, 0, 0, 0, 0); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, + D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &texture, NULL); + ok(SUCCEEDED(hr), "Failed to create texture, hr %#x.\n", hr); + + /* SetLOD() is only supported on D3DPOOL_MANAGED textures, but doesn't + * return a HRESULT, so it can't return a normal error. Instead, the call + * is simply ignored. */ + ret = IDirect3DTexture9_SetLOD(texture, 0); + ok(!ret, "Got unexpected ret %u.\n", ret); + ret = IDirect3DTexture9_SetLOD(texture, 1); + ok(!ret, "Got unexpected ret %u.\n", ret); + ret = IDirect3DTexture9_SetLOD(texture, 2); + ok(!ret, "Got unexpected ret %u.\n", ret); + ret = IDirect3DTexture9_GetLOD(texture); + ok(!ret, "Got unexpected ret %u.\n", ret); + + IDirect3DTexture9_Release(texture); + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + START_TEST(device) { HMODULE d3d9_handle = LoadLibraryA( "d3d9.dll" ); @@ -4559,6 +5093,12 @@ START_TEST(device) test_get_set_pixel_shader(); test_pixel_shader_constant(); test_wrong_shader(); + test_texture_stage_states(); + test_cube_textures(); + test_mipmap_gen(); + test_filter(); + test_get_texture(); + test_lod(); } out: diff --git a/dlls/d3d9/tests/texture.c b/dlls/d3d9/tests/texture.c deleted file mode 100644 index 8e8f27b7824..00000000000 --- a/dlls/d3d9/tests/texture.c +++ /dev/null @@ -1,452 +0,0 @@ -/* - * Copyright (C) 2006 Henri Verbeet - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - */ -#define COBJMACROS -#include -#include "wine/test.h" - -static HWND create_window(void) -{ - WNDCLASS wc = {0}; - wc.lpfnWndProc = DefWindowProc; - wc.lpszClassName = "d3d9_test_wc"; - RegisterClass(&wc); - - return CreateWindow("d3d9_test_wc", "d3d9_test", - 0, 0, 0, 0, 0, 0, 0, 0, 0); -} - -static IDirect3DDevice9 *init_d3d9(HMODULE d3d9_handle) -{ - IDirect3D9 * (__stdcall * d3d9_create)(UINT SDKVersion) = 0; - IDirect3D9 *d3d9_ptr = 0; - IDirect3DDevice9 *device_ptr = 0; - D3DPRESENT_PARAMETERS present_parameters; - HRESULT hr; - - d3d9_create = (void *)GetProcAddress(d3d9_handle, "Direct3DCreate9"); - ok(d3d9_create != NULL, "Failed to get address of Direct3DCreate9\n"); - if (!d3d9_create) return NULL; - - d3d9_ptr = d3d9_create(D3D_SDK_VERSION); - if (!d3d9_ptr) - { - skip("could not create D3D9\n"); - return NULL; - } - - ZeroMemory(&present_parameters, sizeof(present_parameters)); - present_parameters.Windowed = TRUE; - present_parameters.hDeviceWindow = create_window(); - present_parameters.SwapEffect = D3DSWAPEFFECT_DISCARD; - - hr = IDirect3D9_CreateDevice(d3d9_ptr, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, - NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &present_parameters, &device_ptr); - - if(FAILED(hr)) - { - skip("could not create device, IDirect3D9_CreateDevice returned %#x\n", hr); - return NULL; - } - - return device_ptr; -} - -static void test_texture_stage_state(IDirect3DDevice9 *device_ptr, DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD expected) -{ - DWORD value; - - HRESULT hr = IDirect3DDevice9_GetTextureStageState(device_ptr, stage, type, &value); - ok(SUCCEEDED(hr) && value == expected, "GetTextureStageState (stage %#x, type %#x) returned: hr %#x, value %#x. " - "Expected hr %#x, value %#x\n", stage, type, hr, value, D3D_OK, expected); -} - -/* Test the default texture stage state values */ -static void test_texture_stage_states(IDirect3DDevice9 *device_ptr, int num_stages) -{ - int i; - for (i = 0; i < num_stages; ++i) - { - test_texture_stage_state(device_ptr, i, D3DTSS_COLOROP, i ? D3DTOP_DISABLE : D3DTOP_MODULATE); - test_texture_stage_state(device_ptr, i, D3DTSS_COLORARG1, D3DTA_TEXTURE); - test_texture_stage_state(device_ptr, i, D3DTSS_COLORARG2, D3DTA_CURRENT); - test_texture_stage_state(device_ptr, i, D3DTSS_ALPHAOP, i ? D3DTOP_DISABLE : D3DTOP_SELECTARG1); - test_texture_stage_state(device_ptr, i, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); - test_texture_stage_state(device_ptr, i, D3DTSS_ALPHAARG2, D3DTA_CURRENT); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVMAT00, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVMAT01, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVMAT10, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVMAT11, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_TEXCOORDINDEX, i); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVLSCALE, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_BUMPENVLOFFSET, 0); - test_texture_stage_state(device_ptr, i, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE); - test_texture_stage_state(device_ptr, i, D3DTSS_COLORARG0, D3DTA_CURRENT); - test_texture_stage_state(device_ptr, i, D3DTSS_ALPHAARG0, D3DTA_CURRENT); - test_texture_stage_state(device_ptr, i, D3DTSS_RESULTARG, D3DTA_CURRENT); - test_texture_stage_state(device_ptr, i, D3DTSS_CONSTANT, 0); - } -} - -static void test_cube_texture_from_pool(IDirect3DDevice9 *device_ptr, DWORD caps, D3DPOOL pool, BOOL need_cap) -{ - IDirect3DCubeTexture9 *texture_ptr = NULL; - HRESULT hr; - - hr = IDirect3DDevice9_CreateCubeTexture(device_ptr, 512, 1, 0, D3DFMT_X8R8G8B8, pool, &texture_ptr, NULL); - - if((caps & D3DPTEXTURECAPS_CUBEMAP) || !need_cap) - ok(SUCCEEDED(hr), "hr=0x%.8x\n", hr); - else - ok(hr == D3DERR_INVALIDCALL, "hr=0x%.8x\n", hr); - - if(texture_ptr) IDirect3DCubeTexture9_Release(texture_ptr); -} - -static void test_cube_texture_mipmap_gen(IDirect3DDevice9 *device_ptr) -{ - IDirect3DCubeTexture9 *texture_ptr = NULL; - IDirect3D9 *d3d9; - HRESULT hr; - - hr = IDirect3DDevice9_GetDirect3D(device_ptr, &d3d9); - ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D returned 0x%08x\n", hr); - - hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, - D3DUSAGE_AUTOGENMIPMAP, - D3DRTYPE_CUBETEXTURE, D3DFMT_X8R8G8B8); - if(FAILED(hr)) - { - skip("No cube mipmap generation support\n"); - return; - } - - /* testing shows that autogenmipmap and rendertarget are mutually exclusive options */ - hr = IDirect3DDevice9_CreateCubeTexture(device_ptr, 64, 0, (D3DUSAGE_RENDERTARGET | - D3DUSAGE_AUTOGENMIPMAP), D3DFMT_X8R8G8B8, - D3DPOOL_DEFAULT, &texture_ptr, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned 0x%08x, expected 0x%08x\n", - hr, D3D_OK); - if (texture_ptr) IDirect3DCubeTexture9_Release(texture_ptr); - texture_ptr = NULL; - - hr = IDirect3DDevice9_CreateCubeTexture(device_ptr, 64, 0, - D3DUSAGE_AUTOGENMIPMAP, D3DFMT_X8R8G8B8, - D3DPOOL_MANAGED, &texture_ptr, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed (0x%08x)\n", hr); - if (texture_ptr) IDirect3DCubeTexture9_Release(texture_ptr); - texture_ptr = NULL; -} - -static void test_cube_texture_levels(IDirect3DDevice9 *device_ptr) -{ - IDirect3DCubeTexture9 *texture_ptr; - DWORD levels; - D3DSURFACE_DESC desc; - HRESULT hr; - IDirect3DSurface9 *surface; - - hr = IDirect3DDevice9_CreateCubeTexture(device_ptr, 64, 0, 0, D3DFMT_X8R8G8B8, - D3DPOOL_DEFAULT, &texture_ptr, NULL); - if (FAILED(hr)) - { - skip("Couldn't create cube texture\n"); - return; - } - - levels = IDirect3DCubeTexture9_GetLevelCount(texture_ptr); - ok(levels == 7, "Got %u levels, expected 7\n", levels); - - hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels - 1, &desc); - ok(hr == D3D_OK, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr); - hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels, &desc); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr); - hr = IDirect3DCubeTexture9_GetLevelDesc(texture_ptr, levels + 1, &desc); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetLevelDesc returned %#x\n", hr); - - hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_POSITIVE_X, - 0, &surface); - ok(hr == D3D_OK, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr); - if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface); - hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_NEGATIVE_Z + 1, - 0, &surface); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr); - if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface); - hr = IDirect3DCubeTexture9_GetCubeMapSurface(texture_ptr, D3DCUBEMAP_FACE_POSITIVE_X - 1, - 0, &surface); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DCubeTexture9_GetCubeMapSurface returned %#x\n", hr); - if (SUCCEEDED(hr)) IDirect3DSurface9_Release(surface); - - IDirect3DCubeTexture9_Release(texture_ptr); -} - -static void test_cube_textures(IDirect3DDevice9 *device_ptr, DWORD caps) -{ - test_cube_texture_from_pool(device_ptr, caps, D3DPOOL_DEFAULT, TRUE); - test_cube_texture_from_pool(device_ptr, caps, D3DPOOL_MANAGED, TRUE); - test_cube_texture_from_pool(device_ptr, caps, D3DPOOL_SYSTEMMEM, TRUE); - test_cube_texture_from_pool(device_ptr, caps, D3DPOOL_SCRATCH, FALSE); - test_cube_texture_mipmap_gen(device_ptr); - test_cube_texture_levels(device_ptr); -} - -static void test_mipmap_gen(IDirect3DDevice9 *device) -{ - HRESULT hr; - IDirect3D9 *d3d9; - IDirect3DTexture9 *texture = NULL; - IDirect3DSurface9 *surface; - DWORD levels; - D3DSURFACE_DESC desc; - int i; - D3DLOCKED_RECT lr; - - hr = IDirect3DDevice9_GetDirect3D(device, &d3d9); - ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D returned %#x\n", hr); - - hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, - D3DUSAGE_AUTOGENMIPMAP, - D3DRTYPE_TEXTURE, D3DFMT_X8R8G8B8); - if(FAILED(hr)) - { - skip("No mipmap generation support\n"); - return; - } - - /* testing shows that autogenmipmap and rendertarget are mutually exclusive options */ - hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 0, (D3DUSAGE_RENDERTARGET | - D3DUSAGE_AUTOGENMIPMAP), D3DFMT_X8R8G8B8, - D3DPOOL_DEFAULT, &texture, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned 0x%08x, expected 0x%08x\n", - hr, D3D_OK); - if (texture) IDirect3DTexture9_Release(texture); - texture = NULL; - - hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 0, D3DUSAGE_AUTOGENMIPMAP, - D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed(%08x)\n", hr); - - if (SUCCEEDED(hr)) - { - D3DTEXTUREFILTERTYPE fltt; - fltt = IDirect3DTexture9_GetAutoGenFilterType(texture); - ok(D3DTEXF_LINEAR == fltt /* || broken(D3DTEXF_POINT == fltt)*/, - "GetAutoGenFilterType returned default %d\n", fltt); - hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_NONE); - todo_wine ok(hr == D3DERR_INVALIDCALL, "SetAutoGenFilterType D3DTEXF_NONE returned %08x\n", hr); - hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_ANISOTROPIC); - ok(hr == D3D_OK, "SetAutoGenFilterType D3DTEXF_ANISOTROPIC returned %08x\n", hr); - fltt = IDirect3DTexture9_GetAutoGenFilterType(texture); - ok(D3DTEXF_ANISOTROPIC == fltt, "GetAutoGenFilterType returned %d\n", fltt); - hr = IDirect3DTexture9_SetAutoGenFilterType(texture, D3DTEXF_LINEAR); - ok(hr == D3D_OK, "SetAutoGenFilterType D3DTEXF_LINEAR returned %08x\n", hr); - } - levels = IDirect3DTexture9_GetLevelCount(texture); - ok(levels == 1, "Got %d levels, expected 1\n", levels); - - for(i = 0; i < 6 /* 64 = 2 ^ 6 */; i++) - { - surface = NULL; - hr = IDirect3DTexture9_GetSurfaceLevel(texture, i, &surface); - ok(hr == (i == 0 ? D3D_OK : D3DERR_INVALIDCALL), - "GetSurfaceLevel on level %d returned %#x\n", i, hr); - if(surface) IDirect3DSurface9_Release(surface); - - hr = IDirect3DTexture9_GetLevelDesc(texture, i, &desc); - ok(hr == (i == 0 ? D3D_OK : D3DERR_INVALIDCALL), - "GetLevelDesc on level %d returned %#x\n", i, hr); - - hr = IDirect3DTexture9_LockRect(texture, i, &lr, NULL, 0); - ok(hr == (i == 0 ? D3D_OK : D3DERR_INVALIDCALL), - "LockRect on level %d returned %#x\n", i, hr); - if(SUCCEEDED(hr)) - { - hr = IDirect3DTexture9_UnlockRect(texture, i); - ok(hr == D3D_OK, "Unlock returned %08x\n", hr); - } - } - IDirect3DTexture9_Release(texture); - - hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 2 /* levels */, D3DUSAGE_AUTOGENMIPMAP, - D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture(levels = 2) returned %08x\n", hr); - hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 6 /* levels */, D3DUSAGE_AUTOGENMIPMAP, - D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); - ok(hr == D3DERR_INVALIDCALL, "IDirect3DDevice9_CreateTexture(levels = 6) returned %08x\n", hr); - - hr = IDirect3DDevice9_CreateTexture(device, 64, 64, 1 /* levels */, D3DUSAGE_AUTOGENMIPMAP, - D3DFMT_X8R8G8B8, D3DPOOL_MANAGED, &texture, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture(levels = 1) returned %08x\n", hr); - levels = IDirect3DTexture9_GetLevelCount(texture); - ok(levels == 1, "Got %d levels, expected 1\n", levels); - IDirect3DTexture9_Release(texture); -} - -static void test_filter(IDirect3DDevice9 *device) { - HRESULT hr; - IDirect3DTexture9 *texture; - IDirect3D9 *d3d9; - DWORD passes = 0; - unsigned int i; - struct filter_tests { - DWORD magfilter, minfilter, mipfilter; - BOOL has_texture; - HRESULT result; - } tests[] = { - { D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, FALSE, D3D_OK }, - { D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, FALSE, D3D_OK }, - - { D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_POINT, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, D3D_OK }, - { D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_POINT, TRUE, D3D_OK }, - - { D3DTEXF_NONE, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_LINEAR, D3DTEXF_NONE, D3DTEXF_NONE, TRUE, D3DERR_UNSUPPORTEDTEXTUREFILTER }, - { D3DTEXF_LINEAR, D3DTEXF_POINT, D3DTEXF_NONE, TRUE, E_FAIL }, - { D3DTEXF_POINT, D3DTEXF_LINEAR, D3DTEXF_NONE, TRUE, E_FAIL }, - { D3DTEXF_POINT, D3DTEXF_POINT, D3DTEXF_LINEAR, TRUE, E_FAIL }, - - }; - - hr = IDirect3DDevice9_GetDirect3D(device, &d3d9); - ok(hr == D3D_OK, "IDirect3DDevice9_GetDirect3D(levels = 1) returned %08x\n", hr); - hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, 0, - D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F); - if(FAILED(hr)) { - skip("D3DFMT_A32B32G32R32F not supported\n"); - goto out; - } - hr = IDirect3D9_CheckDeviceFormat(d3d9, 0, D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_FILTER, - D3DRTYPE_TEXTURE, D3DFMT_A32B32G32R32F); - if(SUCCEEDED(hr)) { - skip("D3DFMT_A32B32G32R32F supports filtering\n"); - goto out; - } - - hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 0, 0, D3DFMT_A32B32G32R32F, - D3DPOOL_MANAGED, &texture, 0); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture returned %08x\n", hr); - - /* Needed for ValidateDevice */ - hr = IDirect3DDevice9_SetFVF(device, D3DFVF_XYZ | D3DFVF_TEX1); - ok(hr == D3D_OK, "IDirect3DDevice9_SetFVF returned %08x\n", hr); - - for(i = 0; i < (sizeof(tests) / sizeof(tests[0])); i++) { - if(tests[i].has_texture) { - hr = IDirect3DDevice9_SetTexture(device, 0, (IDirect3DBaseTexture9 *) texture); - ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr); - } else { - hr = IDirect3DDevice9_SetTexture(device, 0, NULL); - ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture returned %08x\n", hr); - } - - hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, tests[i].magfilter); - ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr); - hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MINFILTER, tests[i].minfilter); - ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr); - hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MIPFILTER, tests[i].mipfilter); - ok(hr == D3D_OK, "IDirect3DDevice9_SetSamplerState returned %08x\n", hr); - - passes = 0xdeadbeef; - hr = IDirect3DDevice9_ValidateDevice(device, &passes); - ok(hr == tests[i].result, "ValidateDevice failed: Texture %s, min %u, mag %u, mip %u. Got %08x, expected %08x\n", - tests[i].has_texture ? "TRUE" : "FALSE", tests[i].magfilter, tests[i].minfilter, - tests[i].mipfilter, hr, tests[i].result); - if(SUCCEEDED(hr)) { - ok(passes != 0, "ValidateDevice succeeded, passes is %u\n", passes); - } else { - ok(passes == 0xdeadbeef, "ValidateDevice failed, passes is %u\n", passes); - } - } - - hr = IDirect3DDevice9_SetTexture(device, 0, NULL); - ok(SUCCEEDED(hr), "IDirect3DDevice9_SetTexture returned %#x.\n", hr); - IDirect3DTexture9_Release(texture); - - out: - IDirect3D9_Release(d3d9); -} - -static void test_gettexture(IDirect3DDevice9 *device) { - HRESULT hr; - IDirect3DBaseTexture9 *texture = (IDirect3DBaseTexture9 *) 0xdeadbeef; - - hr = IDirect3DDevice9_SetTexture(device, 0, NULL); - ok(hr == D3D_OK, "IDirect3DDevice9_SetTexture failed, hr = 0x%08x\n", hr); - hr = IDirect3DDevice9_GetTexture(device, 0, &texture); - ok(hr == D3D_OK, "IDirect3DDevice9_GetTexture failed, hr = 0x%08x\n", hr); - ok(texture == NULL, "Texture returned is %p, expected NULL\n", texture); -} - -static void test_lod(IDirect3DDevice9 *device) -{ - HRESULT hr; - DWORD ret; - IDirect3DTexture9 *texture; - - hr = IDirect3DDevice9_CreateTexture(device, 128, 128, 3, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, - &texture, NULL); - ok(hr == D3D_OK, "IDirect3DDevice9_CreateTexture failed with %08x\n", hr); - - /* SetLOD is only supported on D3DPOOL_MANAGED textures, but it doesn't return a HRESULT, - * so it can't return a normal error. Instead, the call is simply ignored - */ - ret = IDirect3DTexture9_SetLOD(texture, 0); - ok(ret == 0, "IDirect3DTexture9_SetLOD returned %u, expected 0\n", ret); - ret = IDirect3DTexture9_SetLOD(texture, 1); - ok(ret == 0, "IDirect3DTexture9_SetLOD returned %u, expected 0\n", ret); - ret = IDirect3DTexture9_SetLOD(texture, 2); - ok(ret == 0, "IDirect3DTexture9_SetLOD returned %u, expected 0\n", ret); - ret = IDirect3DTexture9_GetLOD(texture); - ok(ret == 0, "IDirect3DTexture9_GetLOD returned %u, expected 0\n", ret); - - IDirect3DTexture9_Release(texture); -} - -START_TEST(texture) -{ - D3DCAPS9 caps; - HMODULE d3d9_handle; - IDirect3DDevice9 *device_ptr; - ULONG refcount; - - d3d9_handle = LoadLibraryA("d3d9.dll"); - if (!d3d9_handle) - { - skip("Could not load d3d9.dll\n"); - return; - } - - device_ptr = init_d3d9(d3d9_handle); - if (!device_ptr) return; - - IDirect3DDevice9_GetDeviceCaps(device_ptr, &caps); - - test_texture_stage_states(device_ptr, caps.MaxTextureBlendStages); - test_cube_textures(device_ptr, caps.TextureCaps); - test_mipmap_gen(device_ptr); - test_filter(device_ptr); - test_gettexture(device_ptr); - test_lod(device_ptr); - - refcount = IDirect3DDevice9_Release(device_ptr); - ok(!refcount, "Device has %u references left\n", refcount); -}