kc3-lang/angle/src/tests/gl_tests/D3D11FormatTablesTest.cpp

• Show log

  Commit

• Hash : 1a4523f3
  Author :
  Date : 2016-03-18T15:33:55
  

  Avoid copying of texture format info structures
  
  Use const pointers to the statically allocated structures instead of
  copying them in TextureStorage11. This avoids the cost of copying and
  saves a little bit of memory.
  
  BUG=angleproject:1244
  TEST=angle_end2end_tests
  
  Change-Id: Ib59fddd68ba9bc53e491d55683416c0661f26e0e
  Reviewed-on: https://chromium-review.googlesource.com/333930
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/tests/gl_tests/D3D11FormatTablesTest.cpp

• //
  // 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/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<gl::Context *>(getEGLWindow()->getContext());
      rx::Renderer11 *renderer = rx::GetAs<rx::Renderer11>(context->getRenderer());
      const auto &textureCaps = renderer->getRendererTextureCaps();
  
      ID3D11Device *device = renderer->getDevice();
  
      const gl::FormatSet &allFormats = gl::GetAllSizedInternalFormats();
      for (GLenum internalFormat : allFormats)
      {
          const rx::d3d11::TextureFormat &formatInfo =
              rx::d3d11::GetTextureFormatInfo(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;
          bool texSuccess =
              SUCCEEDED(device->CheckFormatSupport(formatInfo.formatSet->texFormat, &texSupport));
          bool textureable = texSuccess && ((texSupport & texSupportMask) == texSupportMask);
          EXPECT_EQ(textureable, textureInfo.texturable);
  
          // Bits for filtering
          UINT filterSupport;
          bool filterSuccess =
              SUCCEEDED(device->CheckFormatSupport(formatInfo.formatSet->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.formatSet->dsvFormat;
              bool depthSuccess = SUCCEEDED(
                  device->CheckFormatSupport(formatInfo.formatSet->dsvFormat, &renderSupport));
              renderable =
                  depthSuccess && ((renderSupport & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL) != 0);
              if (renderable)
              {
                  EXPECT_NE(DXGI_FORMAT_UNKNOWN, formatInfo.formatSet->dsvFormat);
              }
          }
          else
          {
              renderFormat   = formatInfo.formatSet->rtvFormat;
              bool rtSuccess = SUCCEEDED(
                  device->CheckFormatSupport(formatInfo.formatSet->rtvFormat, &renderSupport));
              renderable = rtSuccess && ((renderSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET) != 0);
              if (renderable)
              {
                  EXPECT_NE(DXGI_FORMAT_UNKNOWN, formatInfo.formatSet->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
  

Download