BrawlLib.Wii.Textures.TextureConverter Class Reference

Inheritance diagram for BrawlLib.Wii.Textures.TextureConverter:

Public Member Functions
int	GetMipOffset (int width, int height, int mipLevel)
int	GetMipOffset (ref int width, ref int height, int mipLevel)
int	GetFileSize (int width, int height, int mipLevels)
virtual FileMap	EncodeTPLTextureIndexed (Bitmap src, int numColors, WiiPaletteFormat format, QuantizationAlgorithm algorithm, out FileMap paletteFile)
virtual FileMap	EncodeTextureIndexed (Bitmap src, int mipLevels, int numColors, WiiPaletteFormat format, QuantizationAlgorithm algorithm, out FileMap paletteFile)
virtual FileMap	EncodeREFTTextureIndexed (Bitmap src, int mipLevels, int numColors, WiiPaletteFormat format, QuantizationAlgorithm algorithm)
virtual FileMap	EncodeTPLTextureIndexed (Bitmap src, int mipLevels, WiiPaletteFormat format, out FileMap paletteFile)
virtual FileMap	EncodeREFTTextureIndexed (Bitmap src, int mipLevels, WiiPaletteFormat format)
virtual FileMap	EncodeTEX0TextureIndexed (Bitmap src, int mipLevels, WiiPaletteFormat format, out FileMap paletteFile)
virtual FileMap	EncodeREFTTexture (Bitmap src, int mipLevels, WiiPaletteFormat format)
virtual FileMap	EncodeTEX0Texture (Bitmap src, int mipLevels)
virtual FileMap	EncodeTPLTexture (Bitmap src, int mipLevels)
Bitmap	DecodeTexture (TEX0v1 *texture)
virtual Bitmap	DecodeTexture (TEX0v1 *texture, int mipLevel)
virtual Bitmap	DecodeTexture (VoidPtr addr, int w, int h, int mipLevel)
virtual Bitmap	DecodeTextureIndexed (TEX0v1 *texture, PLT0v1 *palette, int mipLevel)
virtual Bitmap	DecodeTextureIndexed (TEX0v1 *texture, ColorPalette palette, int mipLevel)
virtual Bitmap	DecodeTextureIndexed (VoidPtr addr, int w, int h, ColorPalette palette, int mipLevel, WiiPixelFormat fmt)

Static Public Member Functions
static Bitmap	Decode (VoidPtr addr, int w, int h, int mipLevel, WiiPixelFormat fmt)
static TextureConverter	Get (WiiPixelFormat format)
static Bitmap	Decode (TEX0v1 *texture, int mipLevel)
static Bitmap	DecodeIndexed (TEX0v1 *texture, PLT0v1 *palette, int mipLevel)
static Bitmap	DecodeIndexed (TEX0v1 *texture, ColorPalette palette, int mipLevel)
static Bitmap	DecodeIndexed (VoidPtr addr, int w, int h, ColorPalette palette, int mipLevel, WiiPixelFormat fmt)
static FileMap	EncodePLT0Palette (ColorPalette pal, WiiPaletteFormat format)
static FileMap	EncodeTPLPalette (ColorPalette pal, WiiPaletteFormat format)
static FileMap	EncodePalette (ColorPalette pal, WiiPaletteFormat format)
static void	EncodePalette (VoidPtr destAddr, ColorPalette pal, WiiPaletteFormat format)
static ColorPalette	DecodePalette (PLT0v1 *palette)
static ColorPalette	DecodePalette (VoidPtr address, int count, WiiPaletteFormat format)

Static Public Attributes
static readonly TextureConverter	I4 = new I4()
static readonly TextureConverter	IA4 = new IA4()
static readonly TextureConverter	I8 = new I8()
static readonly TextureConverter	IA8 = new IA8()
static readonly TextureConverter	RGB565 = new RGB565()
static readonly TextureConverter	RGB5A3 = new RGB5A3()
static readonly TextureConverter	CI4 = new CI4()
static readonly TextureConverter	CI8 = new CI8()
static readonly CMPR	CMPR = new CMPR()
static readonly TextureConverter	RGBA8 = new RGBA8()

