BrawlLib.Wii.Models.ModelLinker Class Reference

Public Member Functions
	ModelLinker (MDL0Header *pModel)
void	RegenerateBoneCache (bool remake=false)
void	Write (Collada form, ref byte *pGroup, ref byte *pData, bool force)
void	Finish ()

Static Public Member Functions
static ModelLinker	Prepare (MDL0Node model)

Public Attributes
MDL0Header *	Header
int	Version = 9
ResourceGroup *	Defs
ResourceGroup *	Bones
ResourceGroup *	Vertices
ResourceGroup *	Normals
ResourceGroup *	Colors
ResourceGroup *	UVs
ResourceGroup *	Materials
ResourceGroup *	Shaders
ResourceGroup *	Objects
ResourceGroup *	Textures
ResourceGroup *	Palettes
ResourceGroup *	FurVectors
ResourceGroup *	FurLayerCoords
MDL0GroupNode[]	Groups = new MDL0GroupNode[BankLen]
MDL0Node	Model
int	_headerLen
int	_tableLen
int	_groupLen
int	_texLen
int	_boneLen
int	_dataLen
int	_defLen
int	_assetLen
List< MDL0TextureNode >	_texList
List< MDL0TextureNode >	_pltList
int	_nodeCount
MDL0BoneNode[]	BoneCache
IMatrixNode[]	NodeCache
List< VertexCodec >	_vertices
List< VertexCodec >	_normals
List< ColorCodec >	_colors
List< VertexCodec >	_uvs
bool[]	_forceDirectAssets = new bool[12]

Static Public Attributes
static readonly List< MR >[]	IndexBank

Constructor & Destructor Documentation

ModelLinker()

BrawlLib.Wii.Models.ModelLinker.ModelLinker ( MDL0Header *  pModel )

inline

        {
            Header = pModel;
            Version = pModel->_header._version;
            NodeCache = pModel->Properties == null
                ? new IMatrixNode[0]
                : new IMatrixNode[pModel->Properties->_numNodes];
            BoneCache = new MDL0BoneNode[0];
 
            bint* offsets = (bint*) ((byte*) pModel + 0x10);
            if (Version >= 8 && Version <= 11)
            {
                List<MR> iList = IndexBank[Version];
                int groupCount = iList.Count;
                int offset;
 
                //Extract resource addresses
                fixed (ResourceGroup** gList = &Defs)
                {
                    for (int i = 0; i < groupCount; i++)
                    {
                        if ((offset = offsets[i]) > 0)
                        {
                            gList[(int) iList[i]] = (ResourceGroup*) ((byte*) pModel + offset);
                        }
                    }
                }
            }
        }

Member Function Documentation

Finish()

void BrawlLib.Wii.Models.ModelLinker.Finish ( )

inline

        {
            List<MR> iList = IndexBank[Version];
            MR resType;
            bint* pOffset = (bint*) Header + 4;
            int count = iList.Count, offset;
 
            fixed (ResourceGroup** pGroup = &Defs)
            {
                for (int i = 0; i < count; i++)
                {
                    resType = iList[i];
                    if ((offset = (int) pGroup[(int) resType]) > 0)
                    {
                        offset -= (int) Header;
                    }
 
                    pOffset[i] = offset;
                }
            }
        }

Prepare()

static ModelLinker BrawlLib.Wii.Models.ModelLinker.Prepare ( MDL0Node  model )

inlinestatic

        {
            ModelLinker linker = new ModelLinker
            {
                Model = model,
                Version = model._version
            };
 
            //Get flattened bone list and assign it to bone cache
            linker.RegenerateBoneCache();
 
            MR resType;
            int index;
            List<MR> iList = IndexBank[model._version];
 
            foreach (MDL0GroupNode group in model.Children)
            {
                //If version contains resource type, add it to group list
                resType = (MR) Enum.Parse(typeof(MR), group.Name);
                if ((index = iList.IndexOf(resType)) >= 0)
                {
                    linker.Groups[(int) resType] = group;
                }
            }
 
            return linker;
        }

RegenerateBoneCache()

