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

• Show log

  Commit

• Hash : 25ab4510
  Author :
  Date : 2016-05-13T18:13:59
  

  Implement GL_EXT_texture_norm16 extension
  
  BUG=angleproject:1365
  
  Change-Id: I972b156ecb41ff44bc1f6365373ab386bacc85f1
  Reviewed-on: https://chromium-review.googlesource.com/346530
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

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

• // GENERATED FILE - DO NOT EDIT.
  // Generated by gen_load_functions_table.py using data from load_functions_data.json
  //
  // 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.
  //
  // load_functions_table:
  //   Contains the GetLoadFunctionsMap for texture_format_util.h
  //
  
  #include "libANGLE/renderer/d3d/d3d11/load_functions_table.h"
  #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
  #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
  #include "libANGLE/renderer/d3d/loadimage.h"
  #include "libANGLE/renderer/d3d/loadimage_etc.h"
  
  namespace rx
  {
  
  namespace d3d11
  {
  
  namespace
  {
  
  // ES3 image loading functions vary based on:
  //    - the GL internal format (supplied to glTex*Image*D)
  //    - the GL data type given (supplied to glTex*Image*D)
  //    - the target DXGI_FORMAT that the image will be loaded into (which is chosen based on the D3D
  //    device's capabilities)
  // This map type determines which loading function to use, based on these three parameters.
  // Source formats and types are taken from Tables 3.2 and 3.3 of the ES 3 spec.
  void UnimplementedLoadFunction(size_t width,
                                 size_t height,
                                 size_t depth,
                                 const uint8_t *input,
                                 size_t inputRowPitch,
                                 size_t inputDepthPitch,
                                 uint8_t *output,
                                 size_t outputRowPitch,
                                 size_t outputDepthPitch)
  {
      UNIMPLEMENTED();
  }
  
  void UnreachableLoadFunction(size_t width,
                               size_t height,
                               size_t depth,
                               const uint8_t *input,
                               size_t inputRowPitch,
                               size_t inputDepthPitch,
                               uint8_t *output,
                               size_t outputRowPitch,
                               size_t outputDepthPitch)
  {
      UNREACHABLE();
  }
  
  }  // namespace
  
  // TODO we can replace these maps with more generated code
  const std::map<GLenum, LoadImageFunctionInfo> &GetLoadFunctionsMap(GLenum internalFormat,
                                                                     DXGI_FORMAT dxgiFormat)
  {
      // clang-format off
      switch (internalFormat)
      {
          case GL_ALPHA:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R32G32B32A32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadA32FToRGBA32F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_ALPHA16F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_ALPHA32F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadA32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadA32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_ALPHA8_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadA8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_BGR5_A1_ANGLEX:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT] = LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true);
                          loadMap[GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT] = LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_BGRA4_ANGLEX:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT] = LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true);
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT] = LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_BGRA8_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_BGRA_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_COMPRESSED_R11_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadEACR11ToR8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_RG11_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadEACRG11ToRG8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_RGB8_ETC2:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2RGB8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2RGB8A1ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_RGBA8_ETC2_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2RGBA8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_COMPRESSED_SIGNED_R11_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadEACR11SToR8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_SIGNED_RG11_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadEACRG11SToRG8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2SRGBA8ToSRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_SRGB8_ETC2:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2SRGB8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC2SRGB8A1ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_DEPTH24_STENCIL8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_D24_UNORM_S8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT_24_8] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R24G8_TYPELESS:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT_24_8] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_DEPTH32F_STENCIL8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G8X24_TYPELESS:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = LoadImageFunctionInfo(LoadToNative<GLuint,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_DEPTH_COMPONENT16:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_D16_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R16_TYPELESS:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadR32ToR16, true);
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_DEPTH_COMPONENT24:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_D24_UNORM_S8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R24G8_TYPELESS:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_DEPTH_COMPONENT32F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32_TYPELESS:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLfloat,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_DEPTH_COMPONENT32_OES:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadR32ToR24G8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_BC1_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC1RGB8ToBC1, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_ETC1_RGB8_OES:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadETC1RGB8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_LUMINANCE:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R32G32B32A32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadL32FToRGBA32F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE16F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE32F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadL32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadL32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE8_ALPHA8_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadLA8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadLA8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE8_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadL8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadL8ToRGBA8, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE_ALPHA:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R32G32B32A32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadLA32FToRGBA32F, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE_ALPHA16F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_LUMINANCE_ALPHA32F_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadLA32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadLA32FToRGBA32F, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_R11F_G11F_B10F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R11G11B10_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true);
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadRGB32FToRG11B10F, true);
                          loadMap[GL_UNSIGNED_INT_10F_11F_11F_REV] = LoadImageFunctionInfo(LoadToNative<GLuint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R16F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(Load32FTo16F<1>, true);
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLhalf,1>, false);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadToNative<GLhalf,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R16I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLshort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R16UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R16_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R16_SNORM_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R32F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLfloat,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R32I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_INT] = LoadImageFunctionInfo(LoadToNative<GLint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R32UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadToNative<GLuint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R8I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R8UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_R8_SNORM:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG16F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(Load32FTo16F<2>, true);
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLhalf,2>, false);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadToNative<GLhalf,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG16I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLshort,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG16UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG16_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG16_SNORM_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG32F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLfloat,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG32I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_INT] = LoadImageFunctionInfo(LoadToNative<GLint,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG32UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadToNative<GLuint,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG8I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG8UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RG8_SNORM:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,2>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_RGB10_A2:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R10G10B10A2_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadImageFunctionInfo(LoadToNative<GLuint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB10_A2UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R10G10B10A2_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadImageFunctionInfo(LoadToNative<GLuint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB16F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadRGB32FToRGBA16F, true);
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadToNative3To4<GLhalf,gl::Float16One>, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadToNative3To4<GLhalf,gl::Float16One>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB16I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative3To4<GLshort,0x0001>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB16UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative3To4<GLushort,0x0001>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB16_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative3To4<GLushort,0xFFFF>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB16_SNORM_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative3To4<GLushort,0x7FFF>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB32F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadToNative3To4<GLfloat,gl::Float32One>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB32I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_INT] = LoadImageFunctionInfo(LoadToNative3To4<GLint,0x00000001>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB32UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadToNative3To4<GLuint,0x00000001>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB565:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_B5G6R5_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadImageFunctionInfo(LoadToNative<GLushort,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadImageFunctionInfo(LoadR5G6B5ToRGBA8, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB5_A1:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_B5G5R5A1_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadImageFunctionInfo(LoadRGB5A1ToA1RGB5, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadImageFunctionInfo(LoadRGB10A2ToRGBA8, true);
                          loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB8I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLbyte,0x01>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB8UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0x01>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB8_SNORM:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLbyte,0x7F>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGB9_E5:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true);
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadRGB32FToRGB9E5, true);
                          loadMap[GL_UNSIGNED_INT_5_9_9_9_REV] = LoadImageFunctionInfo(LoadToNative<GLuint,1>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadImageFunctionInfo(UnreachableLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
          case GL_RGBA16F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(Load32FTo16F<4>, true);
                          loadMap[GL_HALF_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLhalf,4>, false);
                          loadMap[GL_HALF_FLOAT_OES] = LoadImageFunctionInfo(LoadToNative<GLhalf,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA16I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLshort,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA16UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA16_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA16_SNORM_EXT:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R16G16B16A16_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_SHORT] = LoadImageFunctionInfo(LoadToNative<GLushort,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA32F:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_FLOAT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_FLOAT] = LoadImageFunctionInfo(LoadToNative<GLfloat,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA32I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_INT] = LoadImageFunctionInfo(LoadToNative<GLint,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA32UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R32G32B32A32_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_INT] = LoadImageFunctionInfo(LoadToNative<GLuint,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA4:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_B4G4R4A4_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadImageFunctionInfo(LoadRGBA4ToARGB4, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true);
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA8I:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_SINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA8UI:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UINT:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_RGBA8_SNORM:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_SNORM:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_BYTE] = LoadImageFunctionInfo(LoadToNative<GLbyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_SRGB8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_SRGB8_ALPHA8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[GL_UNSIGNED_BYTE] = LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                      break;
              }
          }
          case GL_STENCIL_INDEX8:
          {
              switch (dxgiFormat)
              {
                  case DXGI_FORMAT_UNKNOWN:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[DXGI_FORMAT_D24_UNORM_S8_UINT] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          loadMap[DXGI_FORMAT_R24G8_TYPELESS] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
                  default:
                  {
                      static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = []() {
                          std::map<GLenum, LoadImageFunctionInfo> loadMap;
                          loadMap[DXGI_FORMAT_D24_UNORM_S8_UINT] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          loadMap[DXGI_FORMAT_R24G8_TYPELESS] = LoadImageFunctionInfo(UnimplementedLoadFunction, true);
                          return loadMap;
                      }();
  
                      return loadFunctionsMap;
                  }
              }
          }
  
          default:
          {
              static std::map<GLenum, LoadImageFunctionInfo> emptyLoadFunctionsMap;
              return emptyLoadFunctionsMap;
          }
      }
      // clang-format on
  
  }  // GetLoadFunctionsMap
  
  }  // namespace d3d11
  
  }  // namespace rx
  

Download