mirror of
https://github.com/crskycode/GARbro.git
synced 2024-12-29 14:24:13 +08:00
177 lines
6.0 KiB
C#
177 lines
6.0 KiB
C#
//! \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");
|
|
}
|
|
}
|
|
}
|