BrawlLib.Wii.Models.VertexCodec Class Reference

Inheritance diagram for BrawlLib.Wii.Models.VertexCodec:

Public Member Functions
void	Dispose ()
	VertexCodec (Vector3[] vertices, bool removeZ, bool forceFloat)
	VertexCodec (Vector3[] vertices, bool removeZ)
	VertexCodec (Vector2[] vertices, bool forceFloat)
	VertexCodec (Vector2[] vertices)
	VertexCodec (Vector3 *sPtr, int count, bool removeZ)
	VertexCodec (Vector2 *sPtr, int count)
void	GetEncoder ()
void	Write (byte *pOut)
void	Write (ref byte *pOut, int index)
void	Write (Vector2[] vertices, byte *pOut)
void	Write (Vector3[] vertices, byte *pOut)
void	Write (float *pIn, byte *pOut)

Static Public Member Functions
static UnsafeBuffer	Decode (MDL0UVData *header)
static UnsafeBuffer	Decode (VoidPtr data, byte divisor, uint length, WiiVertexComponentType componentType, bool UVs, int isSpecial)
static UnsafeBuffer	Decode (MDL0VertexData *header)
static UnsafeBuffer	Decode (MDL0NormalData *header)
static Vector3[]	ExtractVertices (MDL0VertexData *vertices)
static Vector3[]	ExtractVertices (MDL0FurPosData *vertices)
static Vector3[]	ExtractNormals (MDL0NormalData *normals)
static Vector2[]	ExtractUVs (MDL0UVData *uvs)

Public Attributes
Vector2 *	Address
Vector3	_min
Vector3	_max
bool	_hasZ
WiiVertexComponentType	_type
int	_srcElements
int	_srcCount
int	_dstElements
int	_dstCount
int	_dstStride
int	_scale
int	_dataLen

Constructor & Destructor Documentation

VertexCodec() [1/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector3[]  vertices, bool  removeZ, bool  forceFloat  )

inline

        {
            _forceFloat = forceFloat;
            _srcCount = vertices.Length;
            _srcElements = 3;
            _handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
            _pData = (float*) _handle.AddrOfPinnedObject();
            Evaluate(removeZ);
        }

VertexCodec() [2/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector3[]  vertices, bool  removeZ  )

inline

        {
            _srcCount = vertices.Length;
            _srcElements = 3;
            _handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
            _pData = (float*) _handle.AddrOfPinnedObject();
            Evaluate(removeZ);
        }

VertexCodec() [3/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector2[]  vertices, bool  forceFloat  )

inline

        {
            _forceFloat = forceFloat;
            _srcCount = vertices.Length;
            _srcElements = 2;
            _handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
            _pData = (float*) _handle.AddrOfPinnedObject();
            Evaluate(false);
        }

VertexCodec() [4/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector2[]  vertices )

inline

        {
            _srcCount = vertices.Length;
            _srcElements = 2;
            _handle = GCHandle.Alloc(vertices, GCHandleType.Pinned);
            _pData = (float*) _handle.AddrOfPinnedObject();
            Evaluate(false);
        }

VertexCodec() [5/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector3 *  sPtr, int  count, bool  removeZ  )

inline

        {
            _srcCount = count;
            _srcElements = 3;
            _pData = (float*) sPtr;
            Evaluate(removeZ);
        }

VertexCodec() [6/6]

BrawlLib.Wii.Models.VertexCodec.VertexCodec ( Vector2 *  sPtr, int  count  )

inline

        {
            _srcCount = count;
            _srcElements = 2;
            _pData = (float*) sPtr;
            Evaluate(false);
        }

Member Function Documentation

Decode() [1/4]

static UnsafeBuffer BrawlLib.Wii.Models.VertexCodec.Decode ( MDL0NormalData *  header )

inlinestatic

        {
            int count = header->_numVertices;
            float scale = VQuant.DeQuantTable[header->_divisor]; //Should always be zero?
            int type = (int) ElementCodec.CodecType.XYZ + header->_type;
            ElementDecoder decoder = ElementCodec.Decoders[type];
            UnsafeBuffer buffer;
 
            if (header->_isNBT != 0)
            {
                count *= 3; //Format is the same, just with three Vectors each
            }
 
            buffer = new UnsafeBuffer(count * 12);
 
            byte* pIn = (byte*) header->Data, pOut = (byte*) buffer.Address;
            for (int i = 0; i < count; i++)
            {
                decoder(ref pIn, ref pOut, scale);
            }
 
            return buffer;
        }

