DirectXTex updated to read & write new miscFlags2 alpha mode metadata for DDS files

- Added helper to see if a texure's alpha channel is all opaque
- Reads and writes DXT2 and DXT4 DDS files
- Updated PremultiplyAlpha function to set miscFlags2 appropriately
- Texconv updated for new feature, "-dx10" switch now allows write of miscFlags2 data

Author: walbourn_cp

DirectXTex/DDS.h

@@ -169,20 +169,33 @@ extern __declspec(selectany) const DDS_PIXELFORMAT DDSPF_DX10 =
 #define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME
 
 // Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
-typedef enum DDS_RESOURCE_DIMENSION
+enum DDS_RESOURCE_DIMENSION
 {
     DDS_DIMENSION_TEXTURE1D	= 2,
     DDS_DIMENSION_TEXTURE2D	= 3,
     DDS_DIMENSION_TEXTURE3D	= 4,
-} DDS_RESOURCE_DIMENSION;
+};
 
 // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
-typedef enum DDS_RESOURCE_MISC_FLAG
+enum DDS_RESOURCE_MISC_FLAG
+{
+    DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
+};
+
+enum DDS_MISC_FLAGS2
 {
-   DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
-} DDS_RESOURCE_MISC_FLAG;
+    DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x3L,
+};
 
-typedef struct
+enum DDS_ALPHA_MODE
+{
+    DDS_ALPHA_MODE_STRAIGHT      = 0,
+    DDS_ALPHA_MODE_PREMULTIPLIED = 1,
+    DDS_ALPHA_MODE_4TH_CHANNEL   = 2,
+    DDS_ALPHA_MODE_OPAQUE        = 3,
+};
+
+struct DDS_HEADER
 {
     uint32_t    dwSize;
     uint32_t    dwFlags;
@@ -198,17 +211,20 @@ typedef struct
     uint32_t    dwCaps3;
     uint32_t    dwCaps4;
     uint32_t    dwReserved2;
-} DDS_HEADER;
+};
 
-typedef struct
+struct DDS_HEADER_DXT10
 {
     DXGI_FORMAT dxgiFormat;
     uint32_t    resourceDimension;
     uint32_t    miscFlag; // see DDS_RESOURCE_MISC_FLAG
     uint32_t    arraySize;
-    uint32_t    reserved;
-} DDS_HEADER_DXT10;
+    uint32_t    miscFlags2; // see DDS_MISC_FLAGS2
+};
 
 #pragma pack(pop)
 
+static_assert( sizeof(DDS_HEADER) == 124, "DDS Header size mismatch" );
+static_assert( sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
+
 }; // namespace

DirectXTex/DirectXTex.h

@@ -27,7 +27,7 @@
 #include <dxgiformat.h>
 #include <d3d11.h>
 
-#define DIRECTX_TEX_VERSION 101
+#define DIRECTX_TEX_VERSION 102
 
 #if defined(_MSC_VER) && (_MSC_VER<1610) && !defined(_In_reads_)
 #define _Analysis_assume_(exp)
@@ -99,6 +99,20 @@ namespace DirectX
         TEX_MISC_TEXTURECUBE = 0x4L,
     };
 
+    enum TEX_MISC_FLAG2
+    {
+        TEX_MISC2_ALPHA_MODE_MASK = 0x3L,
+    };
+
+    enum TEX_ALPHA_MODE
+        // Matches DDS_ALPHA_MODE, encoded in MISC_FLAGS2
+    {
+        TEX_ALPHA_MODE_STRAIGHT      = 0,
+        TEX_ALPHA_MODE_PREMULTIPLIED = 1,
+        TEX_ALPHA_MODE_4TH_CHANNEL   = 2,
+        TEX_ALPHA_MODE_OPAQUE        = 3,
+    };
+
     struct TexMetadata
     {
         size_t          width;
@@ -107,11 +121,19 @@ namespace DirectX
         size_t          arraySize;  // For cubemap, this is a multiple of 6
         size_t          mipLevels;
         uint32_t        miscFlags;
+        uint32_t        miscFlags2;
         DXGI_FORMAT     format;
         TEX_DIMENSION   dimension;
 
         size_t ComputeIndex( _In_ size_t mip, _In_ size_t item, _In_ size_t slice ) const;
             // Returns size_t(-1) to indicate an out-of-range error
+
+        bool IsCubemap() const { return (miscFlags & TEX_MISC_TEXTURECUBE) != 0; }
+            // Helpers for miscFlags
+
+        bool IsPMAlpha() const { return ((miscFlags2 & TEX_MISC2_ALPHA_MODE_MASK) == TEX_ALPHA_MODE_PREMULTIPLIED) != 0; }
+        void SetAlphaMode( TEX_ALPHA_MODE mode ) { miscFlags2 = (miscFlags2 & ~TEX_MISC2_ALPHA_MODE_MASK) | static_cast<uint32_t>(mode); }
+            // Helpers for miscFlags2
     };
 
     enum DDS_FLAGS
