private void ReadPalette(BinaryReader reader)
{
int paletteWH;
if (PixelFormat == PS2PixelFormat.PSMT4 || PixelFormat == PS2PixelFormat.PSMT4HL || PixelFormat == PS2PixelFormat.PSMT4HH)
{
PaletteColorCount = 16;
paletteWH = 4;
}
else
{
PaletteColorCount = 256;
paletteWH = 16;
}
Palettes = new Color[PaletteCount][];
for (int i = 0; i < PaletteCount; i++)
{
PS2PixelFormatHelper.ReadPixelData(PaletteFormat, reader, paletteWH, paletteWH, out Palettes[i]);
if (PaletteColorCount == 256)
{
PS2PixelFormatHelper.TilePalette(Palettes[i], out Palettes[i]);
}
}
}
/// <summary>
/// Initializer only to be called by the <see cref="RwNodeFactory"/>.
/// </summary>
internal RwRasterDataStructNode(RwNodeFactory.RwNodeHeader header, BinaryReader reader)
: base(header)
{
long start = reader.BaseStream.Position;
if (RasterInfoStructNode.Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
mImageHeader = new PS2StandardImageHeader(reader);
}
if (PS2PixelFormatHelper.IsIndexedPixelFormat(RasterInfoStructNode.Tex0Register.TexturePixelFormat))
{
ReadIndices(reader);
if (RasterInfoStructNode.Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
mPaletteHeader = new PS2StandardImageHeader(reader);
}
ReadPalette(reader);
}
else
{
ReadPixels(reader);
}
long end = reader.BaseStream.Position;
mMipMapData = reader.ReadBytes((int)((start + Size) - end));
}
private void WritePalette(BinaryWriter writer)
{
Color[][] outPaletteEntries = null;
int paletteWH = PS2PixelFormatHelper.GetPaletteDimension(PaletteFormat);
if (PaletteColorCount == 256)
{
outPaletteEntries = new Color[PaletteCount][];
// Tile the palette
for (int i = 0; i < PaletteCount; i++)
{
PS2PixelFormatHelper.TilePalette(Palettes[i], out outPaletteEntries[i]);
}
}
else
{
outPaletteEntries = Palettes;
}
for (int i = 0; i < PaletteCount; i++)
{
PS2PixelFormatHelper.WritePixelData(PaletteFormat, writer, paletteWH, paletteWH, outPaletteEntries[i]);
}
}
/// <summary>
/// Inherited from <see cref="RwNode"/>. Writes the data beyond the header.
/// </summary>
/// <param name="writer">The <see cref="BinaryWriter"/> to write the data with.</param>
protected internal override void WriteBody(BinaryWriter writer)
{
if (RasterInfoStructNode.Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
writer.Write(mImageHeader.GetBytes());
}
if (PS2PixelFormatHelper.IsIndexedPixelFormat(RasterInfoStructNode.Tex0Register.TexturePixelFormat))
{
WriteIndices(writer);
if (RasterInfoStructNode.Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
writer.Write(mPaletteHeader.GetBytes());
}
WritePalette(writer);
}
else
{
WritePixels(writer);
}
writer.Write(mMipMapData);
}
private void ReadPixels(BinaryReader reader)
{
if (UsesPalette)
{
byte[] temp;
PS2PixelFormatHelper.ReadPixelData(PixelFormat, reader, Width, Height, out temp);
PixelIndices = temp;
MipMapPixelIndices = new byte[MipMapCount][];
for (int i = 0; i < MipMapCount; i++)
{
int div = 2 * (2 * i);
PS2PixelFormatHelper.ReadPixelData(PixelFormat, reader, Width / div, Height / div, out MipMapPixelIndices[i]);
}
}
else
{
Color[] temp;
PS2PixelFormatHelper.ReadPixelData(PixelFormat, reader, Width, Height, out temp);
Pixels = temp;
MipMapPixels = new Color[MipMapCount][];
for (int i = 0; i < MipMapCount; i++)
{
int div = 2 * (2 * i);
PS2PixelFormatHelper.ReadPixelData(PixelFormat, reader, Width / div, Height / div, out MipMapPixels[i]);
}
}
}
private static void ScalePSMCT32PixelsToHalfAlphaRange(Color[] colors)
{
for (int c = 0; c < colors.Length; c++)
{
colors[c] = Color.FromArgb(
PS2PixelFormatHelper.ScaleFullRangeAlphaToHalfRange(colors[c].A),
colors[c].R,
colors[c].G,
colors[c].B);
}
}
/// <summary>
/// Read the palette from the stream using given pixel format, untile it, and set the data as the palette member value.
/// </summary>
private void ReadPalette(BinaryReader reader)
{
int paletteWH = PS2PixelFormatHelper.GetPaletteDimension(RasterInfoStructNode.Tex0Register.TexturePixelFormat);
PS2PixelFormatHelper.ReadPixelData(RasterInfoStructNode.Tex0Register.ClutPixelFormat, reader, paletteWH, paletteWH, out mPalette);
if (paletteWH == 16)
{
PS2PixelFormatHelper.TilePalette(mPalette, out mPalette);
}
}
/// <summary>
/// Initialize a new instanc eof <see cref="RwRasterDataStructNode"/> using a given bitmap and a PS2 <see cref="PS2.Graphics.PS2PixelFormat"/> to encode the bitmap to.
/// </summary>
/// <param name="bitmap">Bitmap to be encoded using the given pixel format.</param>
/// <param name="pixelFormat">The pixel format the bitmap will be encoded to and stored in the texture data.</param>
public RwRasterDataStructNode(Bitmap bitmap, PS2PixelFormat pixelFormat)
: base(RwNodeId.RwStructNode)
{
if (PS2PixelFormatHelper.IsIndexedPixelFormat(pixelFormat))
{
BitmapHelper.QuantizeBitmap(bitmap, PS2PixelFormatHelper.GetIndexedColorCount(pixelFormat), out mIndices, out mPalette);
}
else
{
mPixels = BitmapHelper.GetColors(bitmap)
.Select(x => Color.FromArgb(PS2PixelFormatHelper.ScaleFullRangeAlphaToHalfRange(x.A), x.R, x.G, x.B))
.ToArray();
}
mMipMapData = new byte[0];
}
private static Color[] ScalePSMCT32PixelsToFullAlphaRange(Color[] colors)
{
int colorCount = colors.Length;
Color[] scaledColors = new Color[colorCount];
for (int c = 0; c < colorCount; c++)
{
scaledColors[c] = Color.FromArgb(
PS2PixelFormatHelper.ScaleHalfRangeAlphaToFullRange(colors[c].A),
colors[c].R,
colors[c].G,
colors[c].B);
}
return(scaledColors);
}
public Color[] GetPixels()
{
if (IsIndexed && mRasterStructNode.DataStructNode.Pixels == null)
{
mRasterStructNode.DataStructNode.Pixels = new Color[Width * Height];
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
var color = Palette[PixelIndices[x + y * Width]];
mRasterStructNode.DataStructNode.Pixels[x + y * Width] =
Color.FromArgb(PS2PixelFormatHelper.ScaleHalfRangeAlphaToFullRange(color.A), color.R, color.G, color.B);
}
}
}
return(mRasterStructNode.DataStructNode.Pixels);
}
/// <summary>
/// Make a copy of the palette, tile it, and write the palette to the stream using set pixel format.
/// </summary>
private void WritePalette(BinaryWriter writer)
{
int paletteWH = PS2PixelFormatHelper.GetPaletteDimension(RasterInfoStructNode.Tex0Register.TexturePixelFormat);
Color[] outPalette;
if (paletteWH == 16)
{
PS2PixelFormatHelper.TilePalette(mPalette, out outPalette);
}
else
{
outPalette = mPalette;
}
switch (RasterInfoStructNode.Tex0Register.ClutPixelFormat)
{
case PS2PixelFormat.PSMZ32:
case PS2PixelFormat.PSMTC32:
PS2PixelFormatHelper.WritePSMCT32(writer, paletteWH, paletteWH, outPalette);
break;
case PS2PixelFormat.PSMZ24:
case PS2PixelFormat.PSMTC24:
PS2PixelFormatHelper.WritePSMCT24(writer, paletteWH, paletteWH, outPalette);
break;
case PS2PixelFormat.PSMZ16:
case PS2PixelFormat.PSMTC16:
PS2PixelFormatHelper.WritePSMCT16(writer, paletteWH, paletteWH, outPalette);
break;
case PS2PixelFormat.PSMZ16S:
case PS2PixelFormat.PSMTC16S:
PS2PixelFormatHelper.WritePSMCT16S(writer, paletteWH, paletteWH, outPalette);
break;
default:
throw new NotImplementedException();
}
}
private void WritePixels(BinaryWriter writer)
{
if (UsesPalette)
{
PS2PixelFormatHelper.WritePixelData(PixelFormat, writer, Width, Height, PixelIndices);
for (int i = 0; i < MipMapCount; i++)
{
int div = 2 * (2 * i);
PS2PixelFormatHelper.WritePixelData(PixelFormat, writer, Width / div, Height / div, MipMapPixelIndices[i]);
}
}
else
{
PS2PixelFormatHelper.WritePixelData(PixelFormat, writer, Width, Height, Pixels);
for (int i = 0; i < MipMapCount; i++)
{
int div = 2 * (2 * i);
PS2PixelFormatHelper.WritePixelData(PixelFormat, writer, Width / div, Height / div, MipMapPixels[i]);
}
}
}
/// <summary>
/// Make a copy of the pixel indices, swizzle it, and write it to the stream.
/// </summary>
private void WriteIndices(BinaryWriter writer)
{
byte[] outIndices;
switch (RasterInfoStructNode.Tex0Register.TexturePixelFormat)
{
case PS2PixelFormat.PSMT8H:
case PS2PixelFormat.PSMT8:
PS2PixelFormatHelper.Swizzle8(RasterInfoStructNode.Width, RasterInfoStructNode.Height, mIndices, out outIndices);
PS2PixelFormatHelper.WritePSMT8(writer, RasterInfoStructNode.Width, RasterInfoStructNode.Height, outIndices);
break;
case PS2PixelFormat.PSMT4HL:
case PS2PixelFormat.PSMT4HH:
case PS2PixelFormat.PSMT4:
PS2PixelFormatHelper.Swizzle8(RasterInfoStructNode.Width, RasterInfoStructNode.Height, mIndices, out outIndices);
PS2PixelFormatHelper.WritePSMT4(writer, RasterInfoStructNode.Width, RasterInfoStructNode.Height, outIndices);
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// <para>Construct a bitmap from the data in this instance.</para>
/// <para>Subsequent calls to this method will return the same bitmap instance without constructing a new one.</para>
/// </summary>
public Bitmap GetBitmap()
{
if (mBitmap != null)
{
return(mBitmap);
}
if (IsIndexed)
{
mBitmap =
BitmapHelper.Create(Palette.Select(x => Color.FromArgb(PS2PixelFormatHelper.ScaleHalfRangeAlphaToFullRange(x.A), x.R, x.G, x.B)).ToArray(),
PixelIndices, Width, Height);
}
else
{
mBitmap =
BitmapHelper.Create(Pixels.Select(x => Color.FromArgb(PS2PixelFormatHelper.ScaleHalfRangeAlphaToFullRange(x.A), x.R, x.G, x.B)).ToArray(),
Width, Height);
}
return(mBitmap);
}
/// <summary>
/// Sets the appropriate rasterStructNode info values based on the width, height and pixel format of the texture.
/// </summary>
/// <param name="width">Width of the texture.</param>
/// <param name="height">Height of the texture.</param>
/// <param name="pixelFormat">PS2 pixel format of the given texture data.</param>
private void CreateRasterInfo(int width, int height, PS2PixelFormat pixelFormat)
{
Width = width;
Height = height;
Depth = PS2PixelFormatHelper.GetPixelFormatDepth(pixelFormat);
Format = GetRasterFormatFromDepth(Depth);
Tex0Register = new Tex0Register(pixelFormat, width, height);
Tex1Register = new Tex1Register(); // default settings
int texSize = width * height;
if (texSize < 16384) // because yes
{
Tex1Register.MaxMipLevel = 7;
Tex1Register.MipMinFilter = PS2FilterMode.None;
if (texSize <= 4096)
{
Tex1Register.MipMaxFilter = PS2FilterMode.None;
}
else
{
Tex1Register.MipMaxFilter = PS2FilterMode.Nearest;
}
}
MipTBP1Register = new MipTbpRegister(); // default settings
MipTBP2Register = new MipTbpRegister(); // default settings
TexelDataLength = (uint)PS2PixelFormatHelper.GetTexelDataSize(pixelFormat, width, height);
// Add image header size to the length if there is one
if (Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
TexelDataLength += PS2StandardImageHeader.Size;
}
PaletteDataLength = 0; // set to 0 if there's no palette present
// division by 2 might only apply for 8 bit..
int transferWidth = width / 2;
int transferHeight = height / 2;
GpuAlignedLength = (uint)(transferWidth * transferHeight);
// Calculate the palette data length for indexed textures
if (Depth == 4 || Depth == 8)
{
int numColors = 256;
if (Depth == 4)
{
numColors = 16;
}
PaletteDataLength = (uint)(numColors * 4);
// division by 4 might only apply for 8 bit..
GpuAlignedLength += PaletteDataLength / 4;
// Add image header size to the length if there is one
if (Format.HasFlagUnchecked(RwRasterFormats.HasHeaders))
{
PaletteDataLength += PS2StandardImageHeader.Size;
}
}
// align to pages of 2048
GpuAlignedLength = (uint)AlignmentHelper.Align(GpuAlignedLength, 2048);
}
private void WritePixels(BinaryWriter writer)
{
PS2PixelFormatHelper.WritePixelData(RasterInfoStructNode.Tex0Register.TexturePixelFormat, writer, RasterInfoStructNode.Width, RasterInfoStructNode.Height, mPixels);
}
public RwTextureNativeNode(string name, Bitmap bitmap)
: this(name, bitmap, PS2PixelFormatHelper.GetBestPixelFormat(bitmap))
{
}
/// <summary>
/// Read the pixel indices from the stream using given info, unswizzle it, and set the data as the pixel indices member value.
/// </summary>
private void ReadIndices(BinaryReader reader)
{
PS2PixelFormatHelper.ReadPixelData(RasterInfoStructNode.Tex0Register.TexturePixelFormat, reader, RasterInfoStructNode.Width, RasterInfoStructNode.Height, out mIndices);
PS2PixelFormatHelper.UnSwizzle8(RasterInfoStructNode.Width, RasterInfoStructNode.Height, mIndices, out mIndices);
}
/// <summary>
/// Read the pixel data from the stream using given info.
/// </summary>
/// <param name="reader"></param>
private void ReadPixels(BinaryReader reader)
{
PS2PixelFormatHelper.ReadPixelData(RasterInfoStructNode.Tex0Register.TexturePixelFormat, reader, RasterInfoStructNode.Width, RasterInfoStructNode.Height, out mPixels);
}