Decode() [2/4]

static UnsafeBuffer BrawlLib.Wii.Models.VertexCodec.Decode ( MDL0UVData *  header )

inlinestatic

        {
            int count = header->_numEntries;
            float scale = VQuant.DeQuantTable[header->_divisor];
            int type = (header->_isST == 0 ? (int) ElementCodec.CodecType.S : (int) ElementCodec.CodecType.ST) +
                       header->_format;
            ElementDecoder decoder = ElementCodec.Decoders[type];
            UnsafeBuffer buffer = new UnsafeBuffer(count * 8);
 
            byte* pIn = (byte*) header->Entries, pOut = (byte*) buffer.Address;
            for (int i = 0; i < count; i++)
            {
                decoder(ref pIn, ref pOut, scale);
            }
 
            return buffer;
        }

Decode() [3/4]

static UnsafeBuffer BrawlLib.Wii.Models.VertexCodec.Decode ( MDL0VertexData *  header )

inlinestatic

        {
            int count = header->_numVertices;
            float scale = VQuant.DeQuantTable[header->_divisor];
            int type = (header->_isXYZ == 0 ? (int) ElementCodec.CodecType.XY : (int) ElementCodec.CodecType.XYZ) +
                       header->_type;
            ElementDecoder decoder = ElementCodec.Decoders[type];
            UnsafeBuffer buffer = new UnsafeBuffer(count * 12);
 
            byte* pIn = (byte*) header->Data, pOut = (byte*) buffer.Address;
            for (int i = 0; i < count; i++)
            {
                decoder(ref pIn, ref pOut, scale);
            }
 
            return buffer;
        }

Decode() [4/4]

static UnsafeBuffer BrawlLib.Wii.Models.VertexCodec.Decode ( VoidPtr  data, byte  divisor, uint  length, WiiVertexComponentType  componentType, bool  UVs, int  isSpecial  )

inlinestatic

        {
            float scale = VQuant.DeQuantTable[divisor];
            int type = isSpecial * 5 + (UVs ? 0 : 10) + (int) componentType;
            ElementDecoder decoder = ElementCodec.Decoders[type];
 
            int bytesPerVal = (UVs ? isSpecial + 1 : isSpecial + 2) * (componentType < WiiVertexComponentType.UInt16
                ? 1
                : componentType < WiiVertexComponentType.Float
                    ? 2
                    : 4);
 
            int count = (int) (length / bytesPerVal);
 
            UnsafeBuffer buffer = new UnsafeBuffer(count * (UVs ? 8 : 12));
 
            byte* pIn = (byte*) data, pOut = (byte*) buffer.Address;
            for (int i = 0; i < count; i++)
            {
                decoder(ref pIn, ref pOut, scale);
            }
 
            return buffer;
        }

Dispose()

void BrawlLib.Wii.Models.VertexCodec.Dispose ( )

inline

        {
            if (_handle.IsAllocated)
            {
                _handle.Free();
            }
 
            _pData = null;
        }

ExtractNormals()

static Vector3[] BrawlLib.Wii.Models.VertexCodec.ExtractNormals ( MDL0NormalData *  normals )

inlinestatic

        {
            return ExtractVertices(normals->Data, normals->_numVertices, true, normals->Type, 1 << normals->_divisor);
        }

ExtractUVs()

static Vector2[] BrawlLib.Wii.Models.VertexCodec.ExtractUVs ( MDL0UVData *  uvs )

inlinestatic

        {
            return ExtractPoints(uvs->Entries, uvs->_numEntries, uvs->Type, 1 << uvs->_divisor);
        }

ExtractVertices() [1/2]

static Vector3[] BrawlLib.Wii.Models.VertexCodec.ExtractVertices ( MDL0FurPosData *  vertices )

inlinestatic

        {
            if (vertices != null)
            {
                return ExtractVertices(vertices->Data, vertices->_numVertices, vertices->_isXYZ != 0, vertices->Type,
                    1 << vertices->_divisor);
            }
 
            return null;
        }

ExtractVertices() [2/2]

static Vector3[] BrawlLib.Wii.Models.VertexCodec.ExtractVertices ( MDL0VertexData *  vertices )

inlinestatic

        {
            if (vertices != null)
            {
                return ExtractVertices(vertices->Data, vertices->_numVertices, vertices->_isXYZ != 0, vertices->Type,
                    1 << vertices->_divisor);
            }
 
            return null;
        }