void BrawlLib.Wii.Models.ModelLinker.RegenerateBoneCache ( bool  remake = false )

inline

        {
            if (Model?._boneGroup != null)
            {
                if (remake)
                {
                    BoneCache = Model._boneGroup.FindChildrenByType(null, ResourceType.MDL0Bone)
                        .Select(x => x as MDL0BoneNode).ToArray();
                }
                else
                {
                    BoneCache = Model._boneGroup.FindChildrenByType(null, ResourceType.MDL0Bone)
                        .Select(x => x as MDL0BoneNode).OrderBy(x => x.BoneIndex).ToArray();
                }
            }
            else
            {
                BoneCache = new MDL0BoneNode[0];
            }
 
            int i = 0;
            foreach (MDL0BoneNode b in BoneCache)
            {
                b._entryIndex = i++;
            }
        }

Write()

void BrawlLib.Wii.Models.ModelLinker.Write ( Collada  form, ref byte *  pGroup, ref byte *  pData, bool  force  )

inline

        {
            MDL0GroupNode group;
            ResourceGroup* pGrp;
            ResourceEntry* pEntry;
            int len;
 
            //Write data in the order it appears
            foreach (MR resType in OrderBank)
            {
                if ((@group = Groups[(int) resType]) == null || SpecialRebuildData((int) resType))
                {
                    continue;
                }
 
                if (resType == MR.Bones)
                {
                    form?.Say("Writing Bones");
 
                    MDL0Bone* pBone = (MDL0Bone*) pData;
                    foreach (MDL0BoneNode e in BoneCache)
                    {
                        len = e._calcSize;
                        e.Rebuild(pData, len, true);
                        pData += len;
                    }
 
                    //Loop through after all bones are written
                    //and set header offsets to related bones
                    foreach (MDL0BoneNode e in BoneCache)
                    {
                        e.CalculateOffsets();
                    }
                }
                else if (resType == MR.Shaders)
                {
                    MDL0GroupNode mats = Groups[(int) MR.Materials];
                    MDL0Material* mHeader;
 
                    form?.Say("Writing Shaders");
 
                    //Write data without headers
                    foreach (ResourceNode e in group.Children)
                    {
                        if (((MDL0ShaderNode) e)._materials.Count > 0)
                        {
                            len = e._calcSize;
                            e.Rebuild(pData, len, force);
                            pData += len;
                        }
                    }
 
                    //Write one header for each material, using same order.
                    if (mats != null)
                    {
                        foreach (MDL0MaterialNode mat in mats.Children)
                        {
                            mHeader = mat.Header;
                            if (mat._shader != null)
                            {
                                len = (int) mat._shader.Header;
                                mHeader->_shaderOffset = len - (int) mHeader;
                            }
                            else
                            {
                                mHeader->_shaderOffset = 0;
                            }
                        }
                    }
                }
                else if (resType == MR.Objects || resType == MR.Materials)
                {
                    foreach (ResourceNode r in group.Children)
                    {
                        form?.Say("Writing " + resType + " - " + r.Name);
 
                        len = r._calcSize;
                        r.Rebuild(pData, len, true); //Forced to fix object node ids and align materials
                        pData += len;
                    }
                }
                else
                {
                    bool rebuild = true;
 
                    if (Model._isImport)
                    {
                        if (group._name == "Vertices" ||
                            group._name == "Normals" ||
                            group._name == "UVs" ||
                            group._name == "Colors")
                        {
                            rebuild = false; //The data has already been written!
                        }
                    }
 
                    if (rebuild)
                    {
                        foreach (ResourceNode e in group.Children)
                        {
                            //Console.WriteLine("Rebuilding the " + group.Name);
 
                            form?.Say("Writing the " + resType + " - " + e.Name);
 
                            len = e._calcSize;
                            e.Rebuild(pData, len, true); //Forced just in case we need to convert to float.
                            pData += len;
                        }
                    }
                }
            }
 
            //Write relocation offsets in the order of the header
            fixed (ResourceGroup** pOut = &Defs)
            {
                foreach (MR resType in IndexBank[Version])
                {
                    if ((@group = Groups[(int) resType]) == null || SpecialRebuildData((int) resType))
                    {
                        continue;
                    }
 
                    pOut[(int) resType] = pGrp = (ResourceGroup*) pGroup;
                    pEntry = &pGrp->_first + 1;
                    if (resType == MR.Bones)
                    {
                        *pGrp = new ResourceGroup(BoneCache.Length);
                        foreach (ResourceNode e in BoneCache)
                        {
                            (pEntry++)->_dataOffset = (int) ((byte*) e.WorkingUncompressed.Address - pGroup);
                        }
                    }
                    else if (resType == MR.Shaders)
                    {
                        MDL0GroupNode mats = Groups[(int) MR.Materials];
 
                        if (mats != null)
                        {
                            //Create a material group with the amount of entries
                            *pGrp = new ResourceGroup(mats.Children.Count);
 
                            foreach (MDL0MaterialNode mat in mats.Children)
                            {
                                (pEntry++)->_dataOffset = (int) mat._shader.Header - (int) pGrp;
                            }
                        }
                    }
                    else
                    {
                        *pGrp = new ResourceGroup(group.Children.Count);
                        foreach (ResourceNode e in group.Children)
                        {
                            (pEntry++)->_dataOffset = (int) ((byte*) e.WorkingUncompressed.Address - pGroup);
                        }
                    }
 
                    pGroup += pGrp->_totalSize;
                }
            }
        }