@@ -135,6 +157,9 @@ namespace DirectX
 
         DDS_FLAGS_FORCE_DX10_EXT        = 0x10000,
             // Always use the 'DX10' header extension for DDS writer (i.e. don't try to write DX9 compatible DDS files)
+
+        DDS_FLAGS_FORCE_DX10_EXT_MISC2  = 0x20000,
+            // DDS_FLAGS_FORCE_DX10_EXT including miscFlags2 information (result may not be compatible with D3DX10 or D3DX11)
     };
 
     enum WIC_FLAGS
@@ -227,6 +252,8 @@ namespace DirectX
         uint8_t* GetPixels() const { return _memory; }
         size_t GetPixelsSize() const { return _size; }
 
+        bool IsAlphaAllOpaque() const;
+
     private:
         size_t      _nimages;
         size_t      _size;

DirectXTex/DirectXTex.inl

@@ -189,6 +189,9 @@ inline bool HasAlpha( DXGI_FORMAT fmt )
     case DXGI_FORMAT_R8G8B8A8_SNORM:
     case DXGI_FORMAT_R8G8B8A8_SINT:
     case DXGI_FORMAT_A8_UNORM:
+    case DXGI_FORMAT_BC1_TYPELESS:
+    case DXGI_FORMAT_BC1_UNORM:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:
     case DXGI_FORMAT_BC2_TYPELESS:
     case DXGI_FORMAT_BC2_UNORM:
     case DXGI_FORMAT_BC2_UNORM_SRGB:

DirectXTex/DirectXTexCompress.cpp

@@ -426,6 +426,85 @@ static HRESULT _DecompressBC( _In_ const Image& cImage, _In_ const Image& result
 }
 
 
+//-------------------------------------------------------------------------------------
+bool _IsAlphaAllOpaqueBC( _In_ const Image& cImage )
+{
+    if ( !cImage.pixels )
+        return false;
+
+    // Image must be a multiple of 4 (degenerate cases of 1x1, 1x2, 2x1, and 2x2 are allowed)
+    size_t width = cImage.width;
+    if ( (width % 4) != 0 )
+    {
+        if ( width != 1 && width != 2 )
+            return false;
+    }
+
+    size_t height = cImage.height;
+    if ( (height % 4) != 0 )
+    {
+        if ( height != 1 && height != 2 )
+            return false;
+    }
+
+    // Promote "typeless" BC formats
+    DXGI_FORMAT cformat;
+    switch( cImage.format )
+    {
+    case DXGI_FORMAT_BC1_TYPELESS:  cformat = DXGI_FORMAT_BC1_UNORM; break;
+    case DXGI_FORMAT_BC2_TYPELESS:  cformat = DXGI_FORMAT_BC2_UNORM; break;
+    case DXGI_FORMAT_BC3_TYPELESS:  cformat = DXGI_FORMAT_BC3_UNORM; break;
+    case DXGI_FORMAT_BC7_TYPELESS:  cformat = DXGI_FORMAT_BC7_UNORM; break;
+    default:                        cformat = cImage.format;         break;
+    }
+
+    // Determine BC format decoder
+    BC_DECODE pfDecode;
+    size_t sbpp;
+    switch(cformat)
+    {
+    case DXGI_FORMAT_BC1_UNORM:
+    case DXGI_FORMAT_BC1_UNORM_SRGB:    pfDecode = D3DXDecodeBC1;   sbpp = 8;   break;
+    case DXGI_FORMAT_BC2_UNORM:
+    case DXGI_FORMAT_BC2_UNORM_SRGB:    pfDecode = D3DXDecodeBC2;   sbpp = 16;  break;
+    case DXGI_FORMAT_BC3_UNORM:
+    case DXGI_FORMAT_BC3_UNORM_SRGB:    pfDecode = D3DXDecodeBC3;   sbpp = 16;  break;
+    case DXGI_FORMAT_BC7_UNORM:
+    case DXGI_FORMAT_BC7_UNORM_SRGB:    pfDecode = D3DXDecodeBC7;   sbpp = 16;  break;
+    default:
+        // BC4, BC5, and BC6 don't have alpha channels
+        return false;
+    }
+
+    // Scan blocks for non-opaque alpha
+    static const XMVECTORF32 threshold = { 0.99f, 0.99f, 0.99f, 0.99f };
+
+    XMVECTOR temp[16];
+    const uint8_t *pPixels = cImage.pixels;
+    for( size_t h=0; h < cImage.height; h += 4 )
+    {
+        const uint8_t *ptr = pPixels;
+        for( size_t count = 0; count < cImage.rowPitch; count += sbpp )
+        {
+            pfDecode( temp, ptr );
+
+            for( size_t j = 0; j < 16; ++j )
+            {
+                XMVECTOR alpha = XMVectorSplatW( temp[j] );
+                if ( XMVector4Less( alpha, threshold ) )
+                    return false;
+            }
+
+            ptr += sbpp;
+        }
+
+        pPixels += cImage.rowPitch;
+    }
+
+    return true;
+}
+
+
 //=====================================================================================
 // Entry-points
 //=====================================================================================