GetEncoder()

void BrawlLib.Wii.Models.VertexCodec.GetEncoder ( )

inline

        {
            switch (_type)
            {
                case WiiVertexComponentType.Int8:
                case WiiVertexComponentType.UInt8:
                    _enc = _byteEncoder;
                    break;
                case WiiVertexComponentType.Int16:
                case WiiVertexComponentType.UInt16:
                    _enc = _shortEncoder;
                    break;
                default:
                    _enc = _floatEncoder;
                    break;
            }
        }

Write() [1/5]

void BrawlLib.Wii.Models.VertexCodec.Write ( byte *  pOut )

inline

        {
            try
            {
                int[] imp = _remap._impTable;
 
                //Copy elements using encoder
                float* pTemp = _pData;
                for (int i = 0; i < _dstCount; i++)
                {
                    if (imp != null)
                    {
                        pTemp = &_pData[imp[i] * _srcElements];
                    }
 
                    for (int x = 0; x < _srcElements; x++, pTemp++)
                    {
                        if (x < _dstElements)
                        {
                            _enc(*pTemp * _quantScale, ref pOut);
                        }
                    }
                }
 
                //Zero remaining
                for (int i = _dataLen; (i & 0x1F) != 0; i++)
                {
                    *pOut++ = 0;
                }
            }
            finally
            {
                Dispose();
            }
        }

Write() [2/5]

void BrawlLib.Wii.Models.VertexCodec.Write ( float *  pIn, byte *  pOut  )

inline

        {
            int[] imp = _remap._impTable;
            byte* pCeil = pOut + _dataLen.Align(0x20);
 
            //Copy elements using encoder
            float* pTemp = pIn;
            for (int i = 0; i < _dstCount; i++)
            {
                if (imp != null)
                {
                    pTemp = &pIn[imp[i] * _srcElements];
                }
 
                for (int x = 0; x < _srcElements; x++, pTemp++)
                {
                    if (x < _dstElements)
                    {
                        _enc(*pTemp * _quantScale, ref pOut);
                    }
                }
            }
 
            //Zero remaining
            while (pOut < pCeil)
            {
                *pOut++ = 0;
            }
        }

Write() [3/5]

void BrawlLib.Wii.Models.VertexCodec.Write ( ref byte *  pOut, int  index  )

inline

        {
            int[] imp = _remap._impTable;
 
            //Copy element using encoder
            float* pTemp = _pData;
            if (imp != null)
            {
                pTemp = &_pData[imp[index] * _srcElements];
            }
 
            for (int x = 0; x < _srcElements; x++, pTemp++)
            {
                if (x < _dstElements)
                {
                    _enc(*pTemp * _quantScale, ref pOut);
                }
            }
        }

Write() [4/5]

void BrawlLib.Wii.Models.VertexCodec.Write ( Vector2[]  vertices, byte *  pOut  )

inline

        {
            fixed (Vector2* p = vertices)
            {
                Write((float*) p, pOut);
            }
        }

Write() [5/5]

void BrawlLib.Wii.Models.VertexCodec.Write ( Vector3[]  vertices, byte *  pOut  )

inline

        {
            fixed (Vector3* p = vertices)
            {
                Write((float*) p, pOut);
            }
        }

Member Data Documentation

_dataLen

int BrawlLib.Wii.Models.VertexCodec._dataLen

_dstCount

int BrawlLib.Wii.Models.VertexCodec._dstCount

_dstElements

int BrawlLib.Wii.Models.VertexCodec._dstElements

_dstStride

int BrawlLib.Wii.Models.VertexCodec._dstStride

_hasZ

bool BrawlLib.Wii.Models.VertexCodec._hasZ

_max

Vector3 BrawlLib.Wii.Models.VertexCodec._max

_min

Vector3 BrawlLib.Wii.Models.VertexCodec._min

_scale

int BrawlLib.Wii.Models.VertexCodec._scale

_srcCount

int BrawlLib.Wii.Models.VertexCodec._srcCount

_srcElements

int BrawlLib.Wii.Models.VertexCodec._srcElements

_type

WiiVertexComponentType BrawlLib.Wii.Models.VertexCodec._type

Address

Vector2* BrawlLib.Wii.Models.VertexCodec.Address

---

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

• BrawlLib/Wii/Models/VertexCodec.cs