Changed GetTextureFormatInfo to use static switch

src/libANGLE/renderer/d3d/d3d11/gen_load_functions_table.py

+#!/usr/bin/python
+# 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.
+#
+# gen_load_functions_table.py:
+#  Code generation for the load function tables used for texture formats
+#
+
+import json
+
+template = """// 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/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, LoadImageFunction> &GetLoadFunctionsMap(GLenum {internal_format},
+                                                               DXGI_FORMAT {dxgi_format})
+{{
+    // clang-format off
+    switch ({internal_format})
+    {{
+{data}
+        default:
+        {{
+            static std::map<GLenum, LoadImageFunction> emptyLoadFunctionsMap;
+            return emptyLoadFunctionsMap;
+        }}
+    }}
+    // clang-format on
+
+}}  // GetLoadFunctionsMap
+
+}}  // namespace d3d11
+
+}}  // namespace rx
+"""
+
+internal_format_param = 'internalFormat'
+dxgi_format_param = 'dxgiFormat'
+dxgi_format_unknown = "DXGI_FORMAT_UNKNOWN"
+
+def get_function_maps_string(typestr, function):
+    return '                        loadMap[' + typestr + '] = ' + function + ';\n'
+
+def get_unknown_format_string(dxgi_to_type_map, dxgi_unknown_string):
+     if dxgi_unknown_string not in dxgi_to_type_map:
+        return ''
+
+     table_data = ''
+
+     for unknown_type_function in dxgi_to_type_map[dxgi_unknown_string]:
+        table_data += get_function_maps_string(unknown_type_function['type'], unknown_type_function['loadFunction'])
+
+     return table_data
+
+# Making map from dxgi to type map for a particular internalFormat
+def create_dxgi_to_type_map(dst, json_data, internal_format_str):
+    for type_item in sorted(json_data[internal_format_str].iteritems()):
+        for entry_in_type_item in type_item[1]:
+            dxgi_format_str = entry_in_type_item['dxgiFormat']
+
+            if dxgi_format_str not in dst:
+                dst[dxgi_format_str] = []
+
+            type_dxgi_load_function = entry_in_type_item.copy();
+            type_dxgi_load_function['type'] = type_item[0]
+            dst[dxgi_format_str].append(type_dxgi_load_function)
+
+def get_load_function_map_snippet(insert_map_string):
+    load_function_map_snippet = ''
+    load_function_map_snippet += '                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {\n'
+    load_function_map_snippet += '                        std::map<GLenum, LoadImageFunction> loadMap;\n'
+    load_function_map_snippet += insert_map_string
+    load_function_map_snippet += '                        return loadMap;\n'
+    load_function_map_snippet += '                    }();\n\n'
+    load_function_map_snippet += '                    return loadFunctionsMap;\n'
+
+    return load_function_map_snippet
+
+def parse_json_into_switch_string(json_data):
+    table_data = ''
+    for internal_format_item in sorted(json_data.iteritems()):
+        internal_format_str = internal_format_item[0]
+        table_data += '        case ' + internal_format_str + ':\n'
+        table_data += '        {\n'
+        table_data += '            switch (' + dxgi_format_param + ')\n'
+        table_data += '            {\n'
+
+        dxgi_to_type_map = {};
+        create_dxgi_to_type_map(dxgi_to_type_map, json_data, internal_format_str)
+
+        dxgi_unknown_str = get_unknown_format_string(dxgi_to_type_map, dxgi_format_unknown);
+
+        for dxgi_format_item in sorted(dxgi_to_type_map.iteritems()):
+            dxgi_format_str = dxgi_format_item[0]
+
+            # Main case statements
+            table_data += '                case ' + dxgi_format_str + ':\n'
+            table_data += '                {\n'
+            insert_map_string = ''
+            types_already_in_loadmap = set()
+            for type_function in sorted(dxgi_format_item[1]):
+                # type_function['requiresConversion'] element is not in use at the moment but may be needed later
+                insert_map_string += get_function_maps_string(type_function['type'], type_function['loadFunction'])
+                types_already_in_loadmap.add(type_function['type'])
+
+            # DXGI_FORMAT_UNKNOWN add ons
+            if dxgi_format_unknown in dxgi_to_type_map:
+                for unknown_type_function in dxgi_to_type_map[dxgi_format_unknown]:
+                    # Check that it's not already in the loadmap so it doesn't override the value
+                    if unknown_type_function['type'] not in types_already_in_loadmap:
+                        insert_map_string += get_function_maps_string(unknown_type_function['type'], unknown_type_function['loadFunction'])
+
+            table_data += get_load_function_map_snippet(insert_map_string)
+            table_data += '                }\n'
+
+        table_data += '                default:\n'
+
+        if dxgi_unknown_str:
+            table_data += '                {\n'
+            table_data += get_load_function_map_snippet(dxgi_unknown_str)
+            table_data += '                }\n'
+        else:
+            table_data += '                    break;\n'
+        table_data += '            }\n'
+        table_data += '        }\n'
+
+    return table_data
+
+with open('load_functions_data.json') as functions_json_file:
+    functions_data = functions_json_file.read();
+    functions_json_file.close()
+    json_data = json.loads(functions_data)
+
+    table_data = parse_json_into_switch_string(json_data)
+    output = template.format(internal_format = internal_format_param,
+                             dxgi_format = dxgi_format_param,
+                             data=table_data)
+
+    with open('load_functions_table_autogen.cpp', 'wt') as out_file:
+        out_file.write(output)
+        out_file.close()

src/libANGLE/renderer/d3d/d3d11/gen_swizzle_format_table.py

+#!/usr/bin/python
+# 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.
+#
+# gen_swizzle_format_table.py:
+#  Code generation for the swizzle format table used for texture formats
+#
+
+import json
+import pprint
+
+template = """// GENERATED FILE - DO NOT EDIT
+// Generated by gen_swizzle_format_table.py using data from swizzle_format_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.
+//
+// swizzle_format_info:
+//   Provides information for swizzle format and a map from type->formatinfo
+//
+
+#include "libANGLE/renderer/d3d/d3d11/swizzle_format_info.h"
+
+#include <GLES3/gl3.h>
+
+namespace rx
+{{
+
+namespace d3d11
+{{
+
+SwizzleSizeType::SwizzleSizeType() : maxComponentSize(0), componentType(GL_NONE)
+{{
+}}
+
+SwizzleSizeType::SwizzleSizeType(size_t maxComponentSize, GLenum componentType)
+    : maxComponentSize(maxComponentSize), componentType(componentType)
+{{
+}}
+
+bool SwizzleSizeType::operator<(const SwizzleSizeType &other) const
+{{
+    return (maxComponentSize != other.maxComponentSize)
+               ? (maxComponentSize < other.maxComponentSize)
+               : (componentType < other.componentType);
+}}
+
+SwizzleFormatInfo::SwizzleFormatInfo()
+    : mTexFormat(DXGI_FORMAT_UNKNOWN),
+      mSRVFormat(DXGI_FORMAT_UNKNOWN),
+      mRTVFormat(DXGI_FORMAT_UNKNOWN)
+{{
+}}
+
+SwizzleFormatInfo::SwizzleFormatInfo(DXGI_FORMAT texFormat,
+                                     DXGI_FORMAT srvFormat,
+                                     DXGI_FORMAT rtvFormat)
+    : mTexFormat(texFormat), mSRVFormat(srvFormat), mRTVFormat(rtvFormat)
+{{
+}}
+
+const SwizzleFormatInfo &GetSwizzleFormatInfo(GLuint maxBits, GLenum componentType)
+{{
+    // clang-format off
+    switch ({component_type_param})
+    {{
+{data}
+        default:
+        {{
+            static const SwizzleFormatInfo defaultInfo(DXGI_FORMAT_UNKNOWN,
+                                                       DXGI_FORMAT_UNKNOWN,
+                                                       DXGI_FORMAT_UNKNOWN);
+            return defaultInfo;
+        }}
+    }}
+    // clang-format on
+
+}}  // GetSwizzleFormatInfo
+
+}}  // namespace d3d11
+
+}}  // namespace rx
+"""
+
+max_bits_param = 'maxBits'
+component_type_param = 'componentType'
+
+tex_format_key = 'texFormat'
+srv_format_key = 'srvFormat'
+rtv_format_key = 'rtvFormat'
+
+
+def parse_json_into_switch_string(json_data):
+    table_data = ''
+    for component_type in sorted(json_data.iteritems()):
+        type_str = component_type[0]
+        table_data += '        case ' + type_str + ':\n'
+        table_data += '        {\n'
+
+        table_data += '            switch (' + max_bits_param + ')\n'
+        table_data += '            {\n'
+
+        for max_width_item in sorted(json_data[type_str].iteritems()):
+            max_width = max_width_item[0]
+            table_data += '                case ' + max_width + ':\n'
+            table_data += '                {\n'
+            table_data += '                    static const SwizzleFormatInfo formatInfo(' + json_data[type_str][max_width][tex_format_key] + ',\n'
+            table_data += '                                                              ' + json_data[type_str][max_width][srv_format_key] + ',\n'
+            table_data += '                                                              ' + json_data[type_str][max_width][rtv_format_key] + ');\n'
+            table_data += '                    return formatInfo;\n'
+
+            table_data += '                }\n'
+        table_data += '                default:\n'
+        table_data += '                    break;\n'
+        table_data += '            }\n'
+        table_data += '        }\n'
+
+    return table_data
+
+with open('swizzle_format_data.json') as functions_json_file:
+    functions_data = functions_json_file.read();
+    functions_json_file.close()
+    json_data = json.loads(functions_data)
+
+    table_data = parse_json_into_switch_string(json_data)
+    output = template.format(component_type_param=component_type_param,
+                             data=table_data)
+
+    with open('swizzle_format_info_autogen.cpp', 'wt') as out_file:
+        out_file.write(output)
+        out_file.close()

