kc3-lang/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp

• Show log

  Commit

• Hash : 36f41997
  Author :
  Date : 2023-10-30T15:14:09
  

  D3D11: CopySubTexture: Handle sRGB source with D3D11
  
  Use typeless formats for sRGB textures that can be reinterpreted as
  linear. Add a parameter to SRV creation to request samplers that
  do not do sRGB for copying sRGB textures.
  
  Bug: angleproject:7907
  Change-Id: I3d94dfa5b25a1c2c531cd9bef4247097aa4bfb61
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4986290
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp

• //
  // Copyright 2013 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.
  //
  
  // formatutils11.cpp: Queries for GL image formats and their translations to D3D11
  // formats.
  
  #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
  
  #include "image_util/copyimage.h"
  #include "image_util/generatemip.h"
  #include "image_util/loadimage.h"
  
  #include "libANGLE/formatutils.h"
  #include "libANGLE/renderer/copyvertex.h"
  #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
  #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
  #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
  #include "libANGLE/renderer/dxgi_support_table.h"
  
  namespace rx
  {
  
  namespace d3d11
  {
  
  bool SupportsMipGen(DXGI_FORMAT dxgiFormat, D3D_FEATURE_LEVEL featureLevel)
  {
      const auto &support = GetDXGISupport(dxgiFormat, featureLevel);
      ASSERT((support.optionallySupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) == 0);
      return ((support.alwaysSupportedFlags & D3D11_FORMAT_SUPPORT_MIP_AUTOGEN) != 0);
  }
  
  bool IsSupportedMultiplanarFormat(DXGI_FORMAT dxgiFormat)
  {
      return dxgiFormat == DXGI_FORMAT_NV12 || dxgiFormat == DXGI_FORMAT_P010 ||
             dxgiFormat == DXGI_FORMAT_P016;
  }
  
  const Format &GetYUVPlaneFormat(DXGI_FORMAT dxgiFormat, int plane)
  {
      static constexpr Format nv12Plane0Info(
          GL_R8, angle::FormatID::R8_UNORM, DXGI_FORMAT_NV12, DXGI_FORMAT_R8_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8_TYPELESS, GL_RGBA8, nullptr);
  
      static constexpr Format nv12Plane1Info(
          GL_RG8, angle::FormatID::R8G8_UNORM, DXGI_FORMAT_NV12, DXGI_FORMAT_R8G8_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8_TYPELESS, GL_RGBA8, nullptr);
  
      static constexpr Format p010Plane0Info(
          GL_R16_EXT, angle::FormatID::R16_UNORM, DXGI_FORMAT_P010, DXGI_FORMAT_R16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_TYPELESS, GL_RGBA16_EXT, nullptr);
  
      static constexpr Format p010Plane1Info(
          GL_RG16_EXT, angle::FormatID::R16G16_UNORM, DXGI_FORMAT_P010, DXGI_FORMAT_R16G16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_UNKNOWN,
          DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN,
          DXGI_FORMAT_R16G16_TYPELESS, GL_RGBA16_EXT, nullptr);
  
      static constexpr Format p016Plane0Info(
          GL_R16_EXT, angle::FormatID::R16_UNORM, DXGI_FORMAT_P016, DXGI_FORMAT_R16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16_TYPELESS, GL_RGBA16_EXT, nullptr);
  
      static constexpr Format p016Plane1Info(
          GL_RG16_EXT, angle::FormatID::R16G16_UNORM, DXGI_FORMAT_P016, DXGI_FORMAT_R16G16_UNORM,
          DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_UNKNOWN,
          DXGI_FORMAT_R16G16_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN,
          DXGI_FORMAT_R16G16_TYPELESS, GL_RGBA16_EXT, nullptr);
  
      ASSERT(IsSupportedMultiplanarFormat(dxgiFormat));
      if (plane < 0 || plane > 1)
      {
          ERR() << "Invalid client buffer texture plane: " << plane;
          static constexpr Format defaultInfo;
          return defaultInfo;
      }
  
      switch (dxgiFormat)
      {
          case DXGI_FORMAT_NV12:
              return plane == 0 ? nv12Plane0Info : nv12Plane1Info;
          case DXGI_FORMAT_P010:
              return plane == 0 ? p010Plane0Info : p010Plane1Info;
          case DXGI_FORMAT_P016:
              return plane == 0 ? p016Plane0Info : p016Plane1Info;
          default:
              ERR() << "Not supported multiplanar format: " << dxgiFormat;
      }
      static constexpr Format defaultInfo;
      return defaultInfo;
  }
  
  DXGIFormatSize::DXGIFormatSize(GLuint pixelBits, GLuint blockWidth, GLuint blockHeight)
      : pixelBytes(pixelBits / 8), blockWidth(blockWidth), blockHeight(blockHeight)
  {}
  
  const DXGIFormatSize &GetDXGIFormatSizeInfo(DXGI_FORMAT format)
  {
      static const DXGIFormatSize sizeUnknown(0, 0, 0);
      static const DXGIFormatSize size128(128, 1, 1);
      static const DXGIFormatSize size96(96, 1, 1);
      static const DXGIFormatSize size64(64, 1, 1);
      static const DXGIFormatSize size32(32, 1, 1);
      static const DXGIFormatSize size16(16, 1, 1);
      static const DXGIFormatSize size8(8, 1, 1);
      static const DXGIFormatSize sizeBC1(64, 4, 4);
      static const DXGIFormatSize sizeBC2(128, 4, 4);
      static const DXGIFormatSize sizeBC3(128, 4, 4);
      static const DXGIFormatSize sizeBC4(64, 4, 4);
      static const DXGIFormatSize sizeBC5(128, 4, 4);
      static const DXGIFormatSize sizeBC6H(128, 4, 4);
      static const DXGIFormatSize sizeBC7(128, 4, 4);
      switch (format)
      {
          case DXGI_FORMAT_UNKNOWN:
              return sizeUnknown;
          case DXGI_FORMAT_R32G32B32A32_TYPELESS:
          case DXGI_FORMAT_R32G32B32A32_FLOAT:
          case DXGI_FORMAT_R32G32B32A32_UINT:
          case DXGI_FORMAT_R32G32B32A32_SINT:
              return size128;
          case DXGI_FORMAT_R32G32B32_TYPELESS:
          case DXGI_FORMAT_R32G32B32_FLOAT:
          case DXGI_FORMAT_R32G32B32_UINT:
          case DXGI_FORMAT_R32G32B32_SINT:
              return size96;
          case DXGI_FORMAT_R16G16B16A16_TYPELESS:
          case DXGI_FORMAT_R16G16B16A16_FLOAT:
          case DXGI_FORMAT_R16G16B16A16_UNORM:
          case DXGI_FORMAT_R16G16B16A16_UINT:
          case DXGI_FORMAT_R16G16B16A16_SNORM:
          case DXGI_FORMAT_R16G16B16A16_SINT:
          case DXGI_FORMAT_R32G32_TYPELESS:
          case DXGI_FORMAT_R32G32_FLOAT:
          case DXGI_FORMAT_R32G32_UINT:
          case DXGI_FORMAT_R32G32_SINT:
          case DXGI_FORMAT_R32G8X24_TYPELESS:
          case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
          case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
          case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
              return size64;
          case DXGI_FORMAT_R10G10B10A2_TYPELESS:
          case DXGI_FORMAT_R10G10B10A2_UNORM:
          case DXGI_FORMAT_R10G10B10A2_UINT:
          case DXGI_FORMAT_R11G11B10_FLOAT:
          case DXGI_FORMAT_R8G8B8A8_TYPELESS:
          case DXGI_FORMAT_R8G8B8A8_UNORM:
          case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
          case DXGI_FORMAT_R8G8B8A8_UINT:
          case DXGI_FORMAT_R8G8B8A8_SNORM:
          case DXGI_FORMAT_R8G8B8A8_SINT:
          case DXGI_FORMAT_R16G16_TYPELESS:
          case DXGI_FORMAT_R16G16_FLOAT:
          case DXGI_FORMAT_R16G16_UNORM:
          case DXGI_FORMAT_R16G16_UINT:
          case DXGI_FORMAT_R16G16_SNORM:
          case DXGI_FORMAT_R16G16_SINT:
          case DXGI_FORMAT_R32_TYPELESS:
          case DXGI_FORMAT_D32_FLOAT:
          case DXGI_FORMAT_R32_FLOAT:
          case DXGI_FORMAT_R32_UINT:
          case DXGI_FORMAT_R32_SINT:
          case DXGI_FORMAT_R24G8_TYPELESS:
          case DXGI_FORMAT_D24_UNORM_S8_UINT:
          case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
          case DXGI_FORMAT_X24_TYPELESS_G8_UINT:
              return size32;
          case DXGI_FORMAT_R8G8_TYPELESS:
          case DXGI_FORMAT_R8G8_UNORM:
          case DXGI_FORMAT_R8G8_UINT:
          case DXGI_FORMAT_R8G8_SNORM:
          case DXGI_FORMAT_R8G8_SINT:
          case DXGI_FORMAT_R16_TYPELESS:
          case DXGI_FORMAT_R16_FLOAT:
          case DXGI_FORMAT_D16_UNORM:
          case DXGI_FORMAT_R16_UNORM:
          case DXGI_FORMAT_R16_UINT:
          case DXGI_FORMAT_R16_SNORM:
          case DXGI_FORMAT_R16_SINT:
              return size16;
          case DXGI_FORMAT_R8_TYPELESS:
          case DXGI_FORMAT_R8_UNORM:
          case DXGI_FORMAT_R8_UINT:
          case DXGI_FORMAT_R8_SNORM:
          case DXGI_FORMAT_R8_SINT:
          case DXGI_FORMAT_A8_UNORM:
              return size8;
          case DXGI_FORMAT_R1_UNORM:
              UNREACHABLE();
              return sizeUnknown;
          case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
          case DXGI_FORMAT_R8G8_B8G8_UNORM:
          case DXGI_FORMAT_G8R8_G8B8_UNORM:
              return size32;
          case DXGI_FORMAT_BC1_TYPELESS:
          case DXGI_FORMAT_BC1_UNORM:
          case DXGI_FORMAT_BC1_UNORM_SRGB:
              return sizeBC1;
          case DXGI_FORMAT_BC2_TYPELESS:
          case DXGI_FORMAT_BC2_UNORM:
          case DXGI_FORMAT_BC2_UNORM_SRGB:
              return sizeBC2;
          case DXGI_FORMAT_BC3_TYPELESS:
          case DXGI_FORMAT_BC3_UNORM:
          case DXGI_FORMAT_BC3_UNORM_SRGB:
              return sizeBC3;
          case DXGI_FORMAT_BC4_TYPELESS:
          case DXGI_FORMAT_BC4_UNORM:
          case DXGI_FORMAT_BC4_SNORM:
              return sizeBC4;
          case DXGI_FORMAT_BC5_TYPELESS:
          case DXGI_FORMAT_BC5_UNORM:
          case DXGI_FORMAT_BC5_SNORM:
              return sizeBC5;
          case DXGI_FORMAT_B5G6R5_UNORM:
          case DXGI_FORMAT_B5G5R5A1_UNORM:
              return size16;
          case DXGI_FORMAT_B8G8R8A8_UNORM:
          case DXGI_FORMAT_B8G8R8X8_UNORM:
          case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
          case DXGI_FORMAT_B8G8R8A8_TYPELESS:
          case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
          case DXGI_FORMAT_B8G8R8X8_TYPELESS:
          case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
              return size32;
          case DXGI_FORMAT_BC6H_TYPELESS:
          case DXGI_FORMAT_BC6H_UF16:
          case DXGI_FORMAT_BC6H_SF16:
              return sizeBC6H;
          case DXGI_FORMAT_BC7_TYPELESS:
          case DXGI_FORMAT_BC7_UNORM:
          case DXGI_FORMAT_BC7_UNORM_SRGB:
              return sizeBC7;
          case DXGI_FORMAT_AYUV:
          case DXGI_FORMAT_Y410:
          case DXGI_FORMAT_Y416:
          case DXGI_FORMAT_NV12:
          case DXGI_FORMAT_P010:
          case DXGI_FORMAT_P016:
          case DXGI_FORMAT_420_OPAQUE:
          case DXGI_FORMAT_YUY2:
          case DXGI_FORMAT_Y210:
          case DXGI_FORMAT_Y216:
          case DXGI_FORMAT_NV11:
          case DXGI_FORMAT_AI44:
          case DXGI_FORMAT_IA44:
          case DXGI_FORMAT_P8:
          case DXGI_FORMAT_A8P8:
              UNREACHABLE();
              return sizeUnknown;
          case DXGI_FORMAT_B4G4R4A4_UNORM:
              return size16;
          default:
              UNREACHABLE();
              return sizeUnknown;
      }
  }
  
  constexpr VertexFormat::VertexFormat()
      : conversionType(VERTEX_CONVERT_NONE), nativeFormat(DXGI_FORMAT_UNKNOWN), copyFunction(nullptr)
  {}
  
  constexpr VertexFormat::VertexFormat(VertexConversionType conversionTypeIn,
                                       DXGI_FORMAT nativeFormatIn,
                                       VertexCopyFunction copyFunctionIn)
      : conversionType(conversionTypeIn), nativeFormat(nativeFormatIn), copyFunction(copyFunctionIn)
  {}
  
  const VertexFormat *GetVertexFormatInfo_FL_9_3(angle::FormatID vertexFormatID)
  {
      // D3D11 Feature Level 9_3 doesn't support as many formats for vertex buffer resource as Feature
      // Level 10_0+.
      // http://msdn.microsoft.com/en-us/library/windows/desktop/ff471324(v=vs.85).aspx
  
      switch (vertexFormatID)
      {
          // GL_BYTE -- unnormalized
          case angle::FormatID::R8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT,
                                                 &Copy8SintTo16SintVertexData<1, 2>);
              return &info;
          }
          case angle::FormatID::R8G8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT,
                                                 &Copy8SintTo16SintVertexData<2, 2>);
              return &info;
          }
          case angle::FormatID::R8G8B8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &Copy8SintTo16SintVertexData<3, 4>);
              return &info;
          }
          case angle::FormatID::R8G8B8A8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &Copy8SintTo16SintVertexData<4, 4>);
              return &info;
          }
  
          // GL_BYTE -- normalized
          case angle::FormatID::R8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM,
                                                 &Copy8SnormTo16SnormVertexData<1, 2>);
              return &info;
          }
          case angle::FormatID::R8G8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM,
                                                 &Copy8SnormTo16SnormVertexData<2, 2>);
              return &info;
          }
          case angle::FormatID::R8G8B8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM,
                                                 &Copy8SnormTo16SnormVertexData<3, 4>);
              return &info;
          }
          case angle::FormatID::R8G8B8A8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM,
                                                 &Copy8SnormTo16SnormVertexData<4, 4>);
              return &info;
          }
  
          // GL_UNSIGNED_BYTE -- un-normalized
          // NOTE: 3 and 4 component unnormalized GL_UNSIGNED_BYTE should use the default format
          // table.
          case angle::FormatID::R8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 1, 4, 1>);
              return &info;
          }
          case angle::FormatID::R8G8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 2, 4, 1>);
              return &info;
          }
  
          // GL_UNSIGNED_BYTE -- normalized
          // NOTE: 3 and 4 component normalized GL_UNSIGNED_BYTE should use the default format table.
  
          // GL_UNSIGNED_BYTE -- normalized
          case angle::FormatID::R8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 1, 4, UINT8_MAX>);
              return &info;
          }
          case angle::FormatID::R8G8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 2, 4, UINT8_MAX>);
              return &info;
          }
  
          // GL_SHORT -- un-normalized
          // NOTE: 2, 3 and 4 component unnormalized GL_SHORT should use the default format table.
          case angle::FormatID::R16_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16_SINT,
                                                 &CopyNativeVertexData<GLshort, 1, 2, 0>);
              return &info;
          }
  
          // GL_SHORT -- normalized
          // NOTE: 2, 3 and 4 component normalized GL_SHORT should use the default format table.
          case angle::FormatID::R16_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16_SNORM,
                                                 &CopyNativeVertexData<GLshort, 1, 2, 0>);
              return &info;
          }
  
          // GL_UNSIGNED_SHORT -- un-normalized
          case angle::FormatID::R16_USCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                  &CopyToFloatVertexData<GLushort, 1, 2, false, false>);
              return &info;
          }
          case angle::FormatID::R16G16_USCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                  &CopyToFloatVertexData<GLushort, 2, 2, false, false>);
              return &info;
          }
          case angle::FormatID::R16G16B16_USCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT,
                  &CopyToFloatVertexData<GLushort, 3, 3, false, false>);
              return &info;
          }
          case angle::FormatID::R16G16B16A16_USCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                  &CopyToFloatVertexData<GLushort, 4, 4, false, false>);
              return &info;
          }
  
          // GL_UNSIGNED_SHORT -- normalized
          case angle::FormatID::R16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyToFloatVertexData<GLushort, 1, 2, true, false>);
              return &info;
          }
          case angle::FormatID::R16G16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyToFloatVertexData<GLushort, 2, 2, true, false>);
              return &info;
          }
          case angle::FormatID::R16G16B16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT,
                                                 &CopyToFloatVertexData<GLushort, 3, 3, true, false>);
              return &info;
          }
          case angle::FormatID::R16G16B16A16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                                                 &CopyToFloatVertexData<GLushort, 4, 4, true, false>);
              return &info;
          }
  
          // GL_FIXED
          // TODO: Add test to verify that this works correctly.
          // NOTE: 2, 3 and 4 component GL_FIXED should use the default format table.
          case angle::FormatID::R32_FIXED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &Copy32FixedTo32FVertexData<1, 2>);
              return &info;
          }
  
          // GL_FLOAT
          // TODO: Add test to verify that this works correctly.
          // NOTE: 2, 3 and 4 component GL_FLOAT should use the default format table.
          case angle::FormatID::R32_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyNativeVertexData<GLfloat, 1, 2, 0>);
              return &info;
          }
  
          default:
              return nullptr;
      }
  }
  
  const VertexFormat &GetVertexFormatInfo(angle::FormatID vertexFormatID,
                                          D3D_FEATURE_LEVEL featureLevel)
  {
      if (featureLevel == D3D_FEATURE_LEVEL_9_3)
      {
          const VertexFormat *result = GetVertexFormatInfo_FL_9_3(vertexFormatID);
          if (result)
          {
              return *result;
          }
      }
  
      switch (vertexFormatID)
      {
          //
          // Float formats
          //
  
          // GL_BYTE -- un-normalized
          case angle::FormatID::R8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 4, 4, 0>);
              return info;
          }
  
          // GL_BYTE -- normalized
          case angle::FormatID::R8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SNORM,
                                                 &CopyNativeVertexData<GLbyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SNORM,
                                                 &CopyNativeVertexData<GLbyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SNORM,
                                                 &CopyNativeVertexData<GLbyte, 3, 4, INT8_MAX>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SNORM,
                                                 &CopyNativeVertexData<GLbyte, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_BYTE -- un-normalized
          case angle::FormatID::R8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_BYTE -- normalized
          case angle::FormatID::R8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 3, 4, UINT8_MAX>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UNORM,
                                                 &CopyNativeVertexData<GLubyte, 4, 4, 0>);
              return info;
          }
  
          // GL_SHORT -- un-normalized
          case angle::FormatID::R16_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_SINT,
                                                 &CopyNativeVertexData<GLshort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_SINT,
                                                 &CopyNativeVertexData<GLshort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &CopyNativeVertexData<GLshort, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &CopyNativeVertexData<GLshort, 4, 4, 0>);
              return info;
          }
  
          // GL_SHORT -- normalized
          case angle::FormatID::R16_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SNORM,
                                                 &CopyNativeVertexData<GLshort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SNORM,
                                                 &CopyNativeVertexData<GLshort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM,
                                                 &CopyNativeVertexData<GLshort, 3, 4, INT16_MAX>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SNORM,
                                                 &CopyNativeVertexData<GLshort, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_SHORT -- un-normalized
          case angle::FormatID::R16_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_UINT,
                                                 &CopyNativeVertexData<GLushort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_UINT,
                                                 &CopyNativeVertexData<GLushort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_UINT,
                                                 &CopyNativeVertexData<GLushort, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_UINT,
                                                 &CopyNativeVertexData<GLushort, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_SHORT -- normalized
          case angle::FormatID::R16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UNORM,
                                                 &CopyNativeVertexData<GLushort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UNORM,
                                                 &CopyNativeVertexData<GLushort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UNORM,
                                                 &CopyNativeVertexData<GLushort, 3, 4, UINT16_MAX>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UNORM,
                                                 &CopyNativeVertexData<GLushort, 4, 4, 0>);
              return info;
          }
  
          // GL_INT -- un-normalized
          case angle::FormatID::R32_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_SINT,
                                                 &CopyNativeVertexData<GLint, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R32G32_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_SINT,
                                                 &CopyNativeVertexData<GLint, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_SINT,
                                                 &CopyNativeVertexData<GLint, 3, 3, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_SSCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_SINT,
                                                 &CopyNativeVertexData<GLint, 4, 4, 0>);
              return info;
          }
  
          // GL_INT -- normalized
          case angle::FormatID::R32_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT,
                                                 &CopyToFloatVertexData<GLint, 1, 1, true, false>);
              return info;
          }
          case angle::FormatID::R32G32_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyToFloatVertexData<GLint, 2, 2, true, false>);
              return info;
          }
          case angle::FormatID::R32G32B32_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT,
                                                 &CopyToFloatVertexData<GLint, 3, 3, true, false>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_SNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                                                 &CopyToFloatVertexData<GLint, 4, 4, true, false>);
              return info;
          }
  
          // GL_UNSIGNED_INT -- un-normalized
          case angle::FormatID::R32_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_UINT,
                                                 &CopyNativeVertexData<GLuint, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R32G32_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_UINT,
                                                 &CopyNativeVertexData<GLuint, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_UINT,
                                                 &CopyNativeVertexData<GLuint, 3, 3, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_USCALED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_UINT,
                                                 &CopyNativeVertexData<GLuint, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_INT -- normalized
          case angle::FormatID::R32_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT,
                                                 &CopyToFloatVertexData<GLuint, 1, 1, true, false>);
              return info;
          }
          case angle::FormatID::R32G32_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyToFloatVertexData<GLuint, 2, 2, true, false>);
              return info;
          }
          case angle::FormatID::R32G32B32_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT,
                                                 &CopyToFloatVertexData<GLuint, 3, 3, true, false>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                                                 &CopyToFloatVertexData<GLuint, 4, 4, true, false>);
              return info;
          }
  
          // GL_FIXED
          case angle::FormatID::R32_FIXED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT,
                                                 &Copy32FixedTo32FVertexData<1, 1>);
              return info;
          }
          case angle::FormatID::R32G32_FIXED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT,
                                                 &Copy32FixedTo32FVertexData<2, 2>);
              return info;
          }
          case angle::FormatID::R32G32B32_FIXED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT,
                                                 &Copy32FixedTo32FVertexData<3, 3>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_FIXED:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                                                 &Copy32FixedTo32FVertexData<4, 4>);
              return info;
          }
  
          // GL_HALF_FLOAT
          case angle::FormatID::R16_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_FLOAT,
                                                 &CopyNativeVertexData<GLhalf, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_FLOAT,
                                                 &CopyNativeVertexData<GLhalf, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_FLOAT,
                                                 &CopyNativeVertexData<GLhalf, 3, 4, gl::Float16One>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_FLOAT,
                                                 &CopyNativeVertexData<GLhalf, 4, 4, 0>);
              return info;
          }
  
          // GL_FLOAT
          case angle::FormatID::R32_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT,
                                                 &CopyNativeVertexData<GLfloat, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R32G32_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT,
                                                 &CopyNativeVertexData<GLfloat, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_FLOAT,
                                                 &CopyNativeVertexData<GLfloat, 3, 3, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_FLOAT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT,
                                                 &CopyNativeVertexData<GLfloat, 4, 4, 0>);
              return info;
          }
  
          // GL_INT_2_10_10_10_REV
          case angle::FormatID::R10G10B10A2_SSCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                  &CopyXYZ10W2ToXYZWFloatVertexData<true, false, true, false>);
              return info;
          }
          case angle::FormatID::R10G10B10A2_SNORM:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                  &CopyXYZ10W2ToXYZWFloatVertexData<true, true, true, false>);
              return info;
          }
  
          // GL_UNSIGNED_INT_2_10_10_10_REV
          case angle::FormatID::R10G10B10A2_USCALED:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT,
                  &CopyXYZ10W2ToXYZWFloatVertexData<false, false, true, false>);
              return info;
          }
          case angle::FormatID::R10G10B10A2_UNORM:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UNORM,
                                                 &CopyNativeVertexData<GLuint, 1, 1, 0>);
              return info;
          }
  
          //
          // Integer Formats
          //
  
          // GL_BYTE
          case angle::FormatID::R8_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SINT,
                                                 &CopyNativeVertexData<GLbyte, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_BYTE
          case angle::FormatID::R8_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R8G8_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R8G8B8_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R8G8B8A8_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UINT,
                                                 &CopyNativeVertexData<GLubyte, 4, 4, 0>);
              return info;
          }
  
          // GL_SHORT
          case angle::FormatID::R16_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SINT,
                                                 &CopyNativeVertexData<GLshort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SINT,
                                                 &CopyNativeVertexData<GLshort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &CopyNativeVertexData<GLshort, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SINT,
                                                 &CopyNativeVertexData<GLshort, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_SHORT
          case angle::FormatID::R16_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UINT,
                                                 &CopyNativeVertexData<GLushort, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R16G16_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UINT,
                                                 &CopyNativeVertexData<GLushort, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R16G16B16_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UINT,
                                                 &CopyNativeVertexData<GLushort, 3, 4, 1>);
              return info;
          }
          case angle::FormatID::R16G16B16A16_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UINT,
                                                 &CopyNativeVertexData<GLushort, 4, 4, 0>);
              return info;
          }
  
          // GL_INT
          case angle::FormatID::R32_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT,
                                                 &CopyNativeVertexData<GLint, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R32G32_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT,
                                                 &CopyNativeVertexData<GLint, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT,
                                                 &CopyNativeVertexData<GLint, 3, 3, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_SINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT,
                                                 &CopyNativeVertexData<GLint, 4, 4, 0>);
              return info;
          }
  
          // GL_UNSIGNED_INT
          case angle::FormatID::R32_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT,
                                                 &CopyNativeVertexData<GLuint, 1, 1, 0>);
              return info;
          }
          case angle::FormatID::R32G32_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT,
                                                 &CopyNativeVertexData<GLuint, 2, 2, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT,
                                                 &CopyNativeVertexData<GLuint, 3, 3, 0>);
              return info;
          }
          case angle::FormatID::R32G32B32A32_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT,
                                                 &CopyNativeVertexData<GLuint, 4, 4, 0>);
              return info;
          }
  
          // GL_INT_2_10_10_10_REV
          case angle::FormatID::R10G10B10A2_SINT:
          {
              static constexpr VertexFormat info(
                  VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT,
                  &CopyXYZ10W2ToXYZWFloatVertexData<true, true, false, false>);
              return info;
          }
  
          // GL_UNSIGNED_INT_2_10_10_10_REV
          case angle::FormatID::R10G10B10A2_UINT:
          {
              static constexpr VertexFormat info(VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UINT,
                                                 &CopyNativeVertexData<GLuint, 1, 1, 0>);
              return info;
          }
  
          default:
          {
              static constexpr VertexFormat info;
              return info;
          }
      }
  }
  
  }  // namespace d3d11
  
  }  // namespace rx
  

Download