public BaseBitmap(BitmapTextureInterleavedInteropResource definition, int index, Bitmap.Image image)
{
if (index == 0)
{
var def = definition.Texture.Definition.Bitmap1;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.BitmapType;
Flags = image.Flags;
UpdateFormat(image.Format);
}
else
{
var def = definition.Texture.Definition.Bitmap2;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.BitmapType;
Flags = image.Flags;
UpdateFormat(image.Format);
}
MipMapOffset = image.MipMapOffset;
Curve = image.Curve;
}
private void SetTextureFormat(int mipMapCount, BitmapFormat format, BitmapFlags flags)
{
if (mipMapCount > 0)
{
MipMapCount = mipMapCount;
Flags |= DDSFlags.MipMapCount;
}
else
{
MipMapCount = 0;
}
if (flags.HasFlag(BitmapFlags.Compressed))
{
Flags |= DDSFlags.LinearSize;
int blockSize = BitmapFormatUtils.GetBlockSize(format);
int blockDimension = BitmapFormatUtils.GetBlockDimension(format);
var nearestWidth = blockDimension * ((Height + (blockDimension - 1)) / blockDimension);
var nearestHeight = blockDimension * ((Width + (blockDimension - 1)) / blockDimension);;
PitchOrLinearSize = (nearestWidth * nearestHeight / 16) * blockSize;
}
else
{
Flags |= DDSFlags.Pitch;
int bitsPerPixel = BitmapFormatUtils.GetBitsPerPixel(format);
PitchOrLinearSize = (Width * bitsPerPixel + 7) / 8;
}
PixelFormat = new PixelFormat(format, flags);
}
public BaseBitmap(BitmapTextureInterleavedInteropResource definition, int index, Bitmap.Image image)
{
var def = definition.Texture.Definition;
if (index == 0)
{
Height = def.Height1;
Width = def.Width1;
Depth = def.Depth1;
MipMapCount = def.MipmapCount1 - 1;
Type = def.Type1;
Flags = image.Flags;
UpdateFormat(image.Format);
}
else
{
Height = def.Height2;
Width = def.Width2;
Depth = def.Depth2;
MipMapCount = def.MipmapCount2 - 1;
Type = def.Type2;
Flags = image.Flags;
UpdateFormat(image.Format);
}
}
private void CreateHeaderCubemap(int mipMapCount, BitmapFormat format, BitmapFlags flags)
{
Caps |= DDSComplexityFlags.Complex;
Caps2 |= DDSSurfaceInfoFlags.CubeMapAllFaces;
SetTextureFormat(mipMapCount, format, flags);
}
public BaseBitmap(BaseBitmap bitmap)
{
Height = bitmap.Height;
Width = bitmap.Width;
Depth = bitmap.Depth;
MipMapCount = bitmap.MipMapCount;
Type = bitmap.Type;
Flags = bitmap.Flags;
UpdateFormat(bitmap.Format);
}
public BaseBitmap(Bitmap.Image image)
{
Height = image.Height;
Width = image.Width;
Depth = image.Depth;
MipMapCount = image.MipmapCount;
Type = image.Type;
Flags = image.Flags;
UpdateFormat(image.Format);
}
public BaseBitmap(BitmapTextureInteropDefinition definition, Bitmap.Image image)
{
Height = definition.Height;
Width = definition.Width;
Depth = definition.Depth;
MipMapCount = definition.MipmapCount != 0 ? definition.MipmapCount - 1 : 0;
Type = definition.BitmapType;
Flags = image.Flags;
Curve = image.Curve;
MipMapOffset = image.MipMapOffset;
UpdateFormat(image.Format);
}
public BaseBitmap(BitmapTextureInteropResource definition, Bitmap.Image image)
{
var def = definition.Texture.Definition;
Height = def.Height;
Width = def.Width;
Depth = def.Depth;
MipMapCount = def.MipmapCount - 1;
Type = def.Type;
Flags = image.Flags;
UpdateFormat(image.Format);
}
public void Load(BinaryReaderBE reader)
{
Width = reader.ReadInt16();
Height = reader.ReadInt16();
bytesPerRow = reader.ReadInt16();
flags = (BitmapFlags)reader.ReadUInt16();
BitDepth = reader.ReadInt16();
int scanlines = ColumnOrder ? Width : Height;
reader.BaseStream.Seek(20 + scanlines * 4, SeekOrigin.Current);
data = new byte[Width * Height];
if (bytesPerRow > -1)
{
// not compressed
// if (ColumnOrder) {
// // rotate
// short temp = Width;
// Width = Height;
// Height = temp;
// for (int y = Height - 1; y >= 0; --y) {
// for (int x = 0; x < Width; ++x) {
// data[x + y * Width] = reader.ReadByte();
// }
// }
// } else {
reader.Read(data, 0, Width * Height);
// }
}
else
{
ColumnOrder = false;
for (int x = 0; x < Width; x++)
{
short start = reader.ReadInt16();
short end = reader.ReadInt16();
for (int y = start; y < end; y++)
{
data[x + y * Width] = reader.ReadByte();
}
// int dstp = x + start * Width;
// while (start != end) {
// data[dstp] = reader.ReadByte();
// dstp += Width;
// start++;
// }
}
}
}
public void Load(BinaryReaderBE reader)
{
Width = reader.ReadInt16();
Height = reader.ReadInt16();
bytesPerRow = reader.ReadInt16();
flags = (BitmapFlags)reader.ReadUInt16();
BitDepth = reader.ReadInt16();
int scanlines = ColumnOrder ? Width : Height;
reader.BaseStream.Seek(20 + scanlines * 4, SeekOrigin.Current);
data = new byte[Width * Height];
if (bytesPerRow > -1)
{
// not compressed
if (ColumnOrder)
{
// rotate
short temp = Width;
Width = Height;
Height = temp;
for (int y = Height - 1; y >= 0; --y)
{
for (int x = 0; x < Width; ++x)
{
data[x + y * Width] = reader.ReadByte();
}
}
}
else
{
reader.Read(data, 0, Width * Height);
}
}
else
{
for (int x = 0; x < Width; ++x)
{
short start = reader.ReadInt16();
short end = reader.ReadInt16();
for (int y = start; y < end; ++y)
{
data[x + y * Width] = reader.ReadByte();
}
}
}
}
private void CreateHeaderTexture2D(int mipMapCount, BitmapFormat format, BitmapFlags flags)
{
Depth = 0;
if (mipMapCount > 0)
{
MipMapCount = 1 + mipMapCount;
Flags |= DDSFlags.MipMapCount;
Caps |= DDSComplexityFlags.MipMap | DDSComplexityFlags.Complex;
}
else
{
MipMapCount = 0;
}
SetTextureFormat(mipMapCount, format, flags);
}
/// <summary>
/// Initializes a new <see cref="HaloBitmap"/> instance using the supplied object index entry.
/// </summary>
/// <param name="entry">The object index entry that contains the bitmap tag group data.</param>
/// <exception cref="ArgumentNullException"><paramref name="entry"/> is null.</exception>
/// <exception cref="ArgumentException"><paramref name="entry"/> is not a bitmap.</exception>
public HaloBitmap(IndexEntry entry)
{
//Check
if (entry == null)
{
throw new ArgumentNullException(nameof(entry));
}
else if (entry.Root != HaloTags.bitm)
{
throw new ArgumentException("Index entry is not bitmap.", nameof(entry));
}
//Setup
this.entry = entry;
tag = new BitmapTag(entry);
maps = new Bitmap[tag.Bitmaps.Length][][];
//Setup Property Accessors
bitmaps = new BitmapProperties[tag.Bitmaps.Length];
for (int i = 0; i < tag.Bitmaps.Length; i++)
{
bitmaps[i] = new BitmapProperties(this, i);
}
sequences = new SequenceProperties[tag.Sequences.Length];
for (int i = 0; i < tag.Sequences.Length; i++)
{
sequences[i] = new SequenceProperties(this, i);
}
//Check
if (tag == null)
{
return;
}
else if (tag.Bitmaps.Length == 0)
{
return;
}
//Loop through bitmaps
for (int k = 0; k < tag.Bitmaps.Length; k++)
{
//Setup
BitmapTagGroup.Bitmap bitmap = tag.Bitmaps[k];
maps[k] = new Bitmap[6][];
//Loop through LODs
byte[] sourceData = null;
for (int l = 0; l < 6; l++)
{
//Get source data
if (bitmap.rawOffsets[l] != uint.MaxValue)
{
RawLocation rawLocation = (RawLocation)(bitmap.rawOffsets[l] & 0xC0000000);
if (rawLocation == RawLocation.Local)
{
sourceData = entry.Raws[RawSection.Bitmap][(int)bitmap.rawOffsets[l]].GetBuffer();
}
else
{
string filelocation = string.Empty;
int rawOffset = (int)(bitmap.rawOffsets[l] & (uint)RawLocation.LocalMask);
switch (rawLocation)
{
case RawLocation.Mainmenu:
filelocation = HaloSettings.MainmenuPath;
break;
case RawLocation.Shared:
filelocation = HaloSettings.SharedPath;
break;
case RawLocation.SinglePlayerShared:
filelocation = HaloSettings.SingleplayerSharedPath;
break;
}
//Check
if (File.Exists(filelocation))
{
using (FileStream fs = new FileStream(filelocation, FileMode.Open))
using (BinaryReader mapReader = new BinaryReader(fs))
{
fs.Seek(rawOffset, SeekOrigin.Begin);
sourceData = mapReader.ReadBytes(bitmap.rawLengths[l]);
}
}
}
}
//Set
if (sourceData.Length == 0)
{
continue;
}
//Prepare
BitmapFlags flags = (BitmapFlags)bitmap.flags;
BitmapFormat format = (BitmapFormat)bitmap.format;
PixelFormat bitmapFormat = PixelFormat.Format32bppArgb;
int sourceBits = 32;
switch (format)
{
case BitmapFormat.A8:
case BitmapFormat.Y8:
case BitmapFormat.P8Bump:
case BitmapFormat.P8:
case BitmapFormat.Ay8: sourceBits = 8; break;
case BitmapFormat.A8y8:
case BitmapFormat.A1r5g5b5:
case BitmapFormat.A4r4g4b4:
case BitmapFormat.V8u8:
case BitmapFormat.G8b8:
case BitmapFormat.R5g6b5: sourceBits = 16; break;
case BitmapFormat.Dxt1: sourceBits = 4; break;
case BitmapFormat.Dxt5:
case BitmapFormat.Dxt3: sourceBits = 8; break;
case BitmapFormat.Argbfp32: sourceBits = 128; break;
}
//Handle
switch (format)
{
case BitmapFormat.R5g6b5: bitmapFormat = PixelFormat.Format16bppRgb565; break;
case BitmapFormat.A1r5g5b5: bitmapFormat = PixelFormat.Format16bppArgb1555; break;
case BitmapFormat.X8r8g8b8: bitmapFormat = PixelFormat.Format32bppRgb; break;
case BitmapFormat.P8Bump: bitmapFormat = PixelFormat.Format8bppIndexed; break;
case BitmapFormat.P8: bitmapFormat = PixelFormat.Format8bppIndexed; break;
}
//Prepare
int width = bitmap.width, height = bitmap.height;
if (flags.HasFlag(BitmapFlags.Linear))
{
width = (int)Math.Ceiling(width / 16f) * 16;
}
//Loop LOD
for (int i = 0; i < l; i++)
{
width /= 2;
height /= 2;
}
//Prepare
int mapWidth = width, mapHeight = height, location = 0;
int mipmapCount = bitmap.mipmapCount;
maps[k][l] = new Bitmap[mipmapCount + 1];
Size bitmapSize = Size.Empty;
byte[] mapData = null;
//Loop
for (int i = 1; i <= mipmapCount + 1; i++)
{
//Prepare
int mapIndex = i - 1;
mapWidth = width; mapHeight = height;
for (int j = 1; j < i; j++)
{
mapWidth /= 2;
mapHeight /= 2;
}
//Get Size
bitmapSize = new Size(mapWidth, mapHeight);
//Check
if (bitmapSize.Width == 0 || bitmapSize.Height == 0)
{
continue;
}
//Create Map
int mapStride = mapWidth * sourceBits / 8;
int mapSize = mapStride * mapHeight;
//Ehh?
switch (format)
{
case BitmapFormat.Dxt1: mapSize = Math.Max(mapSize, 8); break;
case BitmapFormat.Dxt3:
case BitmapFormat.Dxt5: mapSize = Math.Max(mapSize, 16); break;
case BitmapFormat.P8:
case BitmapFormat.P8Bump: mapSize = Math.Max(mapSize, 16); break;
default: mapSize = Math.Max(mapSize, 1); break;
}
mapData = new byte[mapSize];
if (location + mapSize > sourceData.Length)
{
continue;
}
Array.Copy(sourceData, location, mapData, 0, mapSize);
//Deswizzle?
if ((flags & BitmapFlags.Swizzled) == BitmapFlags.Swizzled)
{
mapData = Swizzler.Swizzle(mapData, mapWidth, mapHeight, bitmap.depth, sourceBits, true);
}
if (mapData == null)
{
mapData = new byte[mapSize];
}
using (Bitmap map = new Bitmap(mapWidth, mapHeight, bitmapFormat))
{
unsafe
{
//Lock Bits
BitmapData data = map.LockBits(new Rectangle(0, 0, mapWidth, mapHeight), ImageLockMode.ReadWrite, bitmapFormat);
//Prepare Buffer
byte[] bitmapData = new byte[data.Stride * data.Height];
int dataLength = Math.Min(bitmapData.Length, mapSize);
//Handle Format...
switch (format)
{
case BitmapFormat.A8:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = 255;
bitmapData[x * 4 + 1] = 255;
bitmapData[x * 4 + 2] = 255;
bitmapData[x * 4 + 3] = mapData[x];
}
break;
case BitmapFormat.Y8:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = mapData[x];
bitmapData[x * 4 + 1] = mapData[x];
bitmapData[x * 4 + 2] = mapData[x];
bitmapData[x * 4 + 3] = 255;
}
break;
case BitmapFormat.Ay8:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = mapData[x];
bitmapData[x * 4 + 1] = mapData[x];
bitmapData[x * 4 + 2] = mapData[x];
bitmapData[x * 4 + 3] = mapData[x];
}
break;
case BitmapFormat.A8y8:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = mapData[x * 2];
bitmapData[x * 4 + 1] = mapData[x * 2];
bitmapData[x * 4 + 2] = mapData[x * 2];
bitmapData[x * 4 + 3] = mapData[x * 2 + 1];
}
break;
case BitmapFormat.A4r4g4b4:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = (byte)(mapData[x * 2 + 0] & 0xF0);
bitmapData[x * 4 + 1] = (byte)(mapData[x * 2 + 0] & 0x0F);
bitmapData[x * 4 + 2] = (byte)(mapData[x * 2 + 1] & 0xF0);
bitmapData[x * 4 + 3] = (byte)(mapData[x * 2 + 1] & 0x0F);
}
break;
case BitmapFormat.P8Bump:
case BitmapFormat.P8: Array.Copy(mapData, 0, bitmapData, 0, dataLength); break;
case BitmapFormat.R5g6b5: Array.Copy(mapData, 0, bitmapData, 0, dataLength); break;
case BitmapFormat.A1r5g5b5: Array.Copy(mapData, 0, bitmapData, 0, dataLength); break;
case BitmapFormat.X8r8g8b8: Array.Copy(mapData, 0, bitmapData, 0, dataLength); break;
case BitmapFormat.A8r8g8b8: Array.Copy(mapData, 0, bitmapData, 0, dataLength); break;
case BitmapFormat.Dxt1:
if (mapWidth >= 4 && mapHeight >= 4)
{
S3TC.DecompressDxt1(ref bitmapData, mapData, bitmapSize);
}
break;
case BitmapFormat.Dxt3:
if (mapWidth >= 4 && mapHeight >= 4)
{
S3TC.DecompressDxt3(ref bitmapData, mapData, bitmapSize);
}
break;
case BitmapFormat.Dxt5:
if (mapWidth >= 4 && mapHeight >= 4)
{
S3TC.DecompressDxt5(ref bitmapData, mapData, bitmapSize);
}
break;
case BitmapFormat.Argbfp32:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = (byte)Math.Min((BitConverter.ToSingle(mapData, x * 16 + 8) * 255f), 255f);
bitmapData[x * 4 + 1] = (byte)Math.Min((BitConverter.ToSingle(mapData, x * 16 + 4) * 255f), 255f);
bitmapData[x * 4 + 2] = (byte)Math.Min((BitConverter.ToSingle(mapData, x * 16) * 255f), 255f);
bitmapData[x * 4 + 3] = (byte)Math.Min((BitConverter.ToSingle(mapData, x * 16 + 12) * 255f), 255f);
}
break;
case BitmapFormat.Rgbfp32: break;
case BitmapFormat.Rgbfp16: break;
case BitmapFormat.V8u8:
for (int x = 0; x < mapWidth * mapHeight; x++)
{
bitmapData[x * 4 + 0] = 255;
bitmapData[x * 4 + 1] = (byte)(127 + (sbyte)mapData[x * 2 + 1]);
bitmapData[x * 4 + 2] = (byte)(127 + (sbyte)mapData[x * 2]);
bitmapData[x * 4 + 3] = 255;
}
break;
case BitmapFormat.G8b8: break;
}
//Copy
Marshal.Copy(bitmapData, 0, data.Scan0, bitmapData.Length);
map.UnlockBits(data);
//Setup Palettes
if (format == BitmapFormat.P8Bump)
{
map.SetNormalMapPalette();
}
else if (format == BitmapFormat.P8)
{
map.SetGrayscalePalette();
}
//Set
location += mapSize;
}
//Draw into cropped image
maps[k][l][mapIndex] = new Bitmap(bitmap.width, bitmap.height, bitmapFormat);
using (Graphics g = Graphics.FromImage(maps[k][l][mapIndex])) g.DrawImage(map, Point.Empty);
}
}
}
}
}
public void SetTextureFormat(BitmapFormat format, BitmapFlags flags)
{
if (flags.HasFlag(BitmapFlags.Compressed))
{
Flags |= DDSPixelFormatFlags.Compressed;
switch (format)
{
case BitmapFormat.Dxt5:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x35545844;
break;
case BitmapFormat.Dxt3:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x33545844;
break;
case BitmapFormat.Dxt1:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x31545844;
break;
case BitmapFormat.Dxn:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x32495441;
break;
default:
throw new Exception($"Unsupported bitmap format {format}");
}
}
else
{
Flags |= DDSPixelFormatFlags.RGB;
RGBBitCount = BitmapFormatUtils.GetBitsPerPixel(format);
switch (format)
{
case BitmapFormat.A8:
case BitmapFormat.AY8:
ABitMask = 0xFF;
Flags |= DDSPixelFormatFlags.Alpha;
break;
case BitmapFormat.Y8:
RBitMask = 0xFF;
Flags |= DDSPixelFormatFlags.Luminance;
break;
case BitmapFormat.A8Y8:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0x00FF; ABitMask = 0xFF00;
break;
case BitmapFormat.R5G6B5:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0xF800; GBitMask = 0x07E0; BBitMask = 0x001F;
break;
case BitmapFormat.A1R5G5B5:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0x7C00; GBitMask = 0x03E0; BBitMask = 0x001F; ABitMask = 0x8000;
break;
case BitmapFormat.A4R4G4B4:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0xF000; GBitMask = 0x0F00; BBitMask = 0x00F0; ABitMask = 0x000F;
break;
case BitmapFormat.A4R4G4B4Font:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0xF000; GBitMask = 0x0F00; BBitMask = 0x00F0; ABitMask = 0x000F;
break;
case BitmapFormat.A8R8G8B8:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0x00FF0000; GBitMask = 0x0000FF00; BBitMask = 0x000000FF; ABitMask = 0xFF000000;
break;
case BitmapFormat.X8R8G8B8:
Flags |= DDSPixelFormatFlags.RGB;
RBitMask = 0x00FF0000; GBitMask = 0x0000FF00; BBitMask = 0x000000FF;
break;
case BitmapFormat.V8U8:
RBitMask = 0xFF00; GBitMask = 0x00FF;
Flags |= DDSPixelFormatFlags.BumpDUDV;
break;
case BitmapFormat.A32B32G32R32F:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x74;
break;
case BitmapFormat.A16B16G16R16F:
Flags |= DDSPixelFormatFlags.FourCC;
FourCC = 0x71;
break;
default:
throw new Exception($"Unsupported bitmap format {format}");
}
}
}
public PixelFormat(BitmapFormat format, BitmapFlags flags)
{
SetTextureFormat(format, flags);
}
private void CreateHeaderVolume(int mipMapCount, int depth, BitmapFormat format, BitmapFlags flags)
{
Flags |= DDSFlags.Depth;
Caps |= DDSComplexityFlags.Complex;
Caps2 |= DDSSurfaceInfoFlags.Volume;
Depth = depth;
SetTextureFormat(mipMapCount, format, flags);
}
private void CreateHeaderFromType(int height, int width, int depth, int mipMapCount, BitmapFormat format, BitmapType type, BitmapFlags flags)
{
Height = height;
Width = width;
Flags |= DDSFlags.Height | DDSFlags.Width;
switch (type)
{
case BitmapType.Texture2D:
CreateHeaderTexture2D(mipMapCount, format, flags);
break;
case BitmapType.Texture3D:
case BitmapType.Array:
CreateHeaderVolume(mipMapCount, depth, format, flags);
break;
case BitmapType.CubeMap:
CreateHeaderCubemap(mipMapCount, format, flags);
break;
}
return;
}