Protected Member Functions
abstract void	EncodeBlock (ARGBPixel *sPtr, VoidPtr blockAddr, int width)
abstract void	DecodeBlock (VoidPtr blockAddr, ARGBPixel *destAddr, int width)

Protected Attributes
ColorPalette	_workingPalette

Properties
abstract WiiPixelFormat	RawFormat [get]
abstract int	BitsPerPixel [get]
abstract int	BlockWidth [get]
abstract int	BlockHeight [get]
bool	IsIndexed [get]

Member Function Documentation

Decode() [1/2]

static Bitmap BrawlLib.Wii.Textures.TextureConverter.Decode ( TEX0v1 *  texture, int  mipLevel  )

inlinestatic

        {
            return Get(texture->PixelFormat).DecodeTexture(texture, mipLevel);
        }

Decode() [2/2]

static Bitmap BrawlLib.Wii.Textures.TextureConverter.Decode ( VoidPtr  addr, int  w, int  h, int  mipLevel, WiiPixelFormat  fmt  )

inlinestatic

        {
            return Get(fmt).DecodeTexture(addr, w, h, mipLevel);
        }

DecodeBlock()

abstract void BrawlLib.Wii.Textures.TextureConverter.DecodeBlock ( VoidPtr  blockAddr, ARGBPixel *  destAddr, int  width  )

protectedpure virtual

Implemented in BrawlLib.Wii.Textures.CMPR, and BrawlLib.Wii.Textures.IA4.

DecodeIndexed() [1/3]

static Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeIndexed ( TEX0v1 *  texture, ColorPalette  palette, int  mipLevel  )

inlinestatic

        {
            return Get(texture->PixelFormat).DecodeTextureIndexed(texture, palette, mipLevel);
        }

DecodeIndexed() [2/3]

static Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeIndexed ( TEX0v1 *  texture, PLT0v1 *  palette, int  mipLevel  )

inlinestatic

        {
            return Get(texture->PixelFormat).DecodeTextureIndexed(texture, palette, mipLevel);
        }

DecodeIndexed() [3/3]

static Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeIndexed ( VoidPtr  addr, int  w, int  h, ColorPalette  palette, int  mipLevel, WiiPixelFormat  fmt  )

inlinestatic

        {
            return Get(fmt).DecodeTextureIndexed(addr, w, h, palette, mipLevel, fmt);
        }

DecodePalette() [1/2]

static ColorPalette BrawlLib.Wii.Textures.TextureConverter.DecodePalette ( PLT0v1 *  palette )

inlinestatic

        {
            int count = palette->_numEntries;
            ColorPalette pal = ColorPaletteExtension.CreatePalette(ColorPaletteFlags.HasAlpha, count);
            switch (palette->PaletteFormat)
            {
                case WiiPaletteFormat.IA8:
                {
                    IA8Pixel* sPtr = (IA8Pixel*) palette->PaletteData;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) sPtr[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB565:
                {
                    wRGB565Pixel* sPtr = (wRGB565Pixel*) palette->PaletteData;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) sPtr[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB5A3:
                {
                    wRGB5A3Pixel* sPtr = (wRGB5A3Pixel*) palette->PaletteData;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) (ARGBPixel) sPtr[i];
                    }
 
                    break;
                }
            }
 
            return pal;
        }

DecodePalette() [2/2]

static ColorPalette BrawlLib.Wii.Textures.TextureConverter.DecodePalette ( VoidPtr  address, int  count, WiiPaletteFormat  format  )

