D3D11: Get mip generation function from ANGLE format

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

@@ -41,15 +41,14 @@ Image11::~Image11()
     releaseStagingTexture();
 }
 
-gl::Error Image11::generateMipmap(Image11 *dest, Image11 *src)
+gl::Error Image11::generateMipmap(Image11 *dest,
+                                  Image11 *src,
+                                  const Renderer11DeviceCaps &rendererCaps)
 {
     ASSERT(src->getDXGIFormat() == dest->getDXGIFormat());
     ASSERT(src->getWidth() == 1 || src->getWidth() / 2 == dest->getWidth());
     ASSERT(src->getHeight() == 1 || src->getHeight() / 2 == dest->getHeight());
 
-    const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(src->getDXGIFormat());
-    ASSERT(dxgiFormatInfo.mipGenerationFunction != NULL);
-
     D3D11_MAPPED_SUBRESOURCE destMapped;
     gl::Error error = dest->map(D3D11_MAP_WRITE, &destMapped);
     if (error.isError())
@@ -68,9 +67,11 @@ gl::Error Image11::generateMipmap(Image11 *dest, Image11 *src)
     const uint8_t *sourceData = reinterpret_cast<const uint8_t*>(srcMapped.pData);
     uint8_t *destData = reinterpret_cast<uint8_t*>(destMapped.pData);
 
-    dxgiFormatInfo.mipGenerationFunction(src->getWidth(), src->getHeight(), src->getDepth(),
-                                         sourceData, srcMapped.RowPitch, srcMapped.DepthPitch,
-                                         destData, destMapped.RowPitch, destMapped.DepthPitch);
+    auto mipGenerationFunction = d3d11::GetTextureFormatInfo(src->getInternalFormat(), rendererCaps)
+                                     .formatSet.mipGenerationFunction;
+    mipGenerationFunction(src->getWidth(), src->getHeight(), src->getDepth(), sourceData,
+                          srcMapped.RowPitch, srcMapped.DepthPitch, destData, destMapped.RowPitch,
+                          destMapped.DepthPitch);
 
     dest->unmap();
     src->unmap();

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

@@ -25,6 +25,7 @@ namespace rx
 class Renderer11;
 class TextureHelper11;
 class TextureStorage11;
+struct Renderer11DeviceCaps;
 
 class Image11 : public ImageD3D
 {
@@ -32,7 +33,9 @@ class Image11 : public ImageD3D
     Image11(Renderer11 *renderer);
     virtual ~Image11();
 
-    static gl::Error generateMipmap(Image11 *dest, Image11 *src);
+    static gl::Error generateMipmap(Image11 *dest,
+                                    Image11 *src,
+                                    const Renderer11DeviceCaps &rendererCaps);
 
     virtual bool isDirty() const;
 

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

@@ -3499,7 +3499,7 @@ gl::Error Renderer11::generateMipmap(ImageD3D *dest, ImageD3D *src)
 {
     Image11 *dest11 = GetAs<Image11>(dest);
     Image11 *src11 = GetAs<Image11>(src);
-    return Image11::generateMipmap(dest11, src11);
+    return Image11::generateMipmap(dest11, src11, mRenderer11DeviceCaps);
 }
 
 gl::Error Renderer11::generateMipmapsUsingD3D(TextureStorage *storage,

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

@@ -45,7 +45,6 @@ struct DXGIFormat
     GLenum internalFormat;
     GLenum componentType;
 
-    MipGenerationFunction mipGenerationFunction;
     ColorReadFunction colorReadFunction;
 
     FastCopyFunctionMap fastCopyFunctions;

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

@@ -52,6 +52,7 @@ template_texture_format_table_autogen_cpp = """// GENERATED FILE - DO NOT EDIT.
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 #include "libANGLE/renderer/d3d/d3d11/load_functions_table.h"
 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
+#include "libANGLE/renderer/d3d/generatemip.h"
 #include "libANGLE/renderer/d3d/loadimage.h"
 
 namespace rx
@@ -142,7 +143,8 @@ ANGLEFormatSet::ANGLEFormatSet()
       srvFormat(DXGI_FORMAT_UNKNOWN),
       rtvFormat(DXGI_FORMAT_UNKNOWN),
       dsvFormat(DXGI_FORMAT_UNKNOWN),
-      swizzleFormat(ANGLE_FORMAT_NONE)
+      swizzleFormat(ANGLE_FORMAT_NONE),
+      mipGenerationFunction(nullptr)
 {{
 }}
 
@@ -170,14 +172,16 @@ ANGLEFormatSet::ANGLEFormatSet(ANGLEFormat format,
                                DXGI_FORMAT srvFormat,
                                DXGI_FORMAT rtvFormat,
                                DXGI_FORMAT dsvFormat,
-                               ANGLEFormat swizzleFormat)
+                               ANGLEFormat swizzleFormat,
+                               MipGenerationFunction mipGenerationFunction)
     : format(format),
       glInternalFormat(glInternalFormat),
       texFormat(texFormat),
       srvFormat(srvFormat),
       rtvFormat(rtvFormat),
       dsvFormat(dsvFormat),
-      swizzleFormat(swizzleFormat)
+      swizzleFormat(swizzleFormat),
+      mipGenerationFunction(mipGenerationFunction)
 {{
 }}
 
@@ -388,6 +392,38 @@ def parse_json_into_switch_texture_format_string(json_map, json_data):
 
     return table_data
 
+def get_channel_struct(angle_format):
+    if 'bits' not in angle_format:
+        return None
+    bits = angle_format['bits']
+    if 'depth' in bits or 'stencil' in bits:
+        return None
+
+    if 'channelStruct' in angle_format:
+        return angle_format['channelStruct']
+
+    struct_name = ''
+    for channel in angle_format['channels']:
+        if channel == 'r':
+            struct_name += 'R{}'.format(bits['red'])
+        if channel == 'g':
+            struct_name += 'G{}'.format(bits['green'])
+        if channel == 'b':
+            struct_name += 'B{}'.format(bits['blue'])
+        if channel == 'a':
+            struct_name += 'A{}'.format(bits['alpha'])
+    if angle_format['componentType'] == 'float':
+        struct_name += 'F'
+    if angle_format['componentType'] == 'int' or angle_format['componentType'] == 'snorm':
+        struct_name += 'S'
+    return struct_name
+
+def get_mip_generation_function(angle_format):
+    channel_struct = get_channel_struct(angle_format)
+    if channel_struct == None:
+        return 'nullptr'
+    return 'GenerateMip<' + channel_struct + '>'
+
 def parse_json_into_switch_angle_format_string(json_data):
     table_data = ''
     for angle_format_item in sorted(json_data.iteritems()):
@@ -399,6 +435,7 @@ def parse_json_into_switch_angle_format_string(json_data):
         rtv_format = angle_format["rtvFormat"] if "rtvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN"
         dsv_format = angle_format["dsvFormat"] if "dsvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN"
         swizzle_format = get_swizzle_format_id(angle_format_item[0], angle_format)
+        mip_generation_function = get_mip_generation_function(angle_format)
         table_data += '        {\n'
         table_data += '            static const ANGLEFormatSet formatInfo(' + angle_format_item[0] + ',\n'
         table_data += '                                                   ' + gl_internal_format + ',\n'
@@ -406,7 +443,8 @@ def parse_json_into_switch_angle_format_string(json_data):
         table_data += '                                                   ' + srv_format + ',\n'
         table_data += '                                                   ' + rtv_format + ',\n'
         table_data += '                                                   ' + dsv_format + ',\n'
-        table_data += '                                                   ' + swizzle_format + ');\n'
+        table_data += '                                                   ' + swizzle_format + ',\n'
+        table_data += '                                                   ' + mip_generation_function + ');\n'
         table_data += '            return formatInfo;\n'
         table_data += '        }\n'
     return table_data

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

@@ -424,7 +424,8 @@
     "channels": "bgr",
     "componentType":  "unorm",
     "bits": { "red": 5, "green": 6, "blue": 5 },
-    "glInternalFormat": "GL_RGB565"
+    "glInternalFormat": "GL_RGB565",
+    "channelStruct": "R5G6B5"
   },
   "ANGLE_FORMAT_B5G5R5A1_UNORM": {
     "texFormat": "DXGI_FORMAT_B5G5R5A1_UNORM",
@@ -433,7 +434,8 @@
     "channels": "bgra",
     "componentType": "unorm",
     "bits": { "red": 5, "green": 5, "blue": 5, "alpha": 1 },
-    "glInternalFormat": "GL_RGB5_A1"
+    "glInternalFormat": "GL_RGB5_A1",
+    "channelStruct": "A1R5G5B5"
   },
   "ANGLE_FORMAT_R8G8B8A8_SINT": {
     "texFormat": "DXGI_FORMAT_R8G8B8A8_SINT",
@@ -467,7 +469,8 @@
     "channels": "rgb",
     "componentType":  "float",
     "bits": { "red": 9, "green": 9, "blue": 9, "shared": 5 },
-    "glInternalFormat": "GL_RGB9_E5"
+    "glInternalFormat": "GL_RGB9_E5",
+    "channelStruct":  "R9G9B9E5"
   },
   "ANGLE_FORMAT_B4G4R4A4_UNORM": {
     "texFormat": "DXGI_FORMAT_B4G4R4A4_UNORM",
@@ -476,7 +479,8 @@
     "channels": "bgra",
     "componentType":  "unorm",
     "bits": { "red": 4, "green": 4, "blue": 4, "alpha": 4 },
-    "glInternalFormat": "GL_RGBA4"
+    "glInternalFormat": "GL_RGBA4",
+    "channelStruct":  "A4R4G4B4"
   },
   "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB": {
     "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB",

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

@@ -44,7 +44,8 @@ struct ANGLEFormatSet
                    DXGI_FORMAT srvFormat,
                    DXGI_FORMAT rtvFormat,
                    DXGI_FORMAT dsvFormat,
-                   ANGLEFormat swizzleFormat);
+                   ANGLEFormat swizzleFormat,
+                   MipGenerationFunction mipGenerationFunction);
     ANGLEFormatSet(const ANGLEFormatSet &) = default;
     ANGLEFormatSet &operator=(const ANGLEFormatSet &) = default;
 
@@ -60,6 +61,8 @@ struct ANGLEFormatSet
     DXGI_FORMAT dsvFormat;
 
     ANGLEFormat swizzleFormat;
+
+    MipGenerationFunction mipGenerationFunction;
 };
 
 struct TextureFormat : public angle::NonCopyable