From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- .../src/tests/gl_tests/D3D11FormatTablesTest.cpp | 153 +++++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100755 gfx/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp (limited to 'gfx/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp') diff --git a/gfx/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp b/gfx/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp new file mode 100755 index 000000000..e407d1190 --- /dev/null +++ b/gfx/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp @@ -0,0 +1,153 @@ +// +// Copyright 2015 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// D3D11FormatTablesTest: +// Tests to validate our D3D11 support tables match hardware support. +// + +#include "libANGLE/angletypes.h" +#include "libANGLE/Context.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/d3d/d3d11/Context11.h" +#include "libANGLE/renderer/d3d/d3d11/dxgi_support_table.h" +#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" +#include "test_utils/angle_test_instantiate.h" +#include "test_utils/ANGLETest.h" + +using namespace angle; + +namespace +{ + +class D3D11FormatTablesTest : public ANGLETest +{ + +}; + +// This test enumerates all GL formats - for each, it queries the D3D support for +// using it as a texture, a render target, and sampling from it in the shader. It +// checks this against our speed-optimized baked tables, and validates they would +// give the same result. +// TODO(jmadill): Find out why in 9_3, some format queries return an error. +// The error seems to appear for formats that are not supported on 9_3. +TEST_P(D3D11FormatTablesTest, TestFormatSupport) +{ + ASSERT_EQ(EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE, GetParam().getRenderer()); + + // Hack the angle! + gl::Context *context = reinterpret_cast(getEGLWindow()->getContext()); + rx::Context11 *context11 = rx::GetImplAs(context); + rx::Renderer11 *renderer = context11->getRenderer(); + const auto &textureCaps = renderer->getNativeTextureCaps(); + + ID3D11Device *device = renderer->getDevice(); + + const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats(); + for (GLenum internalFormat : allFormats) + { + const rx::d3d11::Format &formatInfo = + rx::d3d11::Format::Get(internalFormat, renderer->getRenderer11DeviceCaps()); + const auto &textureInfo = textureCaps.get(internalFormat); + + // Bits for texturing + const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat); + + UINT texSupportMask = D3D11_FORMAT_SUPPORT_TEXTURE2D; + if (internalFormatInfo.depthBits == 0 && internalFormatInfo.stencilBits == 0) + { + texSupportMask |= D3D11_FORMAT_SUPPORT_TEXTURECUBE; + if (GetParam().majorVersion > 2) + { + texSupportMask |= D3D11_FORMAT_SUPPORT_TEXTURE3D; + } + } + + UINT texSupport = 0; + bool texSuccess = SUCCEEDED(device->CheckFormatSupport(formatInfo.texFormat, &texSupport)); + bool textureable = texSuccess && ((texSupport & texSupportMask) == texSupportMask); + EXPECT_EQ(textureable, textureInfo.texturable); + + // Bits for mipmap auto-gen. + bool expectedMipGen = texSuccess && ((texSupport & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) != 0); + auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel; + const auto &dxgiSupport = rx::d3d11::GetDXGISupport(formatInfo.texFormat, featureLevel); + bool actualMipGen = + ((dxgiSupport.alwaysSupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) != 0); + EXPECT_EQ(0u, dxgiSupport.optionallySupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN); + EXPECT_EQ(expectedMipGen, actualMipGen); + + // Bits for filtering + UINT filterSupport = 0; + bool filterSuccess = + SUCCEEDED(device->CheckFormatSupport(formatInfo.srvFormat, &filterSupport)); + bool filterable = filterSuccess && ((filterSupport & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE) != 0); + EXPECT_EQ(filterable, textureInfo.filterable); + + // Bits for renderable + bool renderable = false; + UINT renderSupport = 0u; + DXGI_FORMAT renderFormat = DXGI_FORMAT_UNKNOWN; + if (internalFormatInfo.depthBits > 0 || internalFormatInfo.stencilBits > 0) + { + renderFormat = formatInfo.dsvFormat; + bool depthSuccess = + SUCCEEDED(device->CheckFormatSupport(formatInfo.dsvFormat, &renderSupport)); + renderable = + depthSuccess && ((renderSupport & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL) != 0); + if (renderable) + { + EXPECT_NE(DXGI_FORMAT_UNKNOWN, formatInfo.dsvFormat); + } + } + else + { + renderFormat = formatInfo.rtvFormat; + bool rtSuccess = + SUCCEEDED(device->CheckFormatSupport(formatInfo.rtvFormat, &renderSupport)); + renderable = rtSuccess && ((renderSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET) != 0); + if (renderable) + { + EXPECT_NE(DXGI_FORMAT_UNKNOWN, formatInfo.rtvFormat); + } + } + EXPECT_EQ(renderable, textureInfo.renderable); + if (!textureInfo.sampleCounts.empty()) + { + EXPECT_TRUE(renderable); + } + + // Multisample counts + if (renderable) + { + if ((renderSupport & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET) != 0) + { + EXPECT_TRUE(!textureInfo.sampleCounts.empty()); + for (unsigned int sampleCount = 1; + sampleCount <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; sampleCount *= 2) + { + UINT qualityCount = 0; + bool sampleSuccess = SUCCEEDED(device->CheckMultisampleQualityLevels( + renderFormat, sampleCount, &qualityCount)); + GLuint expectedCount = (!sampleSuccess || qualityCount == 0) ? 0 : 1; + EXPECT_EQ(expectedCount, textureInfo.sampleCounts.count(sampleCount)); + } + } + else + { + EXPECT_TRUE(textureInfo.sampleCounts.empty()); + } + } + } +} + +ANGLE_INSTANTIATE_TEST(D3D11FormatTablesTest, + ES2_D3D11_FL9_3(), + ES2_D3D11_FL10_0(), + ES2_D3D11_FL10_1(), + ES2_D3D11_FL11_0()); + +} // anonymous namespace -- cgit v1.2.3