(GXT): preliminary implementation.

ArcFormats/Cri/ImageGXT.cs

@@ -0,0 +1,176 @@
+//! \file       ImageGXT.cs
+//! \date       2019 Feb 25
+//! \brief      CRI Middleware image format.
+//
+// Copyright (C) 2019 by morkt
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//
+
+using System;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Windows.Media;
+using GameRes.Formats.DirectDraw;
+
+namespace GameRes.Formats.Cri
+{
+    internal class GxtMetaData : ImageMetaData
+    {
+        public uint TextureOffset;
+        public int  TextureLength;
+        public int  PaletteIndex;
+        public uint Flags;
+        public GxtTextureType   TextureType;
+        public GxtTextureFormat TextureFormat;
+    }
+
+    internal enum GxtTextureType : uint
+    {
+        Swizzled    = 0x00000000,
+        Cube        = 0x40000000,
+        Linear      = 0x60000000,
+        Tiled       = 0x80000000,
+        LinearStrided = 0xC0000000,
+    };
+
+    internal enum GxtTextureFormat : uint
+    {
+        UBC3 = 0x87000000,
+    }
+
+    [Export(typeof(ImageFormat))]
+    public class GxtFormat : ImageFormat
+    {
+        public override string         Tag { get { return "GXT"; } }
+        public override string Description { get { return "CRI Middleware image format"; } }
+        public override uint     Signature { get { return 0x545847; } } // 'GXT'
+
+        public override ImageMetaData ReadMetaData (IBinaryStream file)
+        {
+            var header = file.ReadHeader (0x40);
+            if (header.ToInt32 (4) != 0x10000003)
+                return null;
+            return new GxtMetaData {
+                Width  = header.ToUInt16 (0x38),
+                Height = header.ToUInt16 (0x3A),
+                TextureOffset = header.ToUInt32 (0x20),
+                TextureLength = header.ToInt32 (0x24),
+                PaletteIndex = header.ToInt32 (0x28),
+                Flags = header.ToUInt32 (0x2C),
+                TextureType = (GxtTextureType)header.ToUInt32 (0x30),
+                TextureFormat = (GxtTextureFormat)header.ToUInt32 (0x34),
+            };
+        }
+
+        public override ImageData Read (IBinaryStream file, ImageMetaData info)
+        {
+            var meta = (GxtMetaData)info;
+            file.Position = meta.TextureOffset;
+            var data = file.ReadBytes (meta.TextureLength);
+            if (GxtTextureFormat.UBC3 == meta.TextureFormat)
+            {
+                var pixels = UnpackDXT5 (data, meta);
+                return ImageData.Create (info, PixelFormats.Bgra32, null, pixels);
+            }
+            else
+                throw new NotSupportedException (string.Format ("GXT texture format {0:X8} not supported.", meta.TextureFormat));
+        }
+
+        byte[] UnpackDXT5 (byte[] input, GxtMetaData info)
+        {
+            var decoder = new DxtDecoder (input, info);
+            int src = 0;
+            for (int y = 0; y < info.iHeight; y += 4)
+            for (int x = 0; x < info.iWidth; x += 4)
+            {
+                int px, py;
+                GetSwizzledCoords (x / 4, y / 4, info.iWidth / 4, info.iHeight / 4, out px, out py);
+                decoder.DecompressDXT5Block (input, src, py * 4, px * 4);
+                src += 16;
+            }
+            return decoder.Output;
+        }
+
+        void GetSwizzledCoords (int origX, int origY, int width, int height, out int trX, out int trY)
+        {
+            if (width == 0)
+                width = 16;
+            if (height == 0)
+                height = 16;
+
+            int i = (origY * width) + origX;
+
+            int min = Math.Min (width, height);
+            int k = BitScanReverse ((uint)min); // Math.Log (min, 2);
+
+            if (height < width)
+            {
+                // XXXyxyxyx → XXXxxxyyy
+                int j = i >> (2 * k) << (2 * k)
+                    | (DecodeCoord2Y (i) & (min - 1)) << k
+                    | (DecodeCoord2X (i) & (min - 1));
+                trX = j / height;
+                trY = j % height;
+            }
+            else
+            {
+                // YYYyxyxyx → YYYyyyxxx
+                int j = i >> (2 * k) << (2 * k)
+                    | (DecodeCoord2X (i) & (min - 1)) << k
+                    | (DecodeCoord2Y (i) & (min - 1));
+                trX = j % width;
+                trY = j / width;
+            }
+        }
+
+        internal static int BitScanReverse (uint x)
+        {
+            int n = 0;
+            while ((x >>= 1) != 0)
+                ++n;
+            return n;
+        }
+
+        private static int DecodeCoord2X (int code)
+        {
+            return Compact1By1 (code);
+        }
+
+        private static int DecodeCoord2Y (int code)
+        {
+            return Compact1By1 (code >> 1);
+        }
+
+        private static int Compact1By1 (int x)
+        {
+            x &= 0x55555555;
+            x = (x ^ (x >> 1)) & 0x33333333;
+            x = (x ^ (x >> 2)) & 0x0f0f0f0f;
+            x = (x ^ (x >> 4)) & 0x00ff00ff;
+            x = (x ^ (x >> 8)) & 0x0000ffff;
+            return x;
+        }
+
+        public override void Write (Stream file, ImageData image)
+        {
+            throw new System.NotImplementedException ("GxtFormat.Write not implemented");
+        }
+    }
+}