src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py

+#!/usr/bin/python
+# 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.
+#
+# gen_texture_format_table.py:
+#  Code generation for texture format map
+#
+
+import json
+import pprint
+
+template = """// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_texture_format_table.py using data from texture_format_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.
+//
+// texture_format_table:
+//   Queries for full textureFormat information based in internalFormat
+//
+
+#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
+
+#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
+#include "libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.h"
+#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h"
+#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
+#include "libANGLE/renderer/d3d/d3d11/swizzle_format_info.h"
+#include "libANGLE/renderer/d3d/loadimage.h"
+
+namespace rx
+{{
+
+namespace d3d11
+{{
+
+namespace
+{{
+
+typedef bool (*FormatSupportFunction)(const Renderer11DeviceCaps &);
+
+bool AnyDevice(const Renderer11DeviceCaps &deviceCaps)
+{{
+    return true;
+}}
+
+bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps)
+{{
+    return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0);
+}}
+
+bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps)
+{{
+    return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3);
+}}
+
+template <DXGI_FORMAT format, bool requireSupport>
+bool SupportsFormat(const Renderer11DeviceCaps &deviceCaps)
+{{
+    // Must support texture, SRV and RTV support
+    UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE |
+                       D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP |
+                       D3D11_FORMAT_SUPPORT_RENDER_TARGET;
+
+    if (d3d11_gl::GetMaximumClientVersion(deviceCaps.featureLevel) > 2)
+    {{
+        mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D;
+    }}
+
+    bool fullSupport = false;
+    if (format == DXGI_FORMAT_B5G6R5_UNORM)
+    {{
+        // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but
+        // check anyway.
+        mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN;
+        fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport);
+    }}
+    else if (format == DXGI_FORMAT_B4G4R4A4_UNORM)
+    {{
+        fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport);
+    }}
+    else if (format == DXGI_FORMAT_B5G5R5A1_UNORM)
+    {{
+        fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport);
+    }}
+    else
+    {{
+        UNREACHABLE();
+        return false;
+    }}
+
+    // This 'SupportsFormat' function is used by individual entries in the D3D11 Format Map below,
+    // which maps GL formats to DXGI formats.
+    if (requireSupport)
+    {{
+        // This means that ANGLE would like to use the entry in the map if the inputted DXGI format
+        // *IS* supported.
+        // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if
+        // DXGI_FORMAT_B5G5R5A1 is supported.
+        // In this case, we should only return 'true' if the format *IS* supported.
+        return fullSupport;
+    }}
+    else
+    {{
+        // This means that ANGLE would like to use the entry in the map if the inputted DXGI format
+        // *ISN'T* supported.
+        // This might be a fallback entry. e.g. for ANGLE to use DXGI_FORMAT_R8G8B8A8_UNORM if
+        // DXGI_FORMAT_B5G5R5A1 isn't supported.
+        // In this case, we should only return 'true' if the format *ISN'T* supported.
+        return !fullSupport;
+    }}
+}}
+
+// End Format Support Functions
+
+// For sized GL internal formats, there are several possible corresponding D3D11 formats depending
+// on device capabilities.
+// This function allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and
+// DSVs given a GL internal format.
+const TextureFormat GetD3D11FormatInfo(GLenum internalFormat,
+                                       DXGI_FORMAT texFormat,
+                                       DXGI_FORMAT srvFormat,
+                                       DXGI_FORMAT rtvFormat,
+                                       DXGI_FORMAT dsvFormat)
+{{
+    TextureFormat info;
+    info.texFormat = texFormat;
+    info.srvFormat = srvFormat;
+    info.rtvFormat = rtvFormat;
+    info.dsvFormat = dsvFormat;
+
+    // Given a GL internal format, the renderFormat is the DSV format if it is depth- or
+    // stencil-renderable,
+    // the RTV format if it is color-renderable, and the (nonrenderable) texture format otherwise.
+    if (dsvFormat != DXGI_FORMAT_UNKNOWN)
+    {{
+        info.renderFormat = dsvFormat;
+    }}
+    else if (rtvFormat != DXGI_FORMAT_UNKNOWN)
+    {{
+        info.renderFormat = rtvFormat;
+    }}
+    else if (texFormat != DXGI_FORMAT_UNKNOWN)
+    {{
+        info.renderFormat = texFormat;
+    }}
+    else
+    {{
+        info.renderFormat = DXGI_FORMAT_UNKNOWN;
+    }}
+
+    // Compute the swizzle formats
+    const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
+    if (internalFormat != GL_NONE && formatInfo.pixelBytes > 0)
+    {{
+        if (formatInfo.componentCount != 4 || texFormat == DXGI_FORMAT_UNKNOWN ||
+            srvFormat == DXGI_FORMAT_UNKNOWN || rtvFormat == DXGI_FORMAT_UNKNOWN)
+        {{
+            // Get the maximum sized component
+            unsigned int maxBits = 1;
+            if (formatInfo.compressed)
+            {{
+                unsigned int compressedBitsPerBlock = formatInfo.pixelBytes * 8;
+                unsigned int blockSize =
+                    formatInfo.compressedBlockWidth * formatInfo.compressedBlockHeight;
+                maxBits = std::max(compressedBitsPerBlock / blockSize, maxBits);
+            }}
+            else
+            {{
+                maxBits = std::max(maxBits, formatInfo.alphaBits);
+                maxBits = std::max(maxBits, formatInfo.redBits);
+                maxBits = std::max(maxBits, formatInfo.greenBits);
+                maxBits = std::max(maxBits, formatInfo.blueBits);
+                maxBits = std::max(maxBits, formatInfo.luminanceBits);
+                maxBits = std::max(maxBits, formatInfo.depthBits);
+            }}
+
+            maxBits = roundUp(maxBits, 8U);
+
+            const SwizzleFormatInfo &swizzleInfo =
+                GetSwizzleFormatInfo(maxBits, formatInfo.componentType);
+            info.swizzleTexFormat = swizzleInfo.mTexFormat;
+            info.swizzleSRVFormat = swizzleInfo.mSRVFormat;
+            info.swizzleRTVFormat = swizzleInfo.mRTVFormat;
+        }}
+        else
+        {{
+            // The original texture format is suitable for swizzle operations
+            info.swizzleTexFormat = texFormat;
+            info.swizzleSRVFormat = srvFormat;
+            info.swizzleRTVFormat = rtvFormat;
+        }}
+    }}
+    else
+    {{
+        // Not possible to swizzle with this texture format since it is either unsized or GL_NONE
+        info.swizzleTexFormat = DXGI_FORMAT_UNKNOWN;
+        info.swizzleSRVFormat = DXGI_FORMAT_UNKNOWN;
+        info.swizzleRTVFormat = DXGI_FORMAT_UNKNOWN;
+    }}
+
+    // Check if there is an initialization function for this texture format
+    info.dataInitializerFunction = GetInternalFormatInitializer(internalFormat, texFormat);
+    // Gather all the load functions for this internal format
+    info.loadFunctions = GetLoadFunctionsMap(internalFormat, texFormat);
+
+    ASSERT(info.loadFunctions.size() != 0 || internalFormat == GL_NONE);
+
+    return info;
+}}
+
+}}  // namespace
+
+TextureFormat::TextureFormat()
+    : texFormat(DXGI_FORMAT_UNKNOWN),
+      srvFormat(DXGI_FORMAT_UNKNOWN),
+      rtvFormat(DXGI_FORMAT_UNKNOWN),
+      dsvFormat(DXGI_FORMAT_UNKNOWN),
+      renderFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleTexFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleSRVFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleRTVFormat(DXGI_FORMAT_UNKNOWN),
+      dataInitializerFunction(NULL),
+      loadFunctions()
+{{
+}}
+
+const TextureFormat &GetTextureFormatInfo(GLenum internalFormat,
+                                          const Renderer11DeviceCaps &renderer11DeviceCaps)
+{{
+    // clang-format off
+    switch (internalFormat)
+    {{
+{data}
+        default:
+            break;
+    }}
+    // clang-format on
+
+    static const TextureFormat defaultInfo;
+    return defaultInfo;
+}}  // GetTextureFormatInfo
+
+}}  // namespace d3d11
+
+}}  // namespace rx
+"""
+
+tex_format = "texFormat"
+srv_format = "srvFormat"
+rtv_format = "rtvFormat"
+dsv_format = "dsvFormat"
+
+def get_texture_format_item(idx, texture_format):
+    table_data = '';
+
+    if idx == 0:
+        table_data += '            if (' + texture_format["requirementsFcn"] + '(renderer11DeviceCaps))\n'
+    else:
+        table_data += '            else if (' + texture_format["requirementsFcn"] + '(renderer11DeviceCaps))\n'
+    table_data += '            {\n'
+    table_data += '                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,\n'
+    table_data += '                                                                               ' + texture_format[tex_format] + ',\n'
+    table_data += '                                                                               ' + texture_format[srv_format] + ',\n'
+    table_data += '                                                                               ' + texture_format[rtv_format] + ',\n'
+    table_data += '                                                                               ' + texture_format[dsv_format] + ');\n'
+    table_data += '                return textureFormat;\n'
+    table_data += '            }\n'
+
+    return table_data
+
+def parse_json_into_switch_string(json_data):
+    table_data = ''
+    for internal_format_item in sorted(json_data.iteritems()):
+        internal_format = internal_format_item[0]
+        table_data += '        case ' + internal_format + ':\n'
+        table_data += '        {\n'
+
+        for idx, texture_format in enumerate(sorted(json_data[internal_format])):
+            table_data += get_texture_format_item(idx, texture_format)
+
+        table_data += '            else\n'
+        table_data += '            {\n'
+        table_data += '                break;\n'
+        table_data += '            }\n'
+        table_data += '        }\n'
+
+    return table_data
+
+with open('texture_format_data.json') as texture_format_json_file:
+    texture_format_data = texture_format_json_file.read();
+    texture_format_json_file.close()
+    json_data = json.loads(texture_format_data)
+
+    table_data = parse_json_into_switch_string(json_data)
+    output = template.format(data=table_data)
+
+    with open('texture_format_table_autogen.cpp', 'wt') as out_file:
+        out_file.write(output)
+        out_file.close()