DirectXTex/DirectXTexD3D11.cpp

@@ -236,7 +236,7 @@ bool IsSupportedTexture( ID3D11Device* pDevice, const TexMetadata& metadata )
         break;
 
     case TEX_DIMENSION_TEXTURE2D:
-        if ( metadata.miscFlags & TEX_MISC_TEXTURECUBE )
+        if ( metadata.IsCubemap() )
         {
             if ( !(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURECUBE) )
                 return false;
@@ -505,7 +505,7 @@ HRESULT CreateTextureEx( ID3D11Device* pDevice, const Image* srcImages, size_t n
             desc.Usage = usage;
             desc.BindFlags = bindFlags;
             desc.CPUAccessFlags = cpuAccessFlags;
-            if (metadata.miscFlags & TEX_MISC_TEXTURECUBE)
+            if ( metadata.IsCubemap() )
                 desc.MiscFlags =  miscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE;
             else
                 desc.MiscFlags =  miscFlags & ~D3D11_RESOURCE_MISC_TEXTURECUBE;
@@ -589,7 +589,7 @@ HRESULT CreateShaderResourceViewEx( ID3D11Device* pDevice, const Image* srcImage
         break;
 
     case TEX_DIMENSION_TEXTURE2D:
-        if ( metadata.miscFlags & TEX_MISC_TEXTURECUBE )
+        if ( metadata.IsCubemap() )
         {
             if (metadata.arraySize > 6)
             {
@@ -685,6 +685,7 @@ HRESULT CaptureTexture( ID3D11Device* pDevice, ID3D11DeviceContext* pContext, ID
             mdata.arraySize = desc.ArraySize;
             mdata.mipLevels = desc.MipLevels;
             mdata.miscFlags = 0;
+            mdata.miscFlags2 = 0;
             mdata.format = desc.Format;
             mdata.dimension = TEX_DIMENSION_TEXTURE1D;
 
@@ -786,6 +787,7 @@ HRESULT CaptureTexture( ID3D11Device* pDevice, ID3D11DeviceContext* pContext, ID
             mdata.arraySize = desc.ArraySize;
             mdata.mipLevels = desc.MipLevels;
             mdata.miscFlags = (desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) ? TEX_MISC_TEXTURECUBE : 0;
+            mdata.miscFlags2 = 0;
             mdata.format = desc.Format;
             mdata.dimension = TEX_DIMENSION_TEXTURE2D;
 
@@ -830,6 +832,7 @@ HRESULT CaptureTexture( ID3D11Device* pDevice, ID3D11DeviceContext* pContext, ID
             mdata.arraySize = 1;
             mdata.mipLevels = desc.MipLevels;
             mdata.miscFlags = 0;
+            mdata.miscFlags2 = 0;
             mdata.format = desc.Format;
             mdata.dimension = TEX_DIMENSION_TEXTURE3D;