inlinestatic

        {
            ColorPalette pal = ColorPaletteExtension.CreatePalette(ColorPaletteFlags.HasAlpha, count);
            switch (format)
            {
                case WiiPaletteFormat.IA8:
                {
                    IA8Pixel* sPtr = (IA8Pixel*) address;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) sPtr[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB565:
                {
                    wRGB565Pixel* sPtr = (wRGB565Pixel*) address;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) sPtr[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB5A3:
                {
                    wRGB5A3Pixel* sPtr = (wRGB5A3Pixel*) address;
                    for (int i = 0; i < count; i++)
                    {
                        pal.Entries[i] = (Color) (ARGBPixel) sPtr[i];
                    }
 
                    break;
                }
            }
 
            return pal;
        }

DecodeTexture() [1/3]

Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTexture ( TEX0v1 *  texture )

inline

        {
            return DecodeTexture(texture, 1);
        }

DecodeTexture() [2/3]

virtual Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTexture ( TEX0v1 *  texture, int  mipLevel  )

inlinevirtual

        {
            int w = (ushort) texture->_width, h = (ushort) texture->_height;
            VoidPtr addr = texture->PixelData + GetMipOffset(ref w, ref h, mipLevel);
            int aw = w.Align(BlockWidth), ah = h.Align(BlockHeight);
 
            using (DIB dib = new DIB(w, h, BlockWidth, BlockHeight, PixelFormat.Format32bppArgb))
            {
                int sStep = BlockWidth * BlockHeight * BitsPerPixel / 8;
                int bStride = aw * BitsPerPixel / 8;
                for (int y = 0; y < ah; y += BlockHeight)
                {
                    ARGBPixel* dPtr = (ARGBPixel*) dib.Scan0 + y * aw;
                    VoidPtr sPtr = addr + y * bStride;
                    for (int x = 0; x < aw; x += BlockWidth, dPtr += BlockWidth, sPtr += sStep)
                    {
                        DecodeBlock(sPtr, dPtr, aw);
                    }
                }
 
                return dib.ToBitmap();
            }
        }

DecodeTexture() [3/3]

virtual Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTexture ( VoidPtr  addr, int  w, int  h, int  mipLevel  )

inlinevirtual

        {
            addr += GetMipOffset(ref w, ref h, mipLevel);
 
            int aw = w.Align(BlockWidth), ah = h.Align(BlockHeight);
 
            using (DIB dib = new DIB(w, h, BlockWidth, BlockHeight, PixelFormat.Format32bppArgb))
            {
                int sStep = BlockWidth * BlockHeight * BitsPerPixel / 8;
                int bStride = aw * BitsPerPixel / 8;
                for (int y = 0; y < ah; y += BlockHeight)
                {
                    ARGBPixel* dPtr = (ARGBPixel*) dib.Scan0 + y * aw;
                    VoidPtr sPtr = addr + y * bStride;
                    for (int x = 0; x < aw; x += BlockWidth, dPtr += BlockWidth, sPtr += sStep)
                    {
                        DecodeBlock(sPtr, dPtr, aw);
                    }
                }
 
                return dib.ToBitmap();
            }
        }

DecodeTextureIndexed() [1/3]

virtual Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTextureIndexed ( TEX0v1 *  texture, ColorPalette  palette, int  mipLevel  )

inlinevirtual

        {
            _workingPalette = palette;
            try
            {
                return DecodeTexture(texture, mipLevel);
            }
            finally
            {
                _workingPalette = null;
            }
        }

DecodeTextureIndexed() [2/3]

virtual Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTextureIndexed ( TEX0v1 *  texture, PLT0v1 *  palette, int  mipLevel  )

inlinevirtual

        {
            return DecodeTextureIndexed(texture, DecodePalette(palette), mipLevel);
        }

DecodeTextureIndexed() [3/3]

virtual Bitmap BrawlLib.Wii.Textures.TextureConverter.DecodeTextureIndexed ( VoidPtr  addr, int  w, int  h, ColorPalette  palette, int  mipLevel, WiiPixelFormat  fmt  )

inlinevirtual

        {
            _workingPalette = palette;
            try
            {
                return Decode(addr, w, h, mipLevel, fmt);
            }
            finally
            {
                _workingPalette = null;
            }
        }

EncodeBlock()

abstract void BrawlLib.Wii.Textures.TextureConverter.EncodeBlock ( ARGBPixel *  sPtr, VoidPtr  blockAddr, int  width  )

protectedpure virtual

Implemented in BrawlLib.Wii.Textures.CMPR, and BrawlLib.Wii.Textures.IA4.

EncodePalette() [1/2]

static FileMap BrawlLib.Wii.Textures.TextureConverter.EncodePalette ( ColorPalette  pal, WiiPaletteFormat  format  )

inlinestatic

        {
            FileMap fileView = FileMap.FromTempFile(pal.Entries.Length * 2);
            try
            {
                EncodePalette(fileView.Address, pal, format);
                return fileView;
            }
            catch (Exception)
            {
                fileView.Dispose();
                throw;
                //MessageBox.Show(x.ToString());
                //fileView.Dispose();
                //return null;
            }
        }

EncodePalette() [2/2]

static void BrawlLib.Wii.Textures.TextureConverter.EncodePalette ( VoidPtr  destAddr, ColorPalette  pal, WiiPaletteFormat  format  )

inlinestatic

        {
            int count = pal.Entries.Length;
 
            switch (format)
            {
                case WiiPaletteFormat.IA8:
                {
                    IA8Pixel* dPtr = (IA8Pixel*) destAddr;
                    for (int i = 0; i < count; i++)
                    {
                        dPtr[i] = (IA8Pixel) pal.Entries[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB565:
                {
                    wRGB565Pixel* dPtr = (wRGB565Pixel*) destAddr;
                    for (int i = 0; i < count; i++)
                    {
                        dPtr[i] = (wRGB565Pixel) pal.Entries[i];
                    }
 
                    break;
                }
 
                case WiiPaletteFormat.RGB5A3:
                {
                    wRGB5A3Pixel* dPtr = (wRGB5A3Pixel*) destAddr;
                    for (int i = 0; i < count; i++)
                    {
                        dPtr[i] = (wRGB5A3Pixel) pal.Entries[i];
                    }
 
                    break;
                }
            }
        }

EncodePLT0Palette()

static FileMap BrawlLib.Wii.Textures.TextureConverter.EncodePLT0Palette ( ColorPalette  pal, WiiPaletteFormat  format  )

inlinestatic

        {
            FileMap fileView = FileMap.FromTempFile(pal.Entries.Length * 2 + 0x40);
            try
            {
                PLT0v1* header = (PLT0v1*) fileView.Address;
                *header = new PLT0v1(pal.Entries.Length, format);
 
                EncodePalette(fileView.Address + 0x40, pal, format);
                return fileView;
            }
            catch (Exception)
            {
                fileView.Dispose();
                throw;
                //MessageBox.Show(x.ToString());
                //fileView.Dispose();
                //return null;
            }
        }

EncodeREFTTexture()

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeREFTTexture ( Bitmap  src, int  mipLevels, WiiPaletteFormat  format  )

inlinevirtual

        {
            int w = src.Width, h = src.Height;
            int bw = BlockWidth, bh = BlockHeight;
 
            ColorPalette pal = src.Palette;
 
            PixelFormat fmt = src.IsIndexed() ? src.PixelFormat : PixelFormat.Format32bppArgb;
 
            FileMap fileView =
                FileMap.FromTempFile(GetFileSize(w, h, mipLevels) + 0x20 + (pal != null ? pal.Entries.Length * 2 : 0));
            try
            {
                //Build REFT image header
                REFTImageHeader* header = (REFTImageHeader*) fileView.Address;
                *header = new REFTImageHeader((ushort) w, (ushort) h, (byte) RawFormat, (byte) format,
                    (ushort) (pal != null ? pal.Entries.Length : 0),
                    (uint) fileView.Length - 0x20 - (uint) (pal != null ? pal.Entries.Length * 2 : 0),
                    (byte) (mipLevels - 1));
 
                int sStep = bw * Image.GetPixelFormatSize(fmt) / 8;
                int dStep = bw * bh * BitsPerPixel / 8;
 
                using (DIB dib = DIB.FromBitmap(src, bw, bh, fmt))
                {
                    for (int i = 1; i <= mipLevels; i++)
                    {
                        EncodeLevel((VoidPtr) header + 0x20, dib, src, dStep, sStep, i);
                    }
                }
 
                if (pal != null)
                {
                    int count = pal.Entries.Length;
 
                    switch (format)
                    {
                        case WiiPaletteFormat.IA8:
                        {
                            IA8Pixel* dPtr = (IA8Pixel*) header->PaletteData;
                            for (int i = 0; i < count; i++)
                            {
                                dPtr[i] = (IA8Pixel) pal.Entries[i];
                            }
 
                            break;
                        }
 
                        case WiiPaletteFormat.RGB565:
                        {
                            wRGB565Pixel* dPtr = (wRGB565Pixel*) header->PaletteData;
                            for (int i = 0; i < count; i++)
                            {
                                dPtr[i] = (wRGB565Pixel) pal.Entries[i];
                            }
 
                            break;
                        }
 
                        case WiiPaletteFormat.RGB5A3:
                        {
                            wRGB5A3Pixel* dPtr = (wRGB5A3Pixel*) header->PaletteData;
                            for (int i = 0; i < count; i++)
                            {
                                dPtr[i] = (wRGB5A3Pixel) pal.Entries[i];
                            }
 
                            break;
                        }
                    }
                }
 
                return fileView;
            }
            catch (Exception x)
            {
                MessageBox.Show(x.ToString());
                fileView.Dispose();
                return null;
            }
        }

EncodeREFTTextureIndexed() [1/2]

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeREFTTextureIndexed ( Bitmap  src, int  mipLevels, int  numColors, WiiPaletteFormat  format, QuantizationAlgorithm  algorithm  )

inlinevirtual

        {
            using (Bitmap indexed = src.Quantize(algorithm, numColors, RawFormat, format, null))
            {
                return EncodeREFTTextureIndexed(indexed, mipLevels, format);
            }
        }

EncodeREFTTextureIndexed() [2/2]

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeREFTTextureIndexed ( Bitmap  src, int  mipLevels, WiiPaletteFormat  format  )

inlinevirtual

        {
            if (!src.IsIndexed())
            {
                throw new ArgumentException("Source image must be indexed.");
            }
 
            return EncodeREFTTexture(src, mipLevels, format);
        }

EncodeTEX0Texture()

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTEX0Texture ( Bitmap  src, int  mipLevels  )

inlinevirtual

        {
            int w = src.Width, h = src.Height;
            int bw = BlockWidth, bh = BlockHeight;
 
            PixelFormat fmt;
            switch (RawFormat)
            {
                case WiiPixelFormat.CI4:
                case WiiPixelFormat.CI8:
                case WiiPixelFormat.CMPR:
                    fmt = src.IsIndexed() ? src.PixelFormat : PixelFormat.Format32bppArgb;
                    break;
                default:
                    fmt = PixelFormat.Format32bppArgb;
                    break;
            }
 
            FileMap fileView = FileMap.FromTempFile(GetFileSize(w, h, mipLevels) + 0x40);
            try
            {
                //Build TEX header
                TEX0v1* header = (TEX0v1*) fileView.Address;
                *header = new TEX0v1(w, h, RawFormat, mipLevels);
 
                int sStep = bw * Image.GetPixelFormatSize(fmt) / 8;
                int dStep = bw * bh * BitsPerPixel / 8;
 
                using (DIB dib = DIB.FromBitmap(src, bw, bh, fmt))
                {
                    for (int i = 1; i <= mipLevels; i++)
                    {
                        EncodeLevel(header->PixelData, dib, src, dStep, sStep, i);
                    }
                }
 
                return fileView;
            }
            catch (Exception x)
            {
                MessageBox.Show(x.ToString());
                fileView.Dispose();
                return null;
            }
        }

EncodeTEX0TextureIndexed()

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTEX0TextureIndexed ( Bitmap  src, int  mipLevels, WiiPaletteFormat  format, out FileMap  paletteFile  )

inlinevirtual

        {
            if (!src.IsIndexed())
            {
                throw new ArgumentException("Source image must be indexed.");
            }
 
            FileMap texMap = EncodeTEX0Texture(src, mipLevels);
            paletteFile = EncodePLT0Palette(src.Palette, format);
            return texMap;
        }

EncodeTextureIndexed()

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTextureIndexed ( Bitmap  src, int  mipLevels, int  numColors, WiiPaletteFormat  format, QuantizationAlgorithm  algorithm, out FileMap  paletteFile  )

inlinevirtual

        {
            using (Bitmap indexed = src.Quantize(algorithm, numColors, RawFormat, format, null))
            {
                return EncodeTEX0TextureIndexed(indexed, mipLevels, format, out paletteFile);
            }
        }

EncodeTPLPalette()

static FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTPLPalette ( ColorPalette  pal, WiiPaletteFormat  format  )

inlinestatic

        {
            FileMap fileView = FileMap.FromTempFile(pal.Entries.Length * 2 + 0xC);
            try
            {
                TPLPaletteHeader* header = (TPLPaletteHeader*) fileView.Address;
                header->_format = (uint) format;
                header->_numEntries = (ushort) pal.Entries.Length;
                header->_data = 0xC;
 
                EncodePalette(fileView.Address + 0xC, pal, format);
                return fileView;
            }
            catch (Exception)
            {
                fileView.Dispose();
                throw;
                //MessageBox.Show(x.ToString());
                //fileView.Dispose();
                //return null;
            }
        }

EncodeTPLTexture()

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTPLTexture ( Bitmap  src, int  mipLevels  )

inlinevirtual

        {
            int w = src.Width, h = src.Height;
            int bw = BlockWidth, bh = BlockHeight;
 
            PixelFormat fmt = src.IsIndexed() ? src.PixelFormat : PixelFormat.Format32bppArgb;
 
            FileMap fileView = FileMap.FromTempFile(GetFileSize(w, h, mipLevels) + TPLTextureHeader.Size);
            try
            {
                //Build TPL header
                TPLTextureHeader* tex = (TPLTextureHeader*) fileView.Address;
                tex->_wrapS = 0;
                tex->_wrapT = 0;
                tex->_minFilter = 1;
                tex->_magFilter = 1;
                tex->_minLOD = 0;
                tex->_maxLOD = (byte) (mipLevels - 1);
                tex->PixelFormat = RawFormat;
                tex->_width = (ushort) w;
                tex->_height = (ushort) h;
                tex->_data = TPLTextureHeader.Size;
 
                int sStep = bw * Image.GetPixelFormatSize(fmt) / 8;
                int dStep = bw * bh * BitsPerPixel / 8;
                VoidPtr baseAddr = fileView.Address;
 
                using (DIB dib = DIB.FromBitmap(src, bw, bh, fmt))
                {
                    for (int i = 1; i <= mipLevels; i++)
                    {
                        EncodeLevel(baseAddr + tex->_data, dib, src, dStep, sStep, i);
                    }
                }
 
                return fileView;
            }
            catch (Exception x)
            {
                MessageBox.Show(x.ToString());
                fileView.Dispose();
                return null;
            }
        }

EncodeTPLTextureIndexed() [1/2]

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTPLTextureIndexed ( Bitmap  src, int  mipLevels, WiiPaletteFormat  format, out FileMap  paletteFile  )

inlinevirtual

        {
            if (!src.IsIndexed())
            {
                throw new ArgumentException("Source image must be indexed.");
            }
 
            FileMap texMap = EncodeTPLTexture(src, mipLevels);
            paletteFile = EncodeTPLPalette(src.Palette, format);
            return texMap;
        }

EncodeTPLTextureIndexed() [2/2]

virtual FileMap BrawlLib.Wii.Textures.TextureConverter.EncodeTPLTextureIndexed ( Bitmap  src, int  numColors, WiiPaletteFormat  format, QuantizationAlgorithm  algorithm, out FileMap  paletteFile  )

inlinevirtual

        {
            using (Bitmap indexed = src.Quantize(algorithm, numColors, RawFormat, format, null))
            {
                return EncodeTPLTextureIndexed(indexed, 1, format, out paletteFile);
            }
        }

Get()

static TextureConverter BrawlLib.Wii.Textures.TextureConverter.Get ( WiiPixelFormat  format )

inlinestatic

        {
            switch (format)
            {
                case WiiPixelFormat.I4:     return I4;
                case WiiPixelFormat.IA4:    return IA4;
                case WiiPixelFormat.I8:     return I8;
                case WiiPixelFormat.IA8:    return IA8;
                case WiiPixelFormat.RGB565: return RGB565;
                case WiiPixelFormat.RGB5A3: return RGB5A3;
                case WiiPixelFormat.CI4:    return CI4;
                case WiiPixelFormat.CI8:    return CI8;
                case WiiPixelFormat.CMPR:   return CMPR;
                case WiiPixelFormat.RGBA8:  return RGBA8;
            }
 
            return null;
        }

GetFileSize()

int BrawlLib.Wii.Textures.TextureConverter.GetFileSize ( int  width, int  height, int  mipLevels  )

inline

        {
            return GetMipOffset(width, height, mipLevels + 1);
        }

GetMipOffset() [1/2]

int BrawlLib.Wii.Textures.TextureConverter.GetMipOffset ( int  width, int  height, int  mipLevel  )

inline

        {
            return GetMipOffset(ref width, ref height, mipLevel);
        }

GetMipOffset() [2/2]

int BrawlLib.Wii.Textures.TextureConverter.GetMipOffset ( ref int  width, ref int  height, int  mipLevel  )

inline

        {
            int offset = 0;
            while (mipLevel-- > 1)
            {
                offset += (width.Align(BlockWidth) * height.Align(BlockHeight) * BitsPerPixel) >> 3;
                width = Math.Max(width >> 1, 1);
                height = Math.Max(height >> 1, 1);
            }
 
            return offset;
        }

Member Data Documentation

_workingPalette

ColorPalette BrawlLib.Wii.Textures.TextureConverter._workingPalette

protected

CI4

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.CI4 = new CI4()

static

CI8

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.CI8 = new CI8()

static

CMPR

readonly CMPR BrawlLib.Wii.Textures.TextureConverter.CMPR = new CMPR()

static

I4

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.I4 = new I4()

static

I8

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.I8 = new I8()

static

IA4

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.IA4 = new IA4()

static

IA8

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.IA8 = new IA8()

static

RGB565

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.RGB565 = new RGB565()

static

RGB5A3

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.RGB5A3 = new RGB5A3()

static

RGBA8

readonly TextureConverter BrawlLib.Wii.Textures.TextureConverter.RGBA8 = new RGBA8()

static

Property Documentation

BitsPerPixel

abstract int BrawlLib.Wii.Textures.TextureConverter.BitsPerPixel

get

{ get; }

BlockHeight

abstract int BrawlLib.Wii.Textures.TextureConverter.BlockHeight

get

{ get; }

BlockWidth

abstract int BrawlLib.Wii.Textures.TextureConverter.BlockWidth

get

{ get; }

IsIndexed

bool BrawlLib.Wii.Textures.TextureConverter.IsIndexed

get

RawFormat

abstract WiiPixelFormat BrawlLib.Wii.Textures.TextureConverter.RawFormat

get

{ get; }

---

The documentation for this class was generated from the following file:

• BrawlLib/Wii/Textures/TextureConverter.cs