src/libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.cpp

+//
+// Copyright 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// internal_format_initializer_table:
+//   Contains table to go from internal format and dxgi format to initializer function
+//   for TextureFormat
+//
+
+#include "libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.h"
+#include "libANGLE/renderer/d3d/loadimage.h"
+
+namespace rx
+{
+
+namespace d3d11
+{
+
+// TODO: This should be generated by a JSON file
+InitializeTextureDataFunction GetInternalFormatInitializer(GLenum internalFormat,
+                                                           DXGI_FORMAT dxgiFormat)
+{
+    switch (internalFormat)
+    {
+        case GL_RGB8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    return Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB565:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    return Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_SRGB8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                {
+                    return Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_FLOAT:
+                {
+                    return Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    return Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000,
+                                                    gl::Float32One>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UINT:
+                {
+                    return Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0x01>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_SINT:
+                {
+                    return Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x01>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_UINT:
+                {
+                    return Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x0001>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_SINT:
+                {
+                    return Initialize4ComponentData<GLshort, 0x0000, 0x0000, 0x0000, 0x0001>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_UINT:
+                {
+                    return Initialize4ComponentData<GLuint, 0x00000000, 0x00000000, 0x00000000,
+                                                    0x00000001>;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_SINT:
+                {
+                    return Initialize4ComponentData<GLint, 0x00000000, 0x00000000, 0x00000000,
+                                                    0x00000001>;
+                }
+                default:
+                    break;
+            }
+        }
+        default:
+        {
+            return nullptr;
+        }
+    }
+}
+
+}  // namespace d3d11
+
+}  // namespace rx

src/libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.h

+//
+// 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.
+//
+// internal_format_initializer_table:
+//   Contains table to go from internal format and dxgi format to initializer function
+//   for TextureFormat
+//
+
+#ifndef LIBANGLE_RENDERER_D3D_D3D11_INTERNALFORMATINITIALIZERTABLE_H_
+#define LIBANGLE_RENDERER_D3D_D3D11_INTERNALFORMATINITIALIZERTABLE_H_
+
+#include "libANGLE/renderer/d3d/d3d11/renderer11.h"
+
+#include <map>
+
+namespace rx
+{
+
+namespace d3d11
+{
+
+InitializeTextureDataFunction GetInternalFormatInitializer(GLenum internalFormat,
+                                                           DXGI_FORMAT dxgiFormat);
+
+}  // namespace d3d11
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_D3D_D3D11_INTERNALFORMATINITIALIZERTABLE_H_

src/libANGLE/renderer/d3d/d3d11/load_functions_data.json

+{
+  "GL_RG8_SNORM": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,2>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_SNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_SRGB8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLubyte,0xFF>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA8I": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_R8_SNORM": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,1>",
+        "dxgiFormat": "DXGI_FORMAT_R8_SNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGBA8_SNORM": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_R16I": {
+    "GL_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLshort,1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2SRGBA8ToSRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2RGB8A1ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB32UI": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLuint,0x00000001>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_ALPHA32F_EXT": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadA32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R16UI": {
+    "GL_UNSIGNED_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLushort,1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB9_E5": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadRGB16FToRGB9E5",
+        "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_INT_5_9_9_9_REV": [
+      {
+        "loadFunction": "LoadToNative<GLuint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadRGB32FToRGB9E5",
+        "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadRGB16FToRGB9E5",
+        "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_R11_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadEACR11ToR8",
+        "dxgiFormat": "DXGI_FORMAT_R8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA32UI": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadToNative<GLuint,4>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RG8UI": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,2>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE32F_EXT": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadL32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2SRGB8A1ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R16F": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "Load32FTo16F<1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGBA8UI": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_BGRA4_ANGLEX": {
+    "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT": [
+      {
+        "loadFunction": "LoadRGBA4ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGBA16F": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,4>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "Load32FTo16F<4>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,4>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE8_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadL8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadCompressedToNative<4,4,16>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_5_6_5": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB5_A1": {
+    "GL_UNSIGNED_INT_2_10_10_10_REV": [
+      {
+        "loadFunction": "LoadRGB10A2ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_5_5_5_1": [
+      {
+        "loadFunction": "LoadRGB5A1ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      },
+      {
+        "loadFunction": "LoadRGB5A1ToA1RGB5",
+        "dxgiFormat": "DXGI_FORMAT_B5G5R5A1_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB16UI": {
+    "GL_UNSIGNED_SHORT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLushort,0x0001>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_BGRA_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGB8_ETC2": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2RGB8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA32F": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLfloat,4>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGBA32I": {
+    "GL_INT": [
+      {
+        "loadFunction": "LoadToNative<GLint,4>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE8_ALPHA8_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadLA8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,2>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB10_A2": {
+    "GL_UNSIGNED_INT_2_10_10_10_REV": [
+      {
+        "loadFunction": "LoadToNative<GLuint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R10G10B10A2_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_COMPRESSED_SIGNED_RG11_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadEACRG11SToRG8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_SNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_DEPTH_COMPONENT16": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadR32ToR16",
+        "dxgiFormat": "DXGI_FORMAT_R16_TYPELESS",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLushort,1>",
+        "dxgiFormat": "DXGI_FORMAT_R16_TYPELESS",
+        "requiresConversion": "false"
+      },
+      {
+        "loadFunction": "LoadToNative<GLushort,1>",
+        "dxgiFormat": "DXGI_FORMAT_D16_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB32I": {
+    "GL_INT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLint,0x00000001>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,1>",
+        "dxgiFormat": "DXGI_FORMAT_R8_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB32F": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLfloat,gl::Float32One>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R11F_G11F_B10F": {
+    "GL_UNSIGNED_INT_10F_11F_11F_REV": [
+      {
+        "loadFunction": "LoadToNative<GLuint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadRGB16FToRG11B10F",
+        "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadRGB32FToRG11B10F",
+        "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadRGB16FToRG11B10F",
+        "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLubyte,0xFF>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_LUMINANCE_ALPHA": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadLA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadLA32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadLA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA16I": {
+    "GL_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLshort,4>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_R8I": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,1>",
+        "dxgiFormat": "DXGI_FORMAT_R8_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB8_SNORM": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLbyte,0x7F>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG32F": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLfloat,2>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_DEPTH_COMPONENT32F": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLfloat,1>",
+        "dxgiFormat": "DXGI_FORMAT_R32_TYPELESS",
+        "requiresConversion": "false"
+      },
+      {
+        "loadFunction": "UnimplementedLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG32I": {
+    "GL_INT": [
+      {
+        "loadFunction": "LoadToNative<GLint,2>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_ALPHA8_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,1>",
+        "dxgiFormat": "DXGI_FORMAT_A8_UNORM",
+        "requiresConversion": "false"
+      },
+      {
+        "loadFunction": "LoadA8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG32UI": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadToNative<GLuint,2>",
+        "dxgiFormat": "DXGI_FORMAT_R32G32_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGBA16UI": {
+    "GL_UNSIGNED_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLushort,4>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGBA8_ETC2_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2RGBA8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB8I": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLbyte,0x01>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_SRGB8_ETC2": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadETC2SRGB8ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_DEPTH32F_STENCIL8": {
+    "GL_FLOAT_32_UNSIGNED_INT_24_8_REV": [
+      {
+        "loadFunction": "LoadToNative<GLuint,2>",
+        "dxgiFormat": "DXGI_FORMAT_R32G8X24_TYPELESS",
+        "requiresConversion": "false"
+      },
+      {
+        "loadFunction": "UnimplementedLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG8I": {
+    "GL_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLbyte,2>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_R32UI": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadToNative<GLuint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R32_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_BGR5_A1_ANGLEX": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT": [
+      {
+        "loadFunction": "LoadRGB5A1ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RG11_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadEACRG11ToRG8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_SRGB8_ALPHA8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE_ALPHA16F_EXT": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadLA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadLA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_4_4_4_4": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_5_5_5_1": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_DEPTH24_STENCIL8": {
+    "GL_UNSIGNED_INT_24_8": [
+      {
+        "loadFunction": "LoadR32ToR24G8",
+        "dxgiFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+        "requiresConversion": "true"
+      },
+      {
+        "loadFunction": "LoadR32ToR24G8",
+        "dxgiFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB16I": {
+    "GL_SHORT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLshort,0x0001>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R8UI": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,1>",
+        "dxgiFormat": "DXGI_FORMAT_R8_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_ALPHA": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadA32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB16F": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadToNative3To4<GLhalf,gl::Float16One>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadRGB32FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadToNative3To4<GLhalf,gl::Float16One>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_SIGNED_R11_EAC": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadEACR11SToR8",
+        "dxgiFormat": "DXGI_FORMAT_R8_SNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGB_S3TC_DXT1_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadCompressedToNative<4,4,8>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadCompressedToNative<4,4,8>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_STENCIL_INDEX8": {
+    "DXGI_FORMAT_R24G8_TYPELESS": [
+      {
+        "loadFunction": "UnimplementedLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "DXGI_FORMAT_D24_UNORM_S8_UINT": [
+      {
+        "loadFunction": "UnimplementedLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_LUMINANCE_ALPHA32F_EXT": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadLA32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB8UI": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLubyte,0x01>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_DEPTH_COMPONENT24": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadR32ToR24G8",
+        "dxgiFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+        "requiresConversion": "true"
+      },
+      {
+        "loadFunction": "LoadR32ToR24G8",
+        "dxgiFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R32I": {
+    "GL_INT": [
+      {
+        "loadFunction": "LoadToNative<GLint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R32_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_DEPTH_COMPONENT32_OES": {
+    "GL_UNSIGNED_INT": [
+      {
+        "loadFunction": "LoadR32ToR24G8",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_R32F": {
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLfloat,1>",
+        "dxgiFormat": "DXGI_FORMAT_R32_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RG16F": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,2>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "Load32FTo16F<2>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadToNative<GLhalf,2>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_RGB565": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative3To4<GLubyte,0xFF>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_5_6_5": [
+      {
+        "loadFunction": "LoadR5G6B5ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      },
+      {
+        "loadFunction": "LoadToNative<GLushort,1>",
+        "dxgiFormat": "DXGI_FORMAT_B5G6R5_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE16F_EXT": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadL16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadL16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG16UI": {
+    "GL_UNSIGNED_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLushort,2>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadCompressedToNative<4,4,16>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RG16I": {
+    "GL_SHORT": [
+      {
+        "loadFunction": "LoadToNative<GLshort,2>",
+        "dxgiFormat": "DXGI_FORMAT_R16G16_SINT",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_BGRA8_EXT": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_ALPHA16F_EXT": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadA16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA4": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "false"
+      }
+    ],
+    "GL_UNSIGNED_SHORT_4_4_4_4": [
+      {
+        "loadFunction": "LoadRGBA4ToRGBA8",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "true"
+      },
+      {
+        "loadFunction": "LoadRGBA4ToARGB4",
+        "dxgiFormat": "DXGI_FORMAT_B4G4R4A4_UNORM",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGBA8": {
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "LoadToNative<GLubyte,4>",
+        "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+        "requiresConversion": "false"
+      }
+    ]
+  },
+  "GL_LUMINANCE": {
+    "GL_HALF_FLOAT": [
+      {
+        "loadFunction": "LoadL16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_UNSIGNED_BYTE": [
+      {
+        "loadFunction": "UnreachableLoadFunction",
+        "dxgiFormat": "DXGI_FORMAT_UNKNOWN",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_FLOAT": [
+      {
+        "loadFunction": "LoadL32FToRGBA32F",
+        "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+        "requiresConversion": "true"
+      }
+    ],
+    "GL_HALF_FLOAT_OES": [
+      {
+        "loadFunction": "LoadL16FToRGBA16F",
+        "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+        "requiresConversion": "true"
+      }
+    ]
+  },
+  "GL_RGB10_A2UI": {
+    "GL_UNSIGNED_INT_2_10_10_10_REV": [
+      {
+        "loadFunction": "LoadToNative<GLuint,1>",
+        "dxgiFormat": "DXGI_FORMAT_R10G10B10A2_UINT",
+        "requiresConversion": "false"
+      }
+    ]
+  }
+}
\ No newline at end of file

src/libANGLE/renderer/d3d/d3d11/texture_format_util.h → src/libANGLE/renderer/d3d/d3d11/load_functions_table.h

@@ -3,12 +3,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
-// texture_format_util:
-//   Contains helper functions for texture_format_table
+// load_functions_table:
+//   Contains load functions table depending on internal format and dxgi format
 //
 
-#ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATUTIL_H_
-#define LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATUTIL_H_
+#ifndef LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_
+#define LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_
 
 #include <map>
 
@@ -20,20 +20,11 @@ namespace rx
 namespace d3d11
 {
 
-typedef std::pair<DXGI_FORMAT, LoadImageFunction> DxgiFormatLoadFunctionPair;
-typedef std::pair<GLenum, DxgiFormatLoadFunctionPair> GLTypeDXGIFunctionPair;
-typedef std::map<GLenum, std::vector<GLTypeDXGIFunctionPair>> D3D11LoadFunctionMap;
-
-const D3D11LoadFunctionMap &BuildD3D11LoadFunctionMap();
-
-typedef std::pair<GLint, DXGI_FORMAT> InitializeTextureFormatPair;
-typedef std::map<InitializeTextureFormatPair, InitializeTextureDataFunction>
-    InternalFormatInitializerMap;
-
-const InternalFormatInitializerMap &BuildInternalFormatInitializerMap();
+const std::map<GLenum, LoadImageFunction> &GetLoadFunctionsMap(GLenum internalFormat,
+                                                               DXGI_FORMAT dxgiFormat);
 
 }  // namespace d3d11
 
 }  // namespace rx
 
-#endif  // LIBANGLE_RENDERER_D3D_D3D11_TEXTUREFORMATUTIL_H_
+#endif  // LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_

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/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, LoadImageFunction> &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, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadA16FToRGBA16F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadA32FToRGBA32F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_ALPHA16F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadA16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadA16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_ALPHA32F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadA32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadA32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_ALPHA8_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadA8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_BGR5_A1_ANGLEX:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT] = LoadRGB5A1ToRGBA8;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        loadMap[GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT] = LoadRGB5A1ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_BGRA4_ANGLEX:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT] = LoadRGBA4ToRGBA8;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT] = LoadRGBA4ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_BGRA8_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_BGRA_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_COMPRESSED_R11_EAC:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadEACR11ToR8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_RG11_EAC:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadEACRG11ToRG8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_RGB8_ETC2:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2RGB8ToRGBA8;
+                        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, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2RGB8A1ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_RGBA8_ETC2_EAC:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2RGBA8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,8>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,8>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,16>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,16>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,16>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,16>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,8>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadCompressedToNative<4,4,8>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_COMPRESSED_SIGNED_R11_EAC:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadEACR11SToR8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_SIGNED_RG11_EAC:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadEACRG11SToRG8;
+                        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, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2SRGBA8ToSRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_COMPRESSED_SRGB8_ETC2:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2SRGB8ToRGBA8;
+                        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, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadETC2SRGB8A1ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_DEPTH24_STENCIL8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_D24_UNORM_S8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT_24_8] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R24G8_TYPELESS:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT_24_8] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_DEPTH32F_STENCIL8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G8X24_TYPELESS:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = LoadToNative<GLuint,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT_32_UNSIGNED_INT_24_8_REV] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_DEPTH_COMPONENT16:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_D16_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative<GLushort,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R16_TYPELESS:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadR32ToR16;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative<GLushort,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_DEPTH_COMPONENT24:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_D24_UNORM_S8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R24G8_TYPELESS:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_DEPTH_COMPONENT32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32_TYPELESS:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadToNative<GLfloat,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_DEPTH_COMPONENT32_OES:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadR32ToR24G8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadL16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadL16FToRGBA16F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadL32FToRGBA32F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE16F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadL16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadL16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadL16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadL16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE32F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadL32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadL32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE8_ALPHA8_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadLA8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadLA8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE8_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadL8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadL8ToRGBA8;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE_ALPHA:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadLA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadLA16FToRGBA16F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadLA32FToRGBA32F;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE_ALPHA16F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadLA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadLA16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadLA16FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadLA16FToRGBA16F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_LUMINANCE_ALPHA32F_EXT:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadLA32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadLA32FToRGBA32F;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_R11F_G11F_B10F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R11G11B10_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadRGB16FToRG11B10F;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadRGB16FToRG11B10F;
+                        loadMap[GL_FLOAT] = LoadRGB32FToRG11B10F;
+                        loadMap[GL_UNSIGNED_INT_10F_11F_11F_REV] = LoadToNative<GLuint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R16F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = Load32FTo16F<1>;
+                        loadMap[GL_HALF_FLOAT] = LoadToNative<GLhalf,1>;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadToNative<GLhalf,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R16I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_SHORT] = LoadToNative<GLshort,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R16UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative<GLushort,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadToNative<GLfloat,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R32I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_INT] = LoadToNative<GLint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R32UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadToNative<GLuint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R8I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R8UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_R8_SNORM:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG16F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = Load32FTo16F<2>;
+                        loadMap[GL_HALF_FLOAT] = LoadToNative<GLhalf,2>;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadToNative<GLhalf,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG16I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_SHORT] = LoadToNative<GLshort,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG16UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative<GLushort,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadToNative<GLfloat,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG32I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_INT] = LoadToNative<GLint,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG32UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadToNative<GLuint,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG8I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG8UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RG8_SNORM:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,2>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_5_6_5] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_5_6_5] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_RGB10_A2:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R10G10B10A2_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadToNative<GLuint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB10_A2UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R10G10B10A2_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadToNative<GLuint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadRGB32FToRGBA16F;
+                        loadMap[GL_HALF_FLOAT] = LoadToNative3To4<GLhalf,gl::Float16One>;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadToNative3To4<GLhalf,gl::Float16One>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_SHORT] = LoadToNative3To4<GLshort,0x0001>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB16UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative3To4<GLushort,0x0001>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadToNative3To4<GLfloat,gl::Float32One>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_INT] = LoadToNative3To4<GLint,0x00000001>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB32UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadToNative3To4<GLuint,0x00000001>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB565:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_B5G6R5_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadToNative<GLushort,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_5_6_5] = LoadR5G6B5ToRGBA8;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative3To4<GLubyte,0xFF>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB5_A1:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_B5G5R5A1_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadRGB5A1ToA1RGB5;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT_2_10_10_10_REV] = LoadRGB10A2ToRGBA8;
+                        loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = LoadRGB5A1ToRGBA8;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative3To4<GLubyte,0xFF>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative3To4<GLbyte,0x01>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative3To4<GLubyte,0x01>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB8_SNORM:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative3To4<GLbyte,0x7F>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGB9_E5:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R9G9B9E5_SHAREDEXP:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_HALF_FLOAT] = LoadRGB16FToRGB9E5;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadRGB16FToRGB9E5;
+                        loadMap[GL_FLOAT] = LoadRGB32FToRGB9E5;
+                        loadMap[GL_UNSIGNED_INT_5_9_9_9_REV] = LoadToNative<GLuint,1>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = UnreachableLoadFunction;
+                        loadMap[GL_UNSIGNED_SHORT_5_5_5_1] = UnreachableLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+        case GL_RGBA16F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = Load32FTo16F<4>;
+                        loadMap[GL_HALF_FLOAT] = LoadToNative<GLhalf,4>;
+                        loadMap[GL_HALF_FLOAT_OES] = LoadToNative<GLhalf,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA16I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_SHORT] = LoadToNative<GLshort,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA16UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R16G16B16A16_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT] = LoadToNative<GLushort,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA32F:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_FLOAT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_FLOAT] = LoadToNative<GLfloat,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA32I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_INT] = LoadToNative<GLint,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA32UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R32G32B32A32_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_INT] = LoadToNative<GLuint,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA4:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_B4G4R4A4_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadRGBA4ToARGB4;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_SHORT_4_4_4_4] = LoadRGBA4ToRGBA8;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA8I:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_SINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA8UI:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UINT:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_RGBA8_SNORM:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_SNORM:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_BYTE] = LoadToNative<GLbyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_SRGB8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative3To4<GLubyte,0xFF>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_SRGB8_ALPHA8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[GL_UNSIGNED_BYTE] = LoadToNative<GLubyte,4>;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_STENCIL_INDEX8:
+        {
+            switch (dxgiFormat)
+            {
+                case DXGI_FORMAT_UNKNOWN:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[DXGI_FORMAT_D24_UNORM_S8_UINT] = UnimplementedLoadFunction;
+                        loadMap[DXGI_FORMAT_R24G8_TYPELESS] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+                default:
+                {
+                    static const std::map<GLenum, LoadImageFunction> loadFunctionsMap = []() {
+                        std::map<GLenum, LoadImageFunction> loadMap;
+                        loadMap[DXGI_FORMAT_D24_UNORM_S8_UINT] = UnimplementedLoadFunction;
+                        loadMap[DXGI_FORMAT_R24G8_TYPELESS] = UnimplementedLoadFunction;
+                        return loadMap;
+                    }();
+
+                    return loadFunctionsMap;
+                }
+            }
+        }
+
+        default:
+        {
+            static std::map<GLenum, LoadImageFunction> emptyLoadFunctionsMap;
+            return emptyLoadFunctionsMap;
+        }
+    }
+    // clang-format on
+
+}  // GetLoadFunctionsMap
+
+}  // namespace d3d11
+
+}  // namespace rx

src/libANGLE/renderer/d3d/d3d11/swizzle_format_data.json

+{
+  "GL_UNSIGNED_NORMALIZED": {
+    "8": {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM"
+    },
+    "16": {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_UNORM",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UNORM"
+    },
+    "24": {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT"
+    },
+    "32": {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT"
+    }
+  },
+  "GL_SIGNED_NORMALIZED": {
+    "8": {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_SNORM"
+    }
+  },
+  "GL_FLOAT": {
+    "16": {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT"
+    },
+    "32": {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT"
+    }
+  },
+  "GL_UNSIGNED_INT": {
+    "8": {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UINT"
+    },
+    "16": {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UINT"
+    },
+    "32": {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_UINT"
+    }
+  },
+  "GL_INT": {
+    "8": {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_SINT"
+    },
+    "16": {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_SINT"
+    },
+    "32": {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_SINT"
+    }
+  }
+}
\ No newline at end of file

src/libANGLE/renderer/d3d/d3d11/swizzle_format_info.cpp

-//
-// Copyright 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// swizzle_format_info:
-//   Provides information for swizzle format and a map from type->formatinfo
-//
-
-#include "libANGLE/renderer/d3d/d3d11/swizzle_format_info.h"
-
-#include <GLES3/gl3.h>
-
-namespace rx
-{
-
-namespace d3d11
-{
-
-SwizzleSizeType::SwizzleSizeType() : maxComponentSize(0), componentType(GL_NONE)
-{
-}
-
-SwizzleSizeType::SwizzleSizeType(size_t maxComponentSize, GLenum componentType)
-    : maxComponentSize(maxComponentSize), componentType(componentType)
-{
-}
-
-bool SwizzleSizeType::operator<(const SwizzleSizeType &other) const
-{
-    return (maxComponentSize != other.maxComponentSize)
-               ? (maxComponentSize < other.maxComponentSize)
-               : (componentType < other.componentType);
-}
-
-SwizzleFormatInfo::SwizzleFormatInfo()
-    : mTexFormat(DXGI_FORMAT_UNKNOWN),
-      mSRVFormat(DXGI_FORMAT_UNKNOWN),
-      mRTVFormat(DXGI_FORMAT_UNKNOWN)
-{
-}
-
-SwizzleFormatInfo::SwizzleFormatInfo(DXGI_FORMAT texFormat,
-                                     DXGI_FORMAT srvFormat,
-                                     DXGI_FORMAT rtvFormat)
-    : mTexFormat(texFormat), mSRVFormat(srvFormat), mRTVFormat(rtvFormat)
-{
-}
-
-typedef std::pair<SwizzleSizeType, SwizzleFormatInfo> SwizzleInfoPair;
-
-const SwizzleInfoMap &BuildSwizzleInfoMap()
-{
-    static SwizzleInfoMap map;
-
-    map.insert(
-        SwizzleInfoPair(SwizzleSizeType(8, GL_UNSIGNED_NORMALIZED),
-                        SwizzleFormatInfo(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_R8G8B8A8_UNORM,
-                                          DXGI_FORMAT_R8G8B8A8_UNORM)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(16, GL_UNSIGNED_NORMALIZED),
-        SwizzleFormatInfo(DXGI_FORMAT_R16G16B16A16_UNORM, DXGI_FORMAT_R16G16B16A16_UNORM,
-                          DXGI_FORMAT_R16G16B16A16_UNORM)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(24, GL_UNSIGNED_NORMALIZED),
-        SwizzleFormatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT,
-                          DXGI_FORMAT_R32G32B32A32_FLOAT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(32, GL_UNSIGNED_NORMALIZED),
-        SwizzleFormatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT,
-                          DXGI_FORMAT_R32G32B32A32_FLOAT)));
-
-    map.insert(
-        SwizzleInfoPair(SwizzleSizeType(8, GL_SIGNED_NORMALIZED),
-                        SwizzleFormatInfo(DXGI_FORMAT_R8G8B8A8_SNORM, DXGI_FORMAT_R8G8B8A8_SNORM,
-                                          DXGI_FORMAT_R8G8B8A8_SNORM)));
-
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(16, GL_FLOAT),
-        SwizzleFormatInfo(DXGI_FORMAT_R16G16B16A16_FLOAT, DXGI_FORMAT_R16G16B16A16_FLOAT,
-                          DXGI_FORMAT_R16G16B16A16_FLOAT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(32, GL_FLOAT),
-        SwizzleFormatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT, DXGI_FORMAT_R32G32B32A32_FLOAT,
-                          DXGI_FORMAT_R32G32B32A32_FLOAT)));
-
-    map.insert(
-        SwizzleInfoPair(SwizzleSizeType(8, GL_UNSIGNED_INT),
-                        SwizzleFormatInfo(DXGI_FORMAT_R8G8B8A8_UINT, DXGI_FORMAT_R8G8B8A8_UINT,
-                                          DXGI_FORMAT_R8G8B8A8_UINT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(16, GL_UNSIGNED_INT),
-        SwizzleFormatInfo(DXGI_FORMAT_R16G16B16A16_UINT, DXGI_FORMAT_R16G16B16A16_UINT,
-                          DXGI_FORMAT_R16G16B16A16_UINT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(32, GL_UNSIGNED_INT),
-        SwizzleFormatInfo(DXGI_FORMAT_R32G32B32A32_UINT, DXGI_FORMAT_R32G32B32A32_UINT,
-                          DXGI_FORMAT_R32G32B32A32_UINT)));
-
-    map.insert(
-        SwizzleInfoPair(SwizzleSizeType(8, GL_INT),
-                        SwizzleFormatInfo(DXGI_FORMAT_R8G8B8A8_SINT, DXGI_FORMAT_R8G8B8A8_SINT,
-                                          DXGI_FORMAT_R8G8B8A8_SINT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(16, GL_INT),
-        SwizzleFormatInfo(DXGI_FORMAT_R16G16B16A16_SINT, DXGI_FORMAT_R16G16B16A16_SINT,
-                          DXGI_FORMAT_R16G16B16A16_SINT)));
-    map.insert(SwizzleInfoPair(
-        SwizzleSizeType(32, GL_INT),
-        SwizzleFormatInfo(DXGI_FORMAT_R32G32B32A32_SINT, DXGI_FORMAT_R32G32B32A32_SINT,
-                          DXGI_FORMAT_R32G32B32A32_SINT)));
-
-    return map;
-}
-
-}  // namespace d3d11
-
-}  // namespace rx

src/libANGLE/renderer/d3d/d3d11/swizzle_format_info.h

@@ -42,9 +42,7 @@ struct SwizzleFormatInfo
     SwizzleFormatInfo(DXGI_FORMAT texFormat, DXGI_FORMAT srvFormat, DXGI_FORMAT rtvFormat);
 };
 
-typedef std::map<SwizzleSizeType, SwizzleFormatInfo> SwizzleInfoMap;
-
-const SwizzleInfoMap &BuildSwizzleInfoMap();
+const SwizzleFormatInfo &GetSwizzleFormatInfo(GLuint maxBits, GLenum componentType);
 
 }  // namespace d3d11
 

src/libANGLE/renderer/d3d/d3d11/swizzle_format_info_autogen.cpp

+// GENERATED FILE - DO NOT EDIT
+// Generated by gen_swizzle_format_table.py using data from swizzle_format_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.
+//
+// swizzle_format_info:
+//   Provides information for swizzle format and a map from type->formatinfo
+//
+
+#include "libANGLE/renderer/d3d/d3d11/swizzle_format_info.h"
+
+#include <GLES3/gl3.h>
+
+namespace rx
+{
+
+namespace d3d11
+{
+
+SwizzleSizeType::SwizzleSizeType() : maxComponentSize(0), componentType(GL_NONE)
+{
+}
+
+SwizzleSizeType::SwizzleSizeType(size_t maxComponentSize, GLenum componentType)
+    : maxComponentSize(maxComponentSize), componentType(componentType)
+{
+}
+
+bool SwizzleSizeType::operator<(const SwizzleSizeType &other) const
+{
+    return (maxComponentSize != other.maxComponentSize)
+               ? (maxComponentSize < other.maxComponentSize)
+               : (componentType < other.componentType);
+}
+
+SwizzleFormatInfo::SwizzleFormatInfo()
+    : mTexFormat(DXGI_FORMAT_UNKNOWN),
+      mSRVFormat(DXGI_FORMAT_UNKNOWN),
+      mRTVFormat(DXGI_FORMAT_UNKNOWN)
+{
+}
+
+SwizzleFormatInfo::SwizzleFormatInfo(DXGI_FORMAT texFormat,
+                                     DXGI_FORMAT srvFormat,
+                                     DXGI_FORMAT rtvFormat)
+    : mTexFormat(texFormat), mSRVFormat(srvFormat), mRTVFormat(rtvFormat)
+{
+}
+
+const SwizzleFormatInfo &GetSwizzleFormatInfo(GLuint maxBits, GLenum componentType)
+{
+    // clang-format off
+    switch (componentType)
+    {
+        case GL_FLOAT:
+        {
+            switch (maxBits)
+            {
+                case 16:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                              DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                              DXGI_FORMAT_R16G16B16A16_FLOAT);
+                    return formatInfo;
+                }
+                case 32:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT);
+                    return formatInfo;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_INT:
+        {
+            switch (maxBits)
+            {
+                case 16:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R16G16B16A16_SINT,
+                                                              DXGI_FORMAT_R16G16B16A16_SINT,
+                                                              DXGI_FORMAT_R16G16B16A16_SINT);
+                    return formatInfo;
+                }
+                case 32:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R32G32B32A32_SINT,
+                                                              DXGI_FORMAT_R32G32B32A32_SINT,
+                                                              DXGI_FORMAT_R32G32B32A32_SINT);
+                    return formatInfo;
+                }
+                case 8:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R8G8B8A8_SINT,
+                                                              DXGI_FORMAT_R8G8B8A8_SINT,
+                                                              DXGI_FORMAT_R8G8B8A8_SINT);
+                    return formatInfo;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_SIGNED_NORMALIZED:
+        {
+            switch (maxBits)
+            {
+                case 8:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                              DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                              DXGI_FORMAT_R8G8B8A8_SNORM);
+                    return formatInfo;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_UNSIGNED_INT:
+        {
+            switch (maxBits)
+            {
+                case 16:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R16G16B16A16_UINT,
+                                                              DXGI_FORMAT_R16G16B16A16_UINT,
+                                                              DXGI_FORMAT_R16G16B16A16_UINT);
+                    return formatInfo;
+                }
+                case 32:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R32G32B32A32_UINT,
+                                                              DXGI_FORMAT_R32G32B32A32_UINT,
+                                                              DXGI_FORMAT_R32G32B32A32_UINT);
+                    return formatInfo;
+                }
+                case 8:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R8G8B8A8_UINT,
+                                                              DXGI_FORMAT_R8G8B8A8_UINT,
+                                                              DXGI_FORMAT_R8G8B8A8_UINT);
+                    return formatInfo;
+                }
+                default:
+                    break;
+            }
+        }
+        case GL_UNSIGNED_NORMALIZED:
+        {
+            switch (maxBits)
+            {
+                case 16:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R16G16B16A16_UNORM,
+                                                              DXGI_FORMAT_R16G16B16A16_UNORM,
+                                                              DXGI_FORMAT_R16G16B16A16_UNORM);
+                    return formatInfo;
+                }
+                case 24:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT);
+                    return formatInfo;
+                }
+                case 32:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                              DXGI_FORMAT_R32G32B32A32_FLOAT);
+                    return formatInfo;
+                }
+                case 8:
+                {
+                    static const SwizzleFormatInfo formatInfo(DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                              DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                              DXGI_FORMAT_R8G8B8A8_UNORM);
+                    return formatInfo;
+                }
+                default:
+                    break;
+            }
+        }
+
+        default:
+        {
+            static const SwizzleFormatInfo defaultInfo(DXGI_FORMAT_UNKNOWN,
+                                                       DXGI_FORMAT_UNKNOWN,
+                                                       DXGI_FORMAT_UNKNOWN);
+            return defaultInfo;
+        }
+    }
+    // clang-format on
+
+}  // GetSwizzleFormatInfo
+
+}  // namespace d3d11
+
+}  // namespace rx

src/libANGLE/renderer/d3d/d3d11/texture_format_data.json

+{
+  "GL_ALPHA": [
+    {
+      "texFormat": "DXGI_FORMAT_A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_ALPHA16F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_ALPHA32F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_ALPHA8_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_BGR5_A1_ANGLEX": [
+    {
+      "texFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_BGRA4_ANGLEX": [
+    {
+      "texFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_BGRA8_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_BGRA_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_COMPRESSED_R11_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_RG11_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_RGB8_ETC2": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_RGBA8_ETC2_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_BC1_UNORM",
+      "srvFormat": "DXGI_FORMAT_BC1_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE": [
+    {
+      "texFormat": "DXGI_FORMAT_BC2_UNORM",
+      "srvFormat": "DXGI_FORMAT_BC2_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE": [
+    {
+      "texFormat": "DXGI_FORMAT_BC3_UNORM",
+      "srvFormat": "DXGI_FORMAT_BC3_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_COMPRESSED_RGB_S3TC_DXT1_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_BC1_UNORM",
+      "srvFormat": "DXGI_FORMAT_BC1_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_COMPRESSED_SIGNED_R11_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_SIGNED_RG11_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_SRGB8_ETC2": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_DEPTH24_STENCIL8": [
+    {
+      "texFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R24_UNORM_X8_TYPELESS",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_DEPTH32F_STENCIL8": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G8X24_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D32_FLOAT_S8X24_UINT",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_UNKNOWN",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_DEPTH_COMPONENT16": [
+    {
+      "texFormat": "DXGI_FORMAT_R16_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R16_UNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D16_UNORM",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_D16_UNORM",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D16_UNORM",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_DEPTH_COMPONENT24": [
+    {
+      "texFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R24_UNORM_X8_TYPELESS",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_DEPTH_COMPONENT32F": [
+    {
+      "texFormat": "DXGI_FORMAT_R32_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D32_FLOAT",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_UNKNOWN",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ],
+  "GL_DEPTH_COMPONENT32_OES": [
+    {
+      "texFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_R24_UNORM_X8_TYPELESS",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL10Plus"
+    }
+  ],
+  "GL_LUMINANCE": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE16F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE32F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE8_ALPHA8_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE8_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE_ALPHA": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE_ALPHA16F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_LUMINANCE_ALPHA32F_EXT": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_NONE": [
+    {
+      "texFormat": "DXGI_FORMAT_UNKNOWN",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R11F_G11F_B10F": [
+    {
+      "texFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R11G11B10_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R16F": [
+    {
+      "texFormat": "DXGI_FORMAT_R16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R16I": [
+    {
+      "texFormat": "DXGI_FORMAT_R16_SINT",
+      "srvFormat": "DXGI_FORMAT_R16_SINT",
+      "rtvFormat": "DXGI_FORMAT_R16_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R16UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R16_UINT",
+      "srvFormat": "DXGI_FORMAT_R16_UINT",
+      "rtvFormat": "DXGI_FORMAT_R16_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R32F": [
+    {
+      "texFormat": "DXGI_FORMAT_R32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R32I": [
+    {
+      "texFormat": "DXGI_FORMAT_R32_SINT",
+      "srvFormat": "DXGI_FORMAT_R32_SINT",
+      "rtvFormat": "DXGI_FORMAT_R32_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R32UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R32_UINT",
+      "srvFormat": "DXGI_FORMAT_R32_UINT",
+      "rtvFormat": "DXGI_FORMAT_R32_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R8I": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_SINT",
+      "srvFormat": "DXGI_FORMAT_R8_SINT",
+      "rtvFormat": "DXGI_FORMAT_R8_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R8UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_UINT",
+      "srvFormat": "DXGI_FORMAT_R8_UINT",
+      "rtvFormat": "DXGI_FORMAT_R8_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_R8_SNORM": [
+    {
+      "texFormat": "DXGI_FORMAT_R8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG16F": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG16I": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16_SINT",
+      "srvFormat": "DXGI_FORMAT_R16G16_SINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG16UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16_UINT",
+      "srvFormat": "DXGI_FORMAT_R16G16_UINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG32F": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG32I": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32_SINT",
+      "srvFormat": "DXGI_FORMAT_R32G32_SINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG32UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32_UINT",
+      "srvFormat": "DXGI_FORMAT_R32G32_UINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG8I": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_SINT",
+      "srvFormat": "DXGI_FORMAT_R8G8_SINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG8UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_UINT",
+      "srvFormat": "DXGI_FORMAT_R8G8_UINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RG8_SNORM": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB10_A2": [
+    {
+      "texFormat": "DXGI_FORMAT_R10G10B10A2_UNORM",
+      "srvFormat": "DXGI_FORMAT_R10G10B10A2_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R10G10B10A2_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB10_A2UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R10G10B10A2_UINT",
+      "srvFormat": "DXGI_FORMAT_R10G10B10A2_UINT",
+      "rtvFormat": "DXGI_FORMAT_R10G10B10A2_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB16F": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB16I": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB16UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB32F": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB32I": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB32UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB565": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,false>"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_B5G6R5_UNORM",
+      "srvFormat": "DXGI_FORMAT_B5G6R5_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B5G6R5_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,true>"
+    }
+  ],
+  "GL_RGB5_A1": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,false>"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_B5G5R5A1_UNORM",
+      "srvFormat": "DXGI_FORMAT_B5G5R5A1_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B5G5R5A1_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,true>"
+    }
+  ],
+  "GL_RGB8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB8I": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB8UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB8_SNORM": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGB9_E5": [
+    {
+      "texFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+      "srvFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA16F": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA16I": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA16UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "srvFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA32F": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA32I": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA32UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "srvFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "rtvFormat": "DXGI_FORMAT_R32G32B32A32_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA4": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,false>"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_B4G4R4A4_UNORM",
+      "srvFormat": "DXGI_FORMAT_B4G4R4A4_UNORM",
+      "rtvFormat": "DXGI_FORMAT_B4G4R4A4_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,true>"
+    }
+  ],
+  "GL_RGBA8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA8I": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA8UI": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UINT",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_RGBA8_SNORM": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_SNORM",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_SRGB8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_SRGB8_ALPHA8": [
+    {
+      "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",
+      "dsvFormat": "DXGI_FORMAT_UNKNOWN",
+      "requirementsFcn": "AnyDevice"
+    }
+  ],
+  "GL_STENCIL_INDEX8": [
+    {
+      "texFormat": "DXGI_FORMAT_R24G8_TYPELESS",
+      "srvFormat": "DXGI_FORMAT_X24_TYPELESS_G8_UINT",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL10Plus"
+    },
+    {
+      "texFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "srvFormat": "DXGI_FORMAT_UNKNOWN",
+      "rtvFormat": "DXGI_FORMAT_UNKNOWN",
+      "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT",
+      "requirementsFcn": "OnlyFL9_3"
+    }
+  ]
+}
\ No newline at end of file

src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp

+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_texture_format_table.py using data from texture_format_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.
+//
+// texture_format_table:
+//   Queries for full textureFormat information based in internalFormat
+//
+
+#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
+
+#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
+#include "libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.h"
+#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h"
+#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
+#include "libANGLE/renderer/d3d/d3d11/swizzle_format_info.h"
+#include "libANGLE/renderer/d3d/loadimage.h"
+
+namespace rx
+{
+
+namespace d3d11
+{
+
+namespace
+{
+
+typedef bool (*FormatSupportFunction)(const Renderer11DeviceCaps &);
+
+bool AnyDevice(const Renderer11DeviceCaps &deviceCaps)
+{
+    return true;
+}
+
+bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps)
+{
+    return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0);
+}
+
+bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps)
+{
+    return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3);
+}
+
+template <DXGI_FORMAT format, bool requireSupport>
+bool SupportsFormat(const Renderer11DeviceCaps &deviceCaps)
+{
+    // Must support texture, SRV and RTV support
+    UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE |
+                       D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP |
+                       D3D11_FORMAT_SUPPORT_RENDER_TARGET;
+
+    if (d3d11_gl::GetMaximumClientVersion(deviceCaps.featureLevel) > 2)
+    {
+        mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D;
+    }
+
+    bool fullSupport = false;
+    if (format == DXGI_FORMAT_B5G6R5_UNORM)
+    {
+        // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but
+        // check anyway.
+        mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN;
+        fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport);
+    }
+    else if (format == DXGI_FORMAT_B4G4R4A4_UNORM)
+    {
+        fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport);
+    }
+    else if (format == DXGI_FORMAT_B5G5R5A1_UNORM)
+    {
+        fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport);
+    }
+    else
+    {
+        UNREACHABLE();
+        return false;
+    }
+
+    // This 'SupportsFormat' function is used by individual entries in the D3D11 Format Map below,
+    // which maps GL formats to DXGI formats.
+    if (requireSupport)
+    {
+        // This means that ANGLE would like to use the entry in the map if the inputted DXGI format
+        // *IS* supported.
+        // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if
+        // DXGI_FORMAT_B5G5R5A1 is supported.
+        // In this case, we should only return 'true' if the format *IS* supported.
+        return fullSupport;
+    }
+    else
+    {
+        // This means that ANGLE would like to use the entry in the map if the inputted DXGI format
+        // *ISN'T* supported.
+        // This might be a fallback entry. e.g. for ANGLE to use DXGI_FORMAT_R8G8B8A8_UNORM if
+        // DXGI_FORMAT_B5G5R5A1 isn't supported.
+        // In this case, we should only return 'true' if the format *ISN'T* supported.
+        return !fullSupport;
+    }
+}
+
+// End Format Support Functions
+
+// For sized GL internal formats, there are several possible corresponding D3D11 formats depending
+// on device capabilities.
+// This function allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and
+// DSVs given a GL internal format.
+const TextureFormat GetD3D11FormatInfo(GLenum internalFormat,
+                                       DXGI_FORMAT texFormat,
+                                       DXGI_FORMAT srvFormat,
+                                       DXGI_FORMAT rtvFormat,
+                                       DXGI_FORMAT dsvFormat)
+{
+    TextureFormat info;
+    info.texFormat = texFormat;
+    info.srvFormat = srvFormat;
+    info.rtvFormat = rtvFormat;
+    info.dsvFormat = dsvFormat;
+
+    // Given a GL internal format, the renderFormat is the DSV format if it is depth- or
+    // stencil-renderable,
+    // the RTV format if it is color-renderable, and the (nonrenderable) texture format otherwise.
+    if (dsvFormat != DXGI_FORMAT_UNKNOWN)
+    {
+        info.renderFormat = dsvFormat;
+    }
+    else if (rtvFormat != DXGI_FORMAT_UNKNOWN)
+    {
+        info.renderFormat = rtvFormat;
+    }
+    else if (texFormat != DXGI_FORMAT_UNKNOWN)
+    {
+        info.renderFormat = texFormat;
+    }
+    else
+    {
+        info.renderFormat = DXGI_FORMAT_UNKNOWN;
+    }
+
+    // Compute the swizzle formats
+    const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
+    if (internalFormat != GL_NONE && formatInfo.pixelBytes > 0)
+    {
+        if (formatInfo.componentCount != 4 || texFormat == DXGI_FORMAT_UNKNOWN ||
+            srvFormat == DXGI_FORMAT_UNKNOWN || rtvFormat == DXGI_FORMAT_UNKNOWN)
+        {
+            // Get the maximum sized component
+            unsigned int maxBits = 1;
+            if (formatInfo.compressed)
+            {
+                unsigned int compressedBitsPerBlock = formatInfo.pixelBytes * 8;
+                unsigned int blockSize =
+                    formatInfo.compressedBlockWidth * formatInfo.compressedBlockHeight;
+                maxBits = std::max(compressedBitsPerBlock / blockSize, maxBits);
+            }
+            else
+            {
+                maxBits = std::max(maxBits, formatInfo.alphaBits);
+                maxBits = std::max(maxBits, formatInfo.redBits);
+                maxBits = std::max(maxBits, formatInfo.greenBits);
+                maxBits = std::max(maxBits, formatInfo.blueBits);
+                maxBits = std::max(maxBits, formatInfo.luminanceBits);
+                maxBits = std::max(maxBits, formatInfo.depthBits);
+            }
+
+            maxBits = roundUp(maxBits, 8U);
+
+            const SwizzleFormatInfo &swizzleInfo =
+                GetSwizzleFormatInfo(maxBits, formatInfo.componentType);
+            info.swizzleTexFormat = swizzleInfo.mTexFormat;
+            info.swizzleSRVFormat = swizzleInfo.mSRVFormat;
+            info.swizzleRTVFormat = swizzleInfo.mRTVFormat;
+        }
+        else
+        {
+            // The original texture format is suitable for swizzle operations
+            info.swizzleTexFormat = texFormat;
+            info.swizzleSRVFormat = srvFormat;
+            info.swizzleRTVFormat = rtvFormat;
+        }
+    }
+    else
+    {
+        // Not possible to swizzle with this texture format since it is either unsized or GL_NONE
+        info.swizzleTexFormat = DXGI_FORMAT_UNKNOWN;
+        info.swizzleSRVFormat = DXGI_FORMAT_UNKNOWN;
+        info.swizzleRTVFormat = DXGI_FORMAT_UNKNOWN;
+    }
+
+    // Check if there is an initialization function for this texture format
+    info.dataInitializerFunction = GetInternalFormatInitializer(internalFormat, texFormat);
+    // Gather all the load functions for this internal format
+    info.loadFunctions = GetLoadFunctionsMap(internalFormat, texFormat);
+
+    ASSERT(info.loadFunctions.size() != 0 || internalFormat == GL_NONE);
+
+    return info;
+}
+
+}  // namespace
+
+TextureFormat::TextureFormat()
+    : texFormat(DXGI_FORMAT_UNKNOWN),
+      srvFormat(DXGI_FORMAT_UNKNOWN),
+      rtvFormat(DXGI_FORMAT_UNKNOWN),
+      dsvFormat(DXGI_FORMAT_UNKNOWN),
+      renderFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleTexFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleSRVFormat(DXGI_FORMAT_UNKNOWN),
+      swizzleRTVFormat(DXGI_FORMAT_UNKNOWN),
+      dataInitializerFunction(NULL),
+      loadFunctions()
+{
+}
+
+const TextureFormat &GetTextureFormatInfo(GLenum internalFormat,
+                                          const Renderer11DeviceCaps &renderer11DeviceCaps)
+{
+    // clang-format off
+    switch (internalFormat)
+    {
+        case GL_ALPHA:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_ALPHA16F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_ALPHA32F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_ALPHA8_EXT:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_BGR5_A1_ANGLEX:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_BGRA4_ANGLEX:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_BGRA8_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_BGRA_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_B8G8R8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_R11_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_UNORM,
+                                                                               DXGI_FORMAT_R8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RG11_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_UNORM,
+                                                                               DXGI_FORMAT_R8G8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGB8_ETC2:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGBA8_ETC2_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_BC1_UNORM,
+                                                                               DXGI_FORMAT_BC1_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_BC2_UNORM,
+                                                                               DXGI_FORMAT_BC2_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_BC3_UNORM,
+                                                                               DXGI_FORMAT_BC3_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_BC1_UNORM,
+                                                                               DXGI_FORMAT_BC1_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_SIGNED_R11_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_SNORM,
+                                                                               DXGI_FORMAT_R8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_SIGNED_RG11_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_SNORM,
+                                                                               DXGI_FORMAT_R8G8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_SRGB8_ETC2:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH24_STENCIL8:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R24G8_TYPELESS,
+                                                                               DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH32F_STENCIL8:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G8X24_TYPELESS,
+                                                                               DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D32_FLOAT_S8X24_UINT);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH_COMPONENT16:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16_TYPELESS,
+                                                                               DXGI_FORMAT_R16_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D16_UNORM);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_D16_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D16_UNORM);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH_COMPONENT24:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R24G8_TYPELESS,
+                                                                               DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH_COMPONENT32F:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32_TYPELESS,
+                                                                               DXGI_FORMAT_R32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D32_FLOAT);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_DEPTH_COMPONENT32_OES:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R24G8_TYPELESS,
+                                                                               DXGI_FORMAT_R24_UNORM_X8_TYPELESS,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE16F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE32F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE8_ALPHA8_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE8_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE_ALPHA:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE_ALPHA16F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_LUMINANCE_ALPHA32F_EXT:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_NONE:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R11F_G11F_B10F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R11G11B10_FLOAT,
+                                                                               DXGI_FORMAT_R11G11B10_FLOAT,
+                                                                               DXGI_FORMAT_R11G11B10_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R16F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16_FLOAT,
+                                                                               DXGI_FORMAT_R16_FLOAT,
+                                                                               DXGI_FORMAT_R16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R16I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16_SINT,
+                                                                               DXGI_FORMAT_R16_SINT,
+                                                                               DXGI_FORMAT_R16_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R16UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16_UINT,
+                                                                               DXGI_FORMAT_R16_UINT,
+                                                                               DXGI_FORMAT_R16_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R32F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32_FLOAT,
+                                                                               DXGI_FORMAT_R32_FLOAT,
+                                                                               DXGI_FORMAT_R32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R32I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32_SINT,
+                                                                               DXGI_FORMAT_R32_SINT,
+                                                                               DXGI_FORMAT_R32_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R32UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32_UINT,
+                                                                               DXGI_FORMAT_R32_UINT,
+                                                                               DXGI_FORMAT_R32_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_UNORM,
+                                                                               DXGI_FORMAT_R8_UNORM,
+                                                                               DXGI_FORMAT_R8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R8I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_SINT,
+                                                                               DXGI_FORMAT_R8_SINT,
+                                                                               DXGI_FORMAT_R8_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R8UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_UINT,
+                                                                               DXGI_FORMAT_R8_UINT,
+                                                                               DXGI_FORMAT_R8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_R8_SNORM:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8_SNORM,
+                                                                               DXGI_FORMAT_R8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG16F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG16I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16_SINT,
+                                                                               DXGI_FORMAT_R16G16_SINT,
+                                                                               DXGI_FORMAT_R16G16_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG16UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16_UINT,
+                                                                               DXGI_FORMAT_R16G16_UINT,
+                                                                               DXGI_FORMAT_R16G16_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG32F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG32I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32_SINT,
+                                                                               DXGI_FORMAT_R32G32_SINT,
+                                                                               DXGI_FORMAT_R32G32_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG32UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32_UINT,
+                                                                               DXGI_FORMAT_R32G32_UINT,
+                                                                               DXGI_FORMAT_R32G32_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_UNORM,
+                                                                               DXGI_FORMAT_R8G8_UNORM,
+                                                                               DXGI_FORMAT_R8G8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG8I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_SINT,
+                                                                               DXGI_FORMAT_R8G8_SINT,
+                                                                               DXGI_FORMAT_R8G8_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG8UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_UINT,
+                                                                               DXGI_FORMAT_R8G8_UINT,
+                                                                               DXGI_FORMAT_R8G8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RG8_SNORM:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8_SNORM,
+                                                                               DXGI_FORMAT_R8G8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB10_A2:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R10G10B10A2_UNORM,
+                                                                               DXGI_FORMAT_R10G10B10A2_UNORM,
+                                                                               DXGI_FORMAT_R10G10B10A2_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB10_A2UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R10G10B10A2_UINT,
+                                                                               DXGI_FORMAT_R10G10B10A2_UINT,
+                                                                               DXGI_FORMAT_R10G10B10A2_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB16F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB16I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB16UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB32F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB32I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB32UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB565:
+        {
+            if (SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,false>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else if (SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,true>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B5G6R5_UNORM,
+                                                                               DXGI_FORMAT_B5G6R5_UNORM,
+                                                                               DXGI_FORMAT_B5G6R5_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB5_A1:
+        {
+            if (SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,false>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else if (SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,true>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B5G5R5A1_UNORM,
+                                                                               DXGI_FORMAT_B5G5R5A1_UNORM,
+                                                                               DXGI_FORMAT_B5G5R5A1_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB8I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB8UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB8_SNORM:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGB9_E5:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R9G9B9E5_SHAREDEXP,
+                                                                               DXGI_FORMAT_R9G9B9E5_SHAREDEXP,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA16F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_R16G16B16A16_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA16I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA16UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_R16G16B16A16_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA32F:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_R32G32B32A32_FLOAT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA32I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA32UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_R32G32B32A32_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA4:
+        {
+            if (SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,false>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else if (SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,true>(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_B4G4R4A4_UNORM,
+                                                                               DXGI_FORMAT_B4G4R4A4_UNORM,
+                                                                               DXGI_FORMAT_B4G4R4A4_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA8I:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_SINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA8UI:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_R8G8B8A8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_RGBA8_SNORM:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                                               DXGI_FORMAT_R8G8B8A8_SNORM,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_SRGB8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_SRGB8_ALPHA8:
+        {
+            if (AnyDevice(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
+                                                                               DXGI_FORMAT_UNKNOWN);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+        case GL_STENCIL_INDEX8:
+        {
+            if (OnlyFL10Plus(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_R24G8_TYPELESS,
+                                                                               DXGI_FORMAT_X24_TYPELESS_G8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else if (OnlyFL9_3(renderer11DeviceCaps))
+            {
+                static const TextureFormat &textureFormat = GetD3D11FormatInfo(internalFormat,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_UNKNOWN,
+                                                                               DXGI_FORMAT_D24_UNORM_S8_UINT);
+                return textureFormat;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        default:
+            break;
+    }
+    // clang-format on
+
+    static const TextureFormat defaultInfo;
+    return defaultInfo;
+}  // GetTextureFormatInfo
+
+}  // namespace d3d11
+
+}  // namespace rx

src/libGLESv2.gypi

@@ -300,6 +300,10 @@
             'libANGLE/renderer/d3d/d3d11/IndexBuffer11.h',
             'libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp',
             'libANGLE/renderer/d3d/d3d11/InputLayoutCache.h',
+            'libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.h',
+            'libANGLE/renderer/d3d/d3d11/internal_format_initializer_table.cpp',
+            'libANGLE/renderer/d3d/d3d11/load_functions_table.h',
+            'libANGLE/renderer/d3d/d3d11/load_functions_table_autogen.cpp',
             'libANGLE/renderer/d3d/d3d11/NativeWindow.h',
             'libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp',
             'libANGLE/renderer/d3d/d3d11/PixelTransfer11.h',
@@ -370,15 +374,13 @@
             'libANGLE/renderer/d3d/d3d11/SwapChain11.cpp',
             'libANGLE/renderer/d3d/d3d11/SwapChain11.h',
             'libANGLE/renderer/d3d/d3d11/swizzle_format_info.h',
-            'libANGLE/renderer/d3d/d3d11/swizzle_format_info.cpp',
+            'libANGLE/renderer/d3d/d3d11/swizzle_format_info_autogen.cpp',
             'libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp',
             'libANGLE/renderer/d3d/d3d11/TextureStorage11.h',
             'libANGLE/renderer/d3d/d3d11/Trim11.cpp',
             'libANGLE/renderer/d3d/d3d11/Trim11.h',
-            'libANGLE/renderer/d3d/d3d11/texture_format_table.cpp',
+            'libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp',
             'libANGLE/renderer/d3d/d3d11/texture_format_table.h',
-            'libANGLE/renderer/d3d/d3d11/texture_format_util.cpp',
-            'libANGLE/renderer/d3d/d3d11/texture_format_util.h',
             'libANGLE/renderer/d3d/d3d11/VertexArray11.h',
             'libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp',
             'libANGLE/renderer/d3d/d3d11/VertexBuffer11.h',