Member Data Documentation

_assetLen

int BrawlLib.Wii.Models.ModelLinker._assetLen

_boneLen

int BrawlLib.Wii.Models.ModelLinker._boneLen

_colors

List<ColorCodec> BrawlLib.Wii.Models.ModelLinker._colors

_dataLen

int BrawlLib.Wii.Models.ModelLinker._dataLen

_defLen

int BrawlLib.Wii.Models.ModelLinker._defLen

_forceDirectAssets

bool [] BrawlLib.Wii.Models.ModelLinker._forceDirectAssets = new bool[12]

_groupLen

int BrawlLib.Wii.Models.ModelLinker._groupLen

_headerLen

int BrawlLib.Wii.Models.ModelLinker._headerLen

_nodeCount

int BrawlLib.Wii.Models.ModelLinker._nodeCount

_normals

List<VertexCodec> BrawlLib.Wii.Models.ModelLinker._normals

_pltList

List<MDL0TextureNode> BrawlLib.Wii.Models.ModelLinker._pltList

_tableLen

int BrawlLib.Wii.Models.ModelLinker._tableLen

_texLen

int BrawlLib.Wii.Models.ModelLinker._texLen

_texList

List<MDL0TextureNode> BrawlLib.Wii.Models.ModelLinker._texList

_uvs

List<VertexCodec> BrawlLib.Wii.Models.ModelLinker._uvs

_vertices

List<VertexCodec> BrawlLib.Wii.Models.ModelLinker._vertices

BoneCache

MDL0BoneNode [] BrawlLib.Wii.Models.ModelLinker.BoneCache

Bones

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Bones

Colors

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Colors

Defs

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Defs

FurLayerCoords

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.FurLayerCoords

FurVectors

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.FurVectors

Groups

MDL0GroupNode [] BrawlLib.Wii.Models.ModelLinker.Groups = new MDL0GroupNode[BankLen]

Header

MDL0Header* BrawlLib.Wii.Models.ModelLinker.Header

IndexBank

readonly List<MR> [] BrawlLib.Wii.Models.ModelLinker.IndexBank

static

Materials

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Materials

Model

MDL0Node BrawlLib.Wii.Models.ModelLinker.Model

NodeCache

IMatrixNode [] BrawlLib.Wii.Models.ModelLinker.NodeCache

Normals

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Normals

Objects

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Objects

Palettes

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Palettes

Shaders

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Shaders

Textures

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Textures

UVs

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.UVs

Version

int BrawlLib.Wii.Models.ModelLinker.Version = 9

Vertices

ResourceGroup* BrawlLib.Wii.Models.ModelLinker.Vertices

---

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

• BrawlLib/Wii/Models/ModelLinker.cs