Inheritance diagram for BrawlLib.SSBB.ResourceNodes.MDL0Node:

Public Member Functions
	MDL0Node ()

Box	GetBox ()
	Call ApplyCHR0 before calling this More...

void	CalculateBoundingBoxes ()

void	CheckTextures ()

List< ResourceNode >	GetUsedShaders ()

void	GenerateMetalMaterials ()

void	GenerateMetalMaterials (string metalTextureName)

void	CleanTextures ()

MDL0TextureNode	FindOrCreateTexture (string name)

MDL0TextureNode	FindOrCreatePalette (string name)

MDL0BoneNode	FindBone (string name)

MDL0BoneNode	FindBoneByIndex (int givenIndex)

MDL0MaterialNode	FindOrCreateOpaMaterial (string name)

MDL0MaterialNode	FindOrCreateXluMaterial (string name)

override void	AddChild (ResourceNode child, bool change)

override void	RemoveChild (ResourceNode child)

void	ReplaceOrAddMesh (MDL0ObjectNode replacement, bool doSearch, bool replaceIfFound, bool addIfNotFound)

void	ReplaceMeshes (MDL0Node replacement, bool doSearch, bool replaceIfFound, bool addIfNotFound)

void	ConvertToShadowModel ()

void	ConvertToSpyModel ()

void	ConvertToSpyModelMultiType ()

void	StripModel ()

void	LinkGroup (MDL0GroupNode group)

void	UnlinkGroup (MDL0GroupNode group)

override bool	OnInitialize ()

override void	OnPopulate ()

void	BeginImport ()

void	FinishImport (Collada form=null)

override void	Replace (string fileName, FileMapProtect prot, FileOptions options)

override void	Export (string outPath)

override int	OnCalculateSize (bool force)

override void	OnRebuild (VoidPtr address, int length, bool force)

void	Attach ()

void	RegenerateVIS0Indices ()
	This only needs to be called when the model is currently attached to a model renderer and the amount of objects change or an object's visibility bone changes. More...

void	Detach ()

void	Refresh ()

void	PreRender (ModelPanelViewport v)

void	RenderVertices (bool depthPass, IBoneNode weightTarget, GLCamera camera)

void	RenderNormals ()

void	RenderBoxes (bool model, bool obj, bool bone, bool bindState)

void	RenderBones (ModelPanelViewport v)

void	ResetToBindState ()

void	DrawBox (bool bindState)

void	ApplyCHR (CHR0Node node, float index)

void	WeightMeshes (ModelPanelViewport v=null)

void	ApplySRT (SRT0Node node, float index)

void	ApplyCLR (CLR0Node node, float index)

void	ApplyPAT (PAT0Node node, float index)

void	ApplyVIS (VIS0Node node, float index)

void	ApplySCN (SCN0Node node, float index)

void	ApplySHP (SHP0Node node, float index)

void	OnDrawCallsChanged ()

Public Member Functions inherited from BrawlLib.SSBB.ResourceNodes.BRESEntryNode
override bool	OnInitialize ()

override void	Export (string outPath)

override byte[]	MD5 ()
	Find the MD5 checksum of this node's data. Before calculating the checksum, the data will be copied to a temporary area in memory and PostProcess will be run just as in Export(). More...

Public Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
void	OnRenamed ()

List< ResourceNode >	GetChildrenRecursive ()
	Used primarily to get bone lists. Kept for all resource nodes for utility. More...

virtual void	SignalPropertyChange ()

virtual void	Dispose ()

void	SelectChildAtIndex (int index)

void	UpdateProperties ()

void	UpdateCurrentControl ()

virtual bool	MoveUp ()

virtual bool	MoveDown ()

virtual void	OnMoved ()

virtual void	DoMoveDown ()

virtual void	DoMoveDown (bool select)

virtual void	DoMoveUp ()

virtual void	DoMoveUp (bool select)

virtual bool	AddUp ()

virtual bool	AddDown ()

virtual bool	ToParent ()

void	Populate (int levels=-1)

virtual void	OnPopulate ()

void	Initialize (ResourceNode parent, FileMap source)

void	Initialize (ResourceNode parent, VoidPtr address, int length)

void	Initialize (ResourceNode parent, DataSource origSource)

virtual void	Initialize (ResourceNode parent, DataSource origSource, DataSource uncompSource)

virtual bool	OnInitialize ()

virtual void	Restore ()

virtual void	Remove ()

virtual void	RemoveChild (ResourceNode child)

virtual void	AddChild (ResourceNode child)

virtual void	AddChild (ResourceNode child, bool change)

virtual void	InsertChild (ResourceNode child, int index)

virtual void	InsertChild (ResourceNode child, bool change, int index)

void	SetSizeInternal (int size)

virtual void	Replace (string fileName)

virtual void	Replace (ResourceNode node)

virtual void	Replace (string fileName, FileMapProtect prot, FileOptions options)

virtual void	ReplaceRaw (VoidPtr address, int length)

virtual void	ReplaceRaw (FileMap map)

virtual void	Export (string outPath)

void	Export (FileStream outStream)

virtual void	ExportUncompressed (string outPath)

void	ExportUncompressed (FileStream outStream)

virtual void	Rebuild ()

virtual void	Rebuild (bool force)

virtual void	Rebuild (VoidPtr address, int length, bool force)

virtual void	OnRebuild (VoidPtr address, int length, bool force)

virtual int	CalculateSize (bool force)

virtual int	OnCalculateSize (bool force)

void	Merge ()

void	Merge (bool forceBuild)

ResourceNode	FindChildByType (string path, bool searchChildren, params ResourceType[] types)

ResourceNode	FindChildByType (string path, bool searchChildren, StringComparison compare, params ResourceType[] types)

ResourceNode	FindChild (string path)

ResourceNode	FindChild (string path, bool searchChildren)

ResourceNode	FindChild (string path, StringComparison compare)

ResourceNode	FindChild (string path, bool searchChildren, StringComparison compare)

ResourceNode[]	FindChildrenByClassType (string path, Type type)

ResourceNode[]	FindChildrenByType (string path, ResourceType type)

ResourceNode[]	FindChildrenByTypeInGroup (string path, ResourceType type, byte group)

ResourceNode[]	FindChildrenByName (string name)

unsafe string	FindName (string name)

ResourceNode	FindEmbeddedIndex (int index)

virtual unsafe byte[]	MD5 ()
	Find the MD5 checksum of this node's data. If this node doesn't have any data (BRESGroupNode, for example), this method will return null. More...

string	MD5Str ()
	Get the result of the MD5() function as a string of hexadecimal digits. If MD5() returns null, this method will return an empty string. More...

ResourceNode	PrevSibling ()

ResourceNode	NextSibling ()

override string	ToString ()

virtual void	SortChildren ()

void	ResetToBindState ()

void	ApplyCHR (CHR0Node node, float index)

void	ApplySRT (SRT0Node node, float index)

void	ApplySHP (SHP0Node node, float index)

void	ApplyPAT (PAT0Node node, float index)

void	ApplyVIS (VIS0Node node, float index)

void	ApplyCLR (CLR0Node node, float index)

void	ApplySCN (SCN0Node node, float index)

void	RenderVertices (bool depthPass, IBoneNode weightTarget, GLCamera camera)

void	RenderNormals ()

void	RenderBoxes (bool model, bool obj, bool bone, bool bindState)

void	RenderBones (ModelPanelViewport v)

void	Attach ()

void	Detach ()

void	Refresh ()

void	PreRender (ModelPanelViewport v)

Box	GetBox ()

Static Public Member Functions
static MDL0Node	FromFile (string path, FileOptions options=FileOptions.RandomAccess)

Static Public Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
static ResourceNode[]	FindAllSubNodes (ResourceNode root)

static ResourceNode	FindNode (ResourceNode root, string path, bool searchChildren, StringComparison compare)

Public Attributes
byte	_envMtxMode

bool	_needsNrmMtxArray

bool	_needsTexMtxArray

bool	_enableExtents

int	_numFacepoints

int	_numTriangles

int	_numNodes

Box	_extents

ModelLinker	_linker

AssetStorage	_assets

bool	_hasTree

bool	_hasMix

bool	_hasOpa

bool	_hasXlu

bool	_isImport

bool	_autoMetal

List< MDL0BoneNode >	_billboardBones = new List<MDL0BoneNode>()

InfluenceManager	_influences = new InfluenceManager()

List< string >	_errors = new List<string>()

string	_metalMat

MDL0GroupNode	_boneGroup

MDL0GroupNode	_matGroup

MDL0GroupNode	_shadGroup

MDL0GroupNode	_objGroup

MDL0GroupNode	_texGroup

MDL0GroupNode	_pltGroup

MDL0GroupNode	_vertGroup

MDL0GroupNode	_normGroup

MDL0GroupNode	_uvGroup

MDL0GroupNode	_defGroup

MDL0GroupNode	_colorGroup

MDL0GroupNode	_furPosGroup

MDL0GroupNode	_furVecGroup

List< ResourceNode >	_boneList

List< ResourceNode >	_matList

List< ResourceNode >	_shadList

List< ResourceNode >	_objList

List< ResourceNode >	_texList

List< ResourceNode >	_pltList

List< ResourceNode >	_vertList

List< ResourceNode >	_normList

List< ResourceNode >	_uvList

List< ResourceNode >	_defList

List< ResourceNode >	_colorList

List< ResourceNode >	_furPosList

List< ResourceNode >	_furVecList

ModelRenderAttributes	_renderAttribs = new ModelRenderAttributes()

bool	_ignoreModelViewerAttribs = false

int	_selectedObjectIndex = -1

Dictionary< string, Dictionary< int, List< int > > >	VIS0Indices

Matrix?	_matrixOffset = null

bool	_dontUpdateMesh = false

Public Attributes inherited from BrawlLib.SSBB.ResourceNodes.BRESEntryNode
int	_version

string	_originalPath

Public Attributes inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
Form	_mainForm

string	_name

string	_origPath

ResourceNode	_parent

List< ResourceNode >	_children = new List<ResourceNode>()

int	_calcSize

EventHandler	UpdateControl

MoveEventHandler	MovedDown

ResourceEventHandler	Renamed

ResourceEventHandler	PropertyChanged

ResourceEventHandler	Replaced

ResourceEventHandler	Restored

ResourceChildEventHandler	ChildRemoved

bool	_isPopulating

bool	_replaced

Static Public Attributes
static bool	MultiTypeWorks = false

Protected Member Functions
override void	OnVersionChanged (int previousVersion)

virtual void	OnVersionChanged (int previousVersion)

Protected Member Functions inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
void	ForceReplacedEvent ()

virtual void	MergeInternal ()

Properties
override ResourceType	ResourceFileType `[get]`

override int	DataAlign `[get]`

override int[]	SupportedVersions `[get]`

override string	Tag `[get]`

InfluenceManager	Influences `[get]`

bool	AutoMetalMaterials `[get, set]`

string	MetalTexture `[get, set]`

MDLScalingRule	ScalingRule `[get, set]`

TexMatrixMode	TextureMatrixMode `[get, set]`

int	NumFacepoints `[get]`

int	NumVertices `[get]`

int	NumTriangles `[get]`

int	NumNodes `[get]`

bool	NeedsNormalMtxArray `[get]`

bool	NeedsTextureMtxArray `[get]`

Vector3	BoxMin `[get, set]`

Vector3	BoxMax `[get, set]`

bool	EnableBoundingBox `[get, set]`

MDLEnvelopeMatrixMode	EnvelopeMatrixMode `[get, set]`

bool	IsStagePosition `[get]`

ResourceNode	DefinitionsGroup `[get]`

ResourceNode	BoneGroup `[get]`

ResourceNode	MaterialGroup `[get]`

ResourceNode	ShaderGroup `[get]`

ResourceNode	VertexGroup `[get]`

ResourceNode	NormalGroup `[get]`

ResourceNode	UVGroup `[get]`

ResourceNode	ColorGroup `[get]`

ResourceNode	PolygonGroup `[get]`

ResourceNode	TextureGroup `[get]`

ResourceNode	PaletteGroup `[get]`

ResourceNode	FurVecGroup `[get]`

ResourceNode	FurPosGroup `[get]`

List< ResourceNode >	DefinitionsList `[get]`

List< ResourceNode >	BoneList `[get]`

List< MDL0BoneNode >	AllBones `[get]`

List< ResourceNode >	MaterialList `[get]`

List< ResourceNode >	ShaderList `[get]`

List< ResourceNode >	VertexList `[get]`

List< ResourceNode >	NormalList `[get]`

List< ResourceNode >	UVList `[get]`

List< ResourceNode >	ColorList `[get]`

List< ResourceNode >	PolygonList `[get]`

List< ResourceNode >	TextureList `[get]`

List< ResourceNode >	PaletteList `[get]`

List< ResourceNode >	FurVecList `[get]`

List< ResourceNode >	FurPosList `[get]`

IBoneNode[]	BoneCache `[get]`

IBoneNode[]	RootBones `[get]`

bool	IsRendering `[get, set]`

bool	IsTargetModel `[get, set]`

bool	Attached `[get]`

int	SelectedObjectIndex `[get, set]`

IObject[]	Objects `[get]`

List< DrawCallBase >	DrawCalls `[get]`

Properties inherited from BrawlLib.SSBB.ResourceNodes.BRESEntryNode
virtual int	DataAlign `[get]`

BRRESNode	BRESNode `[get]`

virtual int[]	SupportedVersions `[get]`

virtual string	Tag `[get]`

int	Version `[get, set]`

string	OriginalPath `[get, set]`

UserDataCollection	UserEntries `[get, set]`

Properties inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
string	FilePath `[get]`

string	FileName `[get]`

string	DirectoryName `[get]`

ResourceNode	RootNode `[get]`

DataSource	OriginalSource `[get]`

DataSource	UncompressedSource `[get]`

DataSource	WorkingSource `[get]`

DataSource	WorkingUncompressed `[get]`

virtual bool	HasChildren `[get]`

virtual ResourceType	ResourceFileType `[get]`

string	NodeType `[get]`

virtual string	TreePathAbsolute `[get]`

virtual string	TreePath `[get]`

virtual int	Level `[get]`

virtual int	MaxNameLength `[get]`

virtual bool	AllowDuplicateNames `[get]`

virtual bool	AllowNullNames `[get]`

virtual string	Name `[get, set]`

ResourceNode	Parent `[get, set]`

List< ResourceNode >	Children `[get]`

int	Index `[get]`

int	HexIndex `[get]`

bool	IsCompressed `[get]`

bool	HasChanged `[get, set]`

bool	IsBranch `[get]`

bool	HasMerged `[get]`

virtual bool	AllowSaving `[get, set]`

virtual bool	IsDirty `[get, set]`

virtual uint	UncompressedSize `[get]`

virtual Type[]	AllowedChildTypes `[get]`

virtual string	Compression `[get, set]`

virtual bool	RetainChildrenOnReplace `[get]`

virtual bool	supportsCompression `[get]`

static MD5CryptoServiceProvider	MD5Provider `[get]`

Properties inherited from BrawlLib.Modeling.IModel
InfluenceManager	Influences `[get]`

IBoneNode[]	BoneCache `[get]`

IBoneNode[]	RootBones `[get]`

IObject[]	Objects `[get]`

int	SelectedObjectIndex `[get, set]`

bool	IsTargetModel `[get, set]`

Properties inherited from BrawlLib.OpenGL.IRenderedObject
List< DrawCallBase >	DrawCalls `[get]`

bool	IsRendering `[get, set]`

bool	Attached `[get]`

Events
EventHandler	DrawCallsChanged

Events inherited from BrawlLib.SSBB.ResourceNodes.ResourceNode
SelectEventHandler	SelectChild

EventHandler	UpdateProps

MoveEventHandler	MovedUp

ResourceEventHandler	Disposing

ResourceChildEventHandler	ChildAdded

ResourceChildInsertEventHandler	ChildInserted

Events inherited from BrawlLib.OpenGL.IRenderedObject
EventHandler	DrawCallsChanged

Constructor & Destructor Documentation

◆ MDL0Node()

BrawlLib.SSBB.ResourceNodes.MDL0Node.MDL0Node ( )

inline

        {
            _version = 9;
            _linker = ModelLinker.Prepare(this);
        }

Member Function Documentation

◆ AddChild()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.AddChild	(	ResourceNode	child,
		bool	change
	)

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            if (child is MDL0GroupNode)
            {
                LinkGroup(child as MDL0GroupNode);
            }
 
            base.AddChild(child, change);
        }

◆ ApplyCHR()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplyCHR	(	CHR0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            _bindFrame = node == null || index == 0;
 
            //Transform bones
            if (_boneList != null)
            {
                foreach (MDL0BoneNode b in _boneList)
                {
                    b.ApplyCHR0(node, index);
                }
            }
 
            WeightMeshes();
        }

◆ ApplyCLR()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplyCLR	(	CLR0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            //Apply color changes
            if (_matList != null)
            {
                foreach (MDL0MaterialNode m in _matList)
                {
                    m.ApplyCLR0(node, index);
                }
            }
        }

◆ ApplyPAT()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplyPAT	(	PAT0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            //Change textures
            if (_matList != null)
            {
                foreach (MDL0MaterialNode m in _matList)
                {
                    m.ApplyPAT0(node, index);
                }
            }
        }

◆ ApplySCN()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplySCN	(	SCN0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            _scn0 = node;
            _scn0Frame = index;
 
            if (node != null)
            {
                _scn0Frame = _scn0Frame.Clamp(1, node.FrameCount);
            }
 
            if (_matList != null)
            {
                foreach (MDL0MaterialNode mat in _matList)
                {
                    mat.ApplySCN(node, _scn0Frame);
                }
            }
        }

◆ ApplySHP()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplySHP	(	SHP0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            _currentSHP = node;
            _currentSHPIndex = index;
 
            //Max amount of morphs allowed is technically 32
 
            SHP0EntryNode entry;
 
            if (_objList != null)
            {
                foreach (MDL0ObjectNode poly in _objList)
                {
                    PrimitiveManager p = poly._manager;
                    if (p?._vertices == null || p._faceData == null)
                    {
                        continue;
                    }
 
                    //Reset this object's normal buffer to default
                    //Vertices are already weighted in WeightMeshes
                    //and colors aren't influenced by matrices,
                    //so they can be retrieved directly from the external array later on
                    for (int i = 0; i < p._vertices.Count; i++)
                    {
                        Vertex3 v = p._vertices[i];
                        if (v.FaceDataIndices != null)
                        {
                            for (int m = 0; m < v.FaceDataIndices.Count; m++)
                            {
                                int fIndex = v.FaceDataIndices[m];
                                if (fIndex < p._pointCount && fIndex >= 0)
                                {
                                    if (p._faceData[1] != null && poly._normalNode != null)
                                    {
                                        int normalIndex = v.Facepoints[m]._normalIndex;
                                        if (normalIndex >= 0 && normalIndex < poly._normalNode.Normals.Length)
                                        {
                                            ((Vector3*) p._faceData[1].Address)[fIndex] =
                                                poly._normalNode.Normals[normalIndex];
                                        }
                                    }
 
                                    if ((node == null || index == 0) && poly._colorSet != null)
                                    {
                                        for (int c = 0; c < 2; c++)
                                        {
                                            if (p._faceData[c + 2] != null && poly._colorSet[c] != null)
                                            {
                                                int colorIndex = v.Facepoints[m]._colorIndices[c];
                                                if (colorIndex >= 0 && colorIndex < poly._colorSet[c].Colors.Length)
                                                {
                                                    ((RGBAPixel*) p._faceData[c + 2].Address)[fIndex] =
                                                        poly._colorSet[c].Colors[colorIndex];
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
 
                    if (node == null || index == 0)
                    {
                        continue;
                    }
 
                    if ((entry = node.FindChild(poly.VertexNode, true) as SHP0EntryNode) != null &&
                        entry.Enabled && entry.UpdateVertices)
                    {
                        float[] weights = new float[entry.Children.Count];
                        foreach (SHP0VertexSetNode shpSet in entry.Children)
                        {
                            weights[shpSet.Index] = shpSet.Keyframes.GetFrameValue(index - 1);
                        }
 
                        float totalWeight = 0;
                        foreach (float f in weights)
                        {
                            totalWeight += f;
                        }
 
                        float baseWeight = 1.0f - totalWeight;
                        float total = totalWeight + baseWeight;
 
                        MDL0VertexNode[] nodes = new MDL0VertexNode[entry.Children.Count];
                        foreach (SHP0VertexSetNode shpSet in entry.Children)
                        {
                            nodes[shpSet.Index] = _vertList.Find(x => x.Name == shpSet.Name) as MDL0VertexNode;
                        }
 
                        //Calculate barycenter per vertex and set as weighted pos
                        if (p._vertices != null)
                        {
                            for (int i = 0; i < p._vertices.Count; i++)
                            {
                                int x = 0;
                                Vertex3 v3 = p._vertices[i];
                                v3._weightedPosition *= baseWeight;
 
                                foreach (MDL0VertexNode vNode in nodes)
                                {
                                    if (vNode != null && v3.Facepoints[0]._vertexIndex < vNode.Vertices.Length)
                                    {
                                        v3._weightedPosition +=
                                            v3.GetMatrix() * vNode.Vertices[v3.Facepoints[0]._vertexIndex] *
                                            weights[x];
                                    }
 
                                    x++;
                                }
 
                                v3._weightedPosition /= total;
 
                                v3._weights = weights;
                                v3._nodes = nodes;
                                v3._baseWeight = baseWeight;
                                v3._bCenter = v3._weightedPosition;
                            }
                        }
                    }
 
                    if ((entry = node.FindChild(poly.NormalNode, true) as SHP0EntryNode) != null &&
                        entry.Enabled && entry.UpdateNormals)
                    {
                        float[] weights = new float[entry.Children.Count];
                        foreach (SHP0VertexSetNode shpSet in entry.Children)
                        {
                            weights[shpSet.Index] = shpSet.Keyframes.GetFrameValue(index - 1);
                        }
 
                        float totalWeight = 0;
                        foreach (float f in weights)
                        {
                            totalWeight += f;
                        }
 
                        float baseWeight = 1.0f - totalWeight;
                        float total = totalWeight + baseWeight;
 
                        MDL0NormalNode[] nodes = new MDL0NormalNode[entry.Children.Count];
                        foreach (SHP0VertexSetNode shpSet in entry.Children)
                        {
                            nodes[shpSet.Index] = _normList.Find(x => x.Name == shpSet.Name) as MDL0NormalNode;
                        }
 
                        UnsafeBuffer buf = p._faceData[1];
                        if (buf != null)
                        {
                            Vector3* pData = (Vector3*) buf.Address;
 
                            if (p._vertices != null)
                            {
                                for (int i = 0; i < p._vertices.Count; i++)
                                {
                                    Vertex3 v3 = p._vertices[i];
                                    int m = 0;
                                    foreach (Facepoint r in v3.Facepoints)
                                    {
                                        int nIndex = v3.FaceDataIndices[m++];
 
                                        Vector3 weightedNormal =
                                            v3.GetMatrix().GetRotationMatrix() * pData[nIndex] * baseWeight;
 
                                        int x = 0;
                                        foreach (MDL0NormalNode n in nodes)
                                        {
                                            if (n != null && r._normalIndex < n.Normals.Length)
                                            {
                                                weightedNormal +=
                                                    v3.GetMatrix().GetRotationMatrix() *
                                                    n.Normals[r._normalIndex] *
                                                    weights[x];
                                            }
 
                                            x++;
                                        }
 
                                        pData[nIndex] = v3.GetInvMatrix().GetRotationMatrix() *
                                                        (weightedNormal / total).Normalize();
                                    }
                                }
                            }
                        }
 
                        p._dirty[1] = true;
                    }
 
                    for (int x = 0; x < 2; x++)
                    {
                        if (poly._colorSet[x] != null &&
                            (entry = node.FindChild(poly._colorSet[x].Name, true) as SHP0EntryNode) != null &&
                            entry.Enabled && entry.UpdateColors)
                        {
                            float[] weights = new float[entry.Children.Count];
                            foreach (SHP0VertexSetNode shpSet in entry.Children)
                            {
                                weights[shpSet.Index] = shpSet.Keyframes.GetFrameValue(index - 1);
                            }
 
                            float totalWeight = 0;
                            foreach (float f in weights)
                            {
                                totalWeight += f;
                            }
 
                            float baseWeight = 1.0f - totalWeight;
                            float total = totalWeight + baseWeight;
 
                            MDL0ColorNode[] nodes = new MDL0ColorNode[entry.Children.Count];
                            foreach (SHP0VertexSetNode shpSet in entry.Children)
                            {
                                nodes[shpSet.Index] = _colorList.Find(b => b.Name == shpSet.Name) as MDL0ColorNode;
                            }
 
                            UnsafeBuffer buf = p._faceData[x + 2];
                            if (buf != null)
                            {
                                RGBAPixel* pData = (RGBAPixel*) buf.Address;
 
                                if (p._vertices != null)
                                {
                                    for (int i = 0; i < p._vertices.Count; i++)
                                    {
                                        Vertex3 v3 = p._vertices[i];
                                        int m = 0;
                                        foreach (Facepoint r in v3.Facepoints)
                                        {
                                            int cIndex = v3.FaceDataIndices[m++];
                                            if (cIndex < p._pointCount)
                                            {
                                                Vector4 color =
                                                    (Vector4) poly._colorSet[x].Colors[r._colorIndices[x]] * baseWeight;
 
                                                int w = 0;
                                                foreach (MDL0ColorNode n in nodes)
                                                {
                                                    if (n != null && r._colorIndices[x] < n.Colors.Length)
                                                    {
                                                        color += (Vector4) n.Colors[r._colorIndices[x]] * weights[w];
                                                    }
 
                                                    w++;
                                                }
 
                                                pData[cIndex] = color / total;
                                            }
                                        }
                                    }
                                }
                            }
 
                            p._dirty[x + 2] = true;
                        }
                    }
                }
            }
        }

◆ ApplySRT()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplySRT	(	SRT0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            //Transform textures
            if (_matList != null)
            {
                foreach (MDL0MaterialNode m in _matList)
                {
                    m.ApplySRT0(node, index);
                }
            }
        }

◆ ApplyVIS()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ApplyVIS	(	VIS0Node	node,
		float	index
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            if (node == null || index < 1)
            {
                //if (_objList != null)
                //    foreach (MDL0ObjectNode o in _objList)
                //        if (o._visBoneNode != null)
                //            o._render = o._visBoneNode._boneFlags.HasFlag(BoneFlags.Visible);
                return;
            }
 
            if (VIS0Indices == null)
            {
                RegenerateVIS0Indices();
            }
 
            foreach (string boneName in VIS0Indices.Keys)
            {
                VIS0EntryNode entry = null;
                Dictionary<int, List<int>> objects = VIS0Indices[boneName];
                foreach (KeyValuePair<int, List<int>> objDrawCalls in objects)
                {
                    MDL0ObjectNode obj = (MDL0ObjectNode) _objList[objDrawCalls.Key];
                    for (int x = 0; x < objDrawCalls.Value.Count; x++)
                    {
                        DrawCall c = obj._drawCalls[objDrawCalls.Value[x]];
                        if ((entry = (VIS0EntryNode) node.FindChild(c._visBoneNode.Name, true)) != null)
                        {
                            if (entry._entryCount != 0 && index > 0)
                            {
                                c._render = entry.GetEntry((int) index - 1);
                            }
                            else
                            {
                                c._render = entry._flags.HasFlag(VIS0Flags.Enabled);
                            }
                        }
                    }
                }
            }
        }

◆ Attach()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.Attach ( )

inline

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            _attached = true;
            foreach (MDL0GroupNode g in Children)
            {
                g.Bind();
            }
 
            RegenerateVIS0Indices();
        }

◆ BeginImport()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.BeginImport ( )

inline

        {
            _isImport = true;
            InitGroups();
        }

◆ CalculateBoundingBoxes()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.CalculateBoundingBoxes ( )

inline

        {
            ApplyCHR(null, 0);
            _extents = GetBox();
            if (_boneList != null)
            {
                foreach (MDL0BoneNode b in _boneList)
                {
                    b.SetBox();
                }
            }
 
            SignalPropertyChange();
            UpdateProperties();
        }

◆ CheckTextures()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.CheckTextures ( )

inline

        {
            if (_texList != null)
            {
                for (int i = 0; i < _texList.Count; i++)
                {
                    MDL0TextureNode t = (MDL0TextureNode) _texList[i];
                    for (int x = 0; x < t._references.Count; x++)
                    {
                        if (t._references[x].Parent == null)
                        {
                            t._references.RemoveAt(x--);
                        }
                    }
 
                    if (t._references.Count == 0)
                    {
                        _texList.RemoveAt(i--);
                    }
                }
            }
        }

◆ CleanTextures()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.CleanTextures ( )

inline

        {
            if (_texList != null)
            {
                int i = 0;
                while (i < _texList.Count)
                {
                    MDL0TextureNode texture = (MDL0TextureNode) _texList[i];
 
                    at1:
                    foreach (MDL0MaterialRefNode r in texture._references)
                    {
                        if (_matList.IndexOf(r.Parent) == -1)
                        {
                            texture._references.Remove(r);
                            goto at1;
                        }
                    }
 
                    if (texture._references.Count == 0)
                    {
                        _texList.RemoveAt(i);
                    }
                    else
                    {
                        i++;
                    }
                }
            }
 
            if (_pltList != null)
            {
                int i = 0;
                while (i < _pltList.Count)
                {
                    MDL0TextureNode palette = (MDL0TextureNode) _pltList[i];
 
                    bt1:
                    foreach (MDL0MaterialRefNode r in palette._references)
                    {
                        if (_matList.IndexOf(r.Parent) == -1)
                        {
                            palette._references.Remove(r);
                            goto bt1;
                        }
                    }
 
                    if (palette._references.Count == 0)
                    {
                        _pltList.RemoveAt(i);
                    }
                    else
                    {
                        i++;
                    }
                }
            }
        }

◆ ConvertToShadowModel()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ConvertToShadowModel ( )

inline

        {
            if (_matGroup == null)
            {
                Populate();
                if (_matGroup == null || _boneGroup == null || _objGroup == null)
                {
                    return;
                }
            }
 
            // Implementation with support for multiple culling types
            MDL0MaterialNode mat1 = new MDL0MaterialNode();
            _matGroup.AddChild(mat1);
            mat1.GenerateShadowMaterial();
            //mat1.Name += "_CullNone";
            mat1.CullMode = CullMode.Cull_None;
 
            MDL0MaterialNode mat2 = new MDL0MaterialNode();
            _matGroup.AddChild(mat2);
            mat2.GenerateShadowMaterial();
            //mat2.Name += "_CullInside";
            mat2.CullMode = CullMode.Cull_Inside;
 
            MDL0MaterialNode mat3 = new MDL0MaterialNode();
            _matGroup.AddChild(mat3);
            mat3.GenerateShadowMaterial();
            //mat3.Name += "_CullOutside";
            mat3.CullMode = CullMode.Cull_Outside;
 
            MDL0MaterialNode mat4 = new MDL0MaterialNode();
            _matGroup.AddChild(mat4);
            mat4.GenerateShadowMaterial();
            //mat4.Name += "_CullAll";
            mat4.CullMode = CullMode.Cull_All;
 
            // Properly remove all shaders
            if (ShaderList != null)
            {
                int shaderNum = ShaderGroup.Children.Count;
                for (int i = 0; i < shaderNum; i++)
                {
                    ResourceNode s = ShaderGroup.Children[0];
                    ShaderGroup.RemoveChild(s);
                }
 
                //Children.Remove(ShaderGroup);
            }
 
            // Add a new shader
            if (_shadGroup == null)
            {
                MDL0GroupNode g = _shadGroup;
                if (g == null)
                {
                    AddChild(g = new MDL0GroupNode(MDLResourceType.Shaders), true);
                    _shadGroup = g;
                    _shadList = g.Children;
                }
            }
 
            if (_shadList.Count == 0)
            {
                if (_shadList != null && _matList != null && _shadList.Count < _matList.Count)
                {
                    MDL0ShaderNode shader = new MDL0ShaderNode();
                    _shadGroup.AddChild(shader);
                    shader.DefaultAsShadow();
                    shader.Rebuild(true);
                }
            }
 
            mat1.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat2.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat3.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat4.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat1.Rebuild(true);
            mat2.Rebuild(true);
            mat3.Rebuild(true);
            mat4.Rebuild(true);
 
            if (_objGroup == null)
            {
                return;
            }
 
            bool usesCullOutside = false;
            bool usesCullInside = false;
            bool usesCullNone = false;
            bool usesCullAll = false;
            foreach (MDL0ObjectNode m in _objGroup.Children)
            {
                m.TextureMatrix0Enabled = false;
                m.TextureMatrix1Enabled = false;
                m.TextureMatrix2Enabled = false;
                m.TextureMatrix3Enabled = false;
                m.TextureMatrix4Enabled = false;
                m.TextureMatrix5Enabled = false;
                m.TextureMatrix6Enabled = false;
                m.TextureMatrix7Enabled = false;
 
                m.TextureMatrix0Identity = false;
                m.TextureMatrix1Identity = false;
                m.TextureMatrix2Identity = false;
                m.TextureMatrix3Identity = false;
                m.TextureMatrix4Identity = false;
                m.TextureMatrix5Identity = false;
                m.TextureMatrix6Identity = false;
                m.TextureMatrix7Identity = false;
 
                foreach (DrawCall c in m.DrawCalls)
                {
                    CullMode cullToUse = c.MaterialNode.CullMode;
 
                    switch (cullToUse)
                    {
                        case CullMode.Cull_None:
                            c.MaterialNode = mat1;
                            usesCullNone = true;
                            break;
                        case CullMode.Cull_Inside:
                            c.MaterialNode = mat2;
                            usesCullInside = true;
                            break;
                        case CullMode.Cull_Outside:
                            c.MaterialNode = mat3;
                            usesCullOutside = true;
                            break;
                        case CullMode.Cull_All:
                            c.MaterialNode = mat4;
                            usesCullAll = true;
                            break;
                        default: break;
                    }
 
                    c.DrawPass = DrawCall.DrawPassType.Transparent;
                }
            }
 
            // Delete unused materials
            while (MaterialGroup.Children.Count > 4)
            {
                MaterialGroup.RemoveChild(MaterialGroup.Children[0]);
            }
 
            if (!usesCullAll)
            {
                MaterialGroup.RemoveChild(mat4);
            }
 
            if (!usesCullOutside)
            {
                MaterialGroup.RemoveChild(mat3);
            }
 
            if (!usesCullInside)
            {
                MaterialGroup.RemoveChild(mat2);
            }
 
            if (!usesCullNone)
            {
                MaterialGroup.RemoveChild(mat1);
            }
 
            if (MaterialGroup.Children.Count == 1 && MaterialGroup.Children[0].Name.IndexOf("_") > 0)
            {
                MaterialGroup.Children[0].Name = MaterialGroup.Children[0].Name
                    .Substring(0,
                        MaterialGroup.Children[0].Name.IndexOf("_"));
            }
 
            if (BoneGroup == null)
            {
                Populate();
            }
 
            MDL0BoneNode b = (MDL0BoneNode) BoneGroup.Children[0];
            b.Name = b.Name + "_NShadow";
            b.Scale = new Vector3(b.Scale._x * 1.01f, b.Scale._y * 1.01f, b.Scale._z * 1.01f);
 
            if (Name.Length > 4)
            {
                if (Name.Substring(Name.Length - 4) == " (2)")
                {
                    Name = Name.Substring(0, Name.Length - 4);
                }
            }
 
            Name = Name + "_Shadow";
        }

◆ ConvertToSpyModel()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ConvertToSpyModel ( )

inline

        {
            if (_matGroup == null)
            {
                return;
            }
 
            Name = Name + "Spy";
 
            if (MultiTypeWorks)
            {
                ConvertToSpyModelMultiType();
                return;
            }
 
            // Material only works properly with the name SpyCloak, so it needs to select the correct culling type
            MDL0MaterialNode mat1 = new MDL0MaterialNode();
            _matGroup.AddChild(mat1);
            mat1.GenerateSpyMaterial();
            mat1.CullMode = CullMode.Cull_None;
 
            MDL0MaterialNode matCulled = new MDL0MaterialNode();
            _matGroup.AddChild(matCulled);
            matCulled.GenerateSpyMaterial();
            matCulled.Name += "_CullAll";
            matCulled.CullMode = CullMode.Cull_All;
 
            // Properly remove all shaders
            if (ShaderList != null)
            {
                int shaderNum = ShaderGroup.Children.Count;
                for (int i = 0; i < shaderNum; i++)
                {
                    ResourceNode s = ShaderGroup.Children[0];
                    ShaderGroup.RemoveChild(s);
                }
 
                //Children.Remove(ShaderGroup);
            }
 
            // Add a new shader
            if (_shadGroup == null)
            {
                MDL0GroupNode g = _shadGroup;
                if (g == null)
                {
                    AddChild(g = new MDL0GroupNode(MDLResourceType.Shaders), true);
                    _shadGroup = g;
                    _shadList = g.Children;
                }
            }
 
            if (_shadList.Count == 0)
            {
                if (_shadList != null && _matList != null && _shadList.Count < _matList.Count)
                {
                    MDL0ShaderNode shader = new MDL0ShaderNode();
                    _shadGroup.AddChild(shader);
                    shader.DefaultAsSpy();
                    shader.Rebuild(true);
                }
            }
 
            // Add the color
            MDL0GroupNode colorG = _colorGroup;
            if (colorG == null)
            {
                AddChild(colorG = new MDL0GroupNode(MDLResourceType.Colors), true);
                _colorGroup = colorG;
                _colorList = colorG.Children;
            }
 
            MDL0ColorNode colorNode = new MDL0ColorNode
            {
                Name = Name + "_BodyM__" + Name + "_Spycloak",
                Colors = new RGBAPixel[] {new RGBAPixel {A = 255, R = 132, G = 130, B = 132}}
            };
            colorG.AddChild(colorNode, true);
 
            mat1.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat1.Rebuild(true);
 
            if (_objGroup == null)
            {
                return;
            }
 
            bool usesCullOutside = false;
            bool usesCullInside = false;
            bool usesCullNone = false;
            bool usesCullAll = false;
            foreach (MDL0ObjectNode m in _objGroup.Children)
            {
                foreach (DrawCall c in m.DrawCalls)
                {
                    CullMode cullToUse = c.MaterialNode.CullMode;
                    c.MaterialNode = mat1;
                    switch (cullToUse)
                    {
                        case CullMode.Cull_None:
                            usesCullNone = true;
                            break;
                        case CullMode.Cull_Inside:
                            usesCullInside = true;
                            break;
                        case CullMode.Cull_Outside:
                            usesCullOutside = true;
                            break;
                        case CullMode.Cull_All:
                            c.MaterialNode = matCulled;
                            usesCullAll = true;
                            break;
                        default: break;
                    }
 
                    c.DrawPass = DrawCall.DrawPassType.Opaque;
                }
 
                for (int i = 0; i < 8; i++)
                {
                    m.SetUVs(i, null, true);
                }
 
                m.SetColors(0, colorNode.Name, true);
                m.SetColors(1, null, true);
 
                m.TextureMatrix0Enabled = true;
                m.TextureMatrix1Enabled = true;
                m.TextureMatrix2Enabled = false;
                m.TextureMatrix3Enabled = false;
                m.TextureMatrix4Enabled = false;
                m.TextureMatrix5Enabled = false;
                m.TextureMatrix6Enabled = false;
                m.TextureMatrix7Enabled = false;
 
                m.TextureMatrix0Identity = true;
                m.TextureMatrix1Identity = false;
                m.TextureMatrix2Identity = false;
                m.TextureMatrix3Identity = false;
                m.TextureMatrix4Identity = false;
                m.TextureMatrix5Identity = false;
                m.TextureMatrix6Identity = false;
                m.TextureMatrix7Identity = false;
            }
 
            // Delete Unused Colors
            while (ColorGroup.Children.Count > 1)
            {
                ColorGroup.RemoveChild(ColorGroup.Children[0]);
            }
 
 
            // Delete unused materials
            while (MaterialGroup.Children.Count > 2)
            {
                MaterialGroup.RemoveChild(MaterialGroup.Children[0]);
            }
 
            // Choose proper culling based on best usage
            if (usesCullNone || usesCullInside && usesCullOutside)
            {
                mat1.CullMode = CullMode.Cull_None;
            }
            else if (usesCullInside)
            {
                mat1.CullMode = CullMode.Cull_Inside;
            }
            else if (usesCullOutside)
            {
                mat1.CullMode = CullMode.Cull_Outside;
            }
 
            if (!usesCullAll)
            {
                MaterialGroup.RemoveChild(matCulled);
            }
 
            foreach (MDL0MaterialNode mat in _matGroup.Children)
            {
                foreach (MDL0MaterialRefNode matref in mat.Children)
                {
                    matref.HasTextureMatrix = true;
                }
            }
        }

◆ ConvertToSpyModelMultiType()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ConvertToSpyModelMultiType ( )

inline

        {
            if (_matGroup == null)
            {
                return;
            }
 
            // Implementation with support for multiple culling types
            // Will all be named the same as the material appears to need to be named "Spycloak"
            MDL0MaterialNode mat1 = new MDL0MaterialNode();
            _matGroup.AddChild(mat1);
            mat1.GenerateSpyMaterial();
            //mat1.Name += "_CullNone";
            mat1.CullMode = CullMode.Cull_None;
 
            MDL0MaterialNode mat2 = new MDL0MaterialNode();
            _matGroup.AddChild(mat2);
            mat2.GenerateSpyMaterial();
            //mat2.Name += "_CullInside";
            mat2.CullMode = CullMode.Cull_Inside;
 
            MDL0MaterialNode mat3 = new MDL0MaterialNode();
            _matGroup.AddChild(mat3);
            mat3.GenerateSpyMaterial();
            //mat3.Name += "_CullOutside";
            mat3.CullMode = CullMode.Cull_Outside;
 
            MDL0MaterialNode mat4 = new MDL0MaterialNode();
            _matGroup.AddChild(mat4);
            mat4.GenerateSpyMaterial();
            //mat4.Name += "_CullAll";
            mat4.CullMode = CullMode.Cull_All;
 
            // Properly remove all shaders
            if (ShaderList != null)
            {
                int shaderNum = ShaderGroup.Children.Count;
                for (int i = 0; i < shaderNum; i++)
                {
                    ResourceNode s = ShaderGroup.Children[0];
                    ShaderGroup.RemoveChild(s);
                }
 
                //Children.Remove(ShaderGroup);
            }
 
            // Add a new shader
            if (_shadGroup == null)
            {
                MDL0GroupNode g = _shadGroup;
                if (g == null)
                {
                    AddChild(g = new MDL0GroupNode(MDLResourceType.Shaders), true);
                    _shadGroup = g;
                    _shadList = g.Children;
                }
            }
 
            if (_shadList.Count == 0)
            {
                if (_shadList != null && _matList != null && _shadList.Count < _matList.Count)
                {
                    MDL0ShaderNode shader = new MDL0ShaderNode();
                    _shadGroup.AddChild(shader);
                    shader.DefaultAsSpy();
                    shader.Rebuild(true);
                }
            }
 
            // Add the color
            MDL0GroupNode colorG = _colorGroup;
            if (colorG == null)
            {
                AddChild(colorG = new MDL0GroupNode(MDLResourceType.Colors), true);
                _colorGroup = colorG;
                _colorList = colorG.Children;
            }
 
            MDL0ColorNode colorNode = new MDL0ColorNode
            {
                Name = Name + "_BodyM__" + Name + "_Spycloak",
                Colors = new RGBAPixel[] {new RGBAPixel {A = 255, R = 132, G = 130, B = 132}}
            };
            colorG.AddChild(colorNode, true);
 
            mat1.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat2.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat3.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat4.ShaderNode = (MDL0ShaderNode) _shadList[0];
            mat1.Rebuild(true);
            mat2.Rebuild(true);
            mat3.Rebuild(true);
            mat4.Rebuild(true);
 
            if (_objGroup == null)
            {
                return;
            }
 
            bool usesCullOutside = false;
            bool usesCullInside = false;
            bool usesCullNone = false;
            bool usesCullAll = false;
            foreach (MDL0ObjectNode m in _objGroup.Children)
            {
                foreach (DrawCall c in m.DrawCalls)
                {
                    CullMode cullToUse = c.MaterialNode.CullMode;
                    switch (cullToUse)
                    {
                        case CullMode.Cull_None:
                            c.MaterialNode = mat1;
                            usesCullNone = true;
                            break;
                        case CullMode.Cull_Inside:
                            c.MaterialNode = mat2;
                            usesCullInside = true;
                            break;
                        case CullMode.Cull_Outside:
                            c.MaterialNode = mat3;
                            usesCullOutside = true;
                            break;
                        case CullMode.Cull_All:
                            c.MaterialNode = mat4;
                            usesCullAll = true;
                            break;
                        default: break;
                    }
 
                    c.DrawPass = DrawCall.DrawPassType.Opaque;
                }
 
                for (int i = 0; i < 8; i++)
                {
                    m.SetUVs(i, null, true);
                }
 
                m.SetColors(0, colorNode.Name, true);
                m.SetColors(1, null, true);
 
                m.TextureMatrix0Enabled = true;
                m.TextureMatrix1Enabled = true;
                m.TextureMatrix2Enabled = false;
                m.TextureMatrix3Enabled = false;
                m.TextureMatrix4Enabled = false;
                m.TextureMatrix5Enabled = false;
                m.TextureMatrix6Enabled = false;
                m.TextureMatrix7Enabled = false;
 
                m.TextureMatrix0Identity = true;
                m.TextureMatrix1Identity = false;
                m.TextureMatrix2Identity = false;
                m.TextureMatrix3Identity = false;
                m.TextureMatrix4Identity = false;
                m.TextureMatrix5Identity = false;
                m.TextureMatrix6Identity = false;
                m.TextureMatrix7Identity = false;
            }
 
            // Delete Unused Colors
            while (ColorGroup.Children.Count > 1)
            {
                ColorGroup.RemoveChild(ColorGroup.Children[0]);
            }
 
            // Delete unused materials
            while (MaterialGroup.Children.Count > 4)
            {
                MaterialGroup.RemoveChild(MaterialGroup.Children[0]);
            }
 
            if (!usesCullAll)
            {
                MaterialGroup.RemoveChild(mat4);
            }
 
            if (!usesCullOutside)
            {
                MaterialGroup.RemoveChild(mat3);
            }
 
            if (!usesCullInside)
            {
                MaterialGroup.RemoveChild(mat2);
            }
 
            if (!usesCullNone)
            {
                MaterialGroup.RemoveChild(mat1);
            }
 
            if (MaterialGroup.Children.Count == 1 && MaterialGroup.Children[0].Name.IndexOf("_") > 0)
            {
                MaterialGroup.Children[0].Name = MaterialGroup.Children[0].Name
                    .Substring(0,
                        MaterialGroup.Children[0].Name.IndexOf("_"));
            }
 
            foreach (MDL0MaterialNode mat in _matGroup.Children)
            {
                foreach (MDL0MaterialRefNode matref in mat.Children)
                {
                    matref.HasTextureMatrix = true;
                }
            }
        }

◆ Detach()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.Detach ( )

inline

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            _attached = false;
            foreach (MDL0GroupNode g in Children)
            {
                g.Unbind();
            }
        }

◆ DrawBox()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.DrawBox ( bool bindState )

inline

        {
            Box box = bindState ? _extents : GetBox();
            //if (box.IsValid)
            TKContext.DrawWireframeBox(box);
        }

◆ Export()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.Export ( string outPath )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.BRESEntryNode.

        {
            if (outPath.ToUpper().EndsWith(".DAE"))
            {
                Collada.Serialize(this, outPath);
            }
            //else if (outPath.ToUpper().EndsWith(".PMD"))
            //    PMDModel.Export(this, outPath);
            //else if (outPath.ToUpper().EndsWith(".RMDL"))
            //    XMLExporter.ExportRMDL(this, outPath);
            else
            {
                base.Export(outPath);
            }
        }

◆ FindBone()

MDL0BoneNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindBone ( string name )

inline

        {
            foreach (MDL0BoneNode b in _linker.BoneCache)
            {
                if (b.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return b;
                }
            }
 
            return null;
        }

◆ FindBoneByIndex()

MDL0BoneNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindBoneByIndex ( int givenIndex )

inline

        {
            // Generate bones if the model hasn't been seen yet
            if (_boneGroup == null)
            {
                Populate();
                _linker.RegenerateBoneCache();
            }
 
            foreach (MDL0BoneNode b in BoneCache)
            {
                if (b.BoneIndex == givenIndex)
                {
                    return b;
                }
            }
 
            return null;
        }

◆ FindOrCreateOpaMaterial()

MDL0MaterialNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindOrCreateOpaMaterial ( string name )

inline

        {
            foreach (MDL0MaterialNode m in _matList)
            {
                if (m.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return m;
                }
            }
 
            MDL0MaterialNode node = new MDL0MaterialNode {_name = _matGroup.FindName(name)};
            _matGroup.AddChild(node, false);
 
            SignalPropertyChange();
 
            return node;
        }

◆ FindOrCreatePalette()

MDL0TextureNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindOrCreatePalette ( string name )

inline

        {
            if (_pltGroup == null)
            {
                AddChild(_pltGroup = new MDL0GroupNode(MDLResourceType.Palettes), false);
            }
            else
            {
                foreach (MDL0TextureNode n in _pltGroup.Children)
                {
                    if (n._name == name)
                    {
                        return n;
                    }
                }
            }
 
            MDL0TextureNode node = new MDL0TextureNode(name);
            _pltGroup.AddChild(node, false);
 
            return node;
        }

◆ FindOrCreateTexture()

MDL0TextureNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindOrCreateTexture ( string name )

inline

        {
            if (_texGroup == null)
            {
                AddChild(_texGroup = new MDL0GroupNode(MDLResourceType.Textures), false);
            }
            else
            {
                foreach (MDL0TextureNode n in _texGroup.Children)
                {
                    if (n._name == name)
                    {
                        return n;
                    }
                }
            }
 
            MDL0TextureNode node = new MDL0TextureNode(name);
            _texGroup.AddChild(node, false);
 
            return node;
        }

◆ FindOrCreateXluMaterial()

MDL0MaterialNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FindOrCreateXluMaterial ( string name )

inline

        {
            foreach (MDL0MaterialNode m in _matList)
            {
                if (m.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return m;
                }
            }
 
            MDL0MaterialNode node = new MDL0MaterialNode {_name = _matGroup.FindName(name), XLUMaterial = true};
            _matGroup.AddChild(node, false);
 
            SignalPropertyChange();
 
            return node;
        }

◆ FinishImport()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.FinishImport ( Collada form = null )

inline

        {
            //Prepare for rebuild
            CleanTextures();
            CleanGroups();
            _influences.Clean();
            _influences.Sort();
            _linker = ModelLinker.Prepare(this);
 
            //Calculate size and get strings
            int size = (_calcSize = ModelEncoder.CalcSize(form, _linker)).Align(4);
            StringTable table = new StringTable();
            GetStrings(table);
 
            //Create temp file and write model and string table, then post process strings, etc
            FileMap uncompMap = FileMap.FromTempFile(size + table.GetTotalSize());
            ModelEncoder.Build(form, _linker, (MDL0Header*) uncompMap.Address, _calcSize, true);
            table.WriteTable(uncompMap.Address + size);
            PostProcess(null, uncompMap.Address, _calcSize, table);
 
            table.Clear();
            _isImport = false;
 
            _origSource = _uncompSource = new DataSource(uncompMap);
 
            if (_children != null)
            {
                foreach (ResourceNode node in _children)
                {
                    node.Dispose();
                }
 
                _children.Clear();
                _children = null;
            }
 
            if (!OnInitialize())
            {
                _children = new List<ResourceNode>();
            }
 
            IsDirty = false;
        }

◆ FromFile()

static MDL0Node BrawlLib.SSBB.ResourceNodes.MDL0Node.FromFile	(	string	path,
		FileOptions	options = `FileOptions.RandomAccess`
	)

inlinestatic

        {
            if (path.EndsWith(".dae", StringComparison.OrdinalIgnoreCase))
            {
                return new Collada {Text = $"Import Settings - {Path.GetFileName(path)}"}.ShowDialog(path,
                    Collada.ImportType.MDL0) as MDL0Node;
            }
 
            if (path.EndsWith(".pmd", StringComparison.OrdinalIgnoreCase))
            {
                return PMDModel.ImportModel(path);
            }
 
            return NodeFactory.FromFile(null, path, options) as MDL0Node;
        }

◆ GenerateMetalMaterials() [1/2]

void BrawlLib.SSBB.ResourceNodes.MDL0Node.GenerateMetalMaterials ( )

inline

        {
            GenerateMetalMaterials(string.IsNullOrEmpty(_metalMat) ? "metal00" : _metalMat);
        }

◆ GenerateMetalMaterials() [2/2]

void BrawlLib.SSBB.ResourceNodes.MDL0Node.GenerateMetalMaterials ( string metalTextureName )

inline

        {
            if (_children == null)
            {
                Populate();
            }
 
            if (_matList == null)
            {
                return;
            }
 
            List<MDL0MaterialNode> metalMats = new List<MDL0MaterialNode>();
            foreach (MDL0MaterialNode m in _matList)
            {
                if (m.IsMetal)
                {
                    metalMats.Add(m);
                }
            }
 
            foreach (MDL0MaterialNode m in metalMats)
            {
                m.Remove(true);
            }
 
            for (int x = 0; x < _matList.Count; x++)
            {
                MDL0MaterialNode n = (MDL0MaterialNode) _matList[x];
                if (!n.IsMetal && n.MetalMaterial == null)
                {
                    MDL0MaterialNode node = new MDL0MaterialNode
                    {
                        _updating = true,
                        Name = n.Name + "_ExtMtl",
                        _activeStages = 4
                    };
 
                    _matGroup.AddChild(node);
                    for (int i = 0; i <= n.Children.Count; i++)
                    {
                        if (i != n.Children.Count &&
                            ((MDL0MaterialRefNode) n.Children[i]).MapMode == MappingMethod.EnvCamera)
                        {
                            continue;
                        }
 
                        MDL0MaterialRefNode mr = new MDL0MaterialRefNode();
                        node.AddChild(mr);
                        mr.Texture = metalTextureName;
 
                        mr._uWrap = 0;
                        mr._vWrap = 0;
                        mr._minFltr = 0;
                        mr._magFltr = 0;
                        mr._texMtxFlags.SourceRow = TexSourceRow.TexCoord0;
                        mr.EmbossSource = 5;
 
                        if (i == n.Children.Count || ((MDL0MaterialRefNode) n.Children[i]).HasTextureMatrix)
                        {
                            mr._minFltr = 5;
                            mr._magFltr = 1;
                            mr._lodBias = -2;
 
                            mr.HasTextureMatrix = true;
                            node.Rebuild(true);
 
                            mr._texMtxFlags = new XFTexMtxInfo
                            {
                                Projection = TexProjection.STQ,
                                InputForm = TexInputForm.ABC1,
                                TexGenType = TexTexgenType.Regular,
                                SourceRow = TexSourceRow.Normals,
                                EmbossSource = 5,
                                EmbossLight = 0
                            };
 
                            mr._dualTexFlags._normalEnable = 1;
                            mr._texMatrixEffect.MapMode = MappingMethod.EnvCamera;
 
                            break;
                        }
                    }
 
                    node._chan1 = new LightChannel(63, new RGBAPixel(128, 128, 128, 255),
                        new RGBAPixel(255, 255, 255, 255), 0, 0, node);
                    node.C1ColorEnabled = true;
                    node.C1ColorDiffuseFunction = GXDiffuseFn.Clamped;
                    node.C1ColorAttenuation = GXAttnFn.Spotlight;
                    node.C1AlphaEnabled = true;
                    node.C1AlphaDiffuseFunction = GXDiffuseFn.Clamped;
                    node.C1AlphaAttenuation = GXAttnFn.Spotlight;
 
                    node._chan2 = new LightChannel(63, new RGBAPixel(255, 255, 255, 255), new RGBAPixel(), 0, 0, node);
                    node.C2ColorEnabled = true;
                    node.C2ColorDiffuseFunction = GXDiffuseFn.Disabled;
                    node.C2ColorAttenuation = GXAttnFn.Specular;
                    node.C2AlphaDiffuseFunction = GXDiffuseFn.Disabled;
                    node.C2AlphaAttenuation = GXAttnFn.Specular;
 
                    node._lightSetIndex = n._lightSetIndex;
                    node._fogIndex = n._fogIndex;
 
                    node._cull = n._cull;
                    node.CompareBeforeTexture = true;
                    node._normMapRefLight1 =
                        node._normMapRefLight2 =
                            node._normMapRefLight3 =
                                node._normMapRefLight4 = -1;
                }
            }
 
            foreach (MDL0MaterialNode node in _matList)
            {
                if (!node.IsMetal)
                {
                    continue;
                }
 
                if (node.ShaderNode != null)
                {
                    if (node.ShaderNode._autoMetal && node.ShaderNode._texCount == node.Children.Count)
                    {
                        node._updating = false;
                        continue;
                    }
 
                    if (node.ShaderNode.Stages == 4)
                    {
                        foreach (MDL0MaterialNode y in node.ShaderNode._materials)
                        {
                            if (!y.IsMetal || y.Children.Count != node.Children.Count)
                            {
                                goto Next;
                            }
                        }
 
                        node.ShaderNode.DefaultAsMetal(node.Children.Count);
                        continue;
                    }
                }
 
                Next:
                bool found = false;
                foreach (MDL0ShaderNode s in _shadGroup.Children)
                {
                    if (s._autoMetal && s._texCount == node.Children.Count)
                    {
                        node.ShaderNode = s;
                        found = true;
                    }
                    else
                    {
                        if (s.Stages == 4)
                        {
                            foreach (MDL0MaterialNode y in s._materials)
                            {
                                if (!y.IsMetal || y.Children.Count != node.Children.Count)
                                {
                                    goto NotFound;
                                }
                            }
 
                            node.ShaderNode = s;
                            found = true;
                            goto End;
                            NotFound:
                            continue;
                        }
                    }
                }
 
                End:
                if (!found)
                {
                    MDL0ShaderNode shader = new MDL0ShaderNode();
                    _shadGroup.AddChild(shader);
                    shader.DefaultAsMetal(node.Children.Count);
                    node.ShaderNode = shader;
                }
            }
 
            foreach (MDL0MaterialNode m in _matList)
            {
                m._updating = false;
            }
        }

◆ GetBox()

Box BrawlLib.SSBB.ResourceNodes.MDL0Node.GetBox ( )

inline

Call ApplyCHR0 before calling this

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            if (_objList == null)
            {
                return new Box();
            }
 
            Box box = Box.ExpandableVolume;
            foreach (MDL0ObjectNode o in _objList)
            {
                if (o._manager?._vertices != null)
                {
                    foreach (Vertex3 vertex in o._manager._vertices)
                    {
                        box.ExpandVolume(vertex.WeightedPosition);
                    }
                }
            }
 
            return box;
        }

◆ GetUsedShaders()

List< ResourceNode > BrawlLib.SSBB.ResourceNodes.MDL0Node.GetUsedShaders ( )

inline

        {
            List<ResourceNode> shaders = new List<ResourceNode>();
            if (_shadList != null)
            {
                foreach (MDL0ShaderNode s in _shadList)
                {
                    if (s._materials.Count > 0)
                    {
                        shaders.Add(s);
                    }
                }
            }
 
            return shaders;
        }

◆ LinkGroup()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.LinkGroup ( MDL0GroupNode group )

inline

        {
            switch (group._type)
            {
                case MDLResourceType.Definitions:
                {
                    _defGroup = group;
                    _defList = group._children;
                    break;
                }
 
                case MDLResourceType.Bones:
                {
                    _boneGroup = group;
                    _boneList = group._children;
                    break;
                }
 
                case MDLResourceType.Materials:
                {
                    _matGroup = group;
                    _matList = group._children;
                    break;
                }
 
                case MDLResourceType.Shaders:
                {
                    _shadGroup = group;
                    _shadList = group._children;
                    break;
                }
 
                case MDLResourceType.Vertices:
                {
                    _vertGroup = group;
                    _vertList = group._children;
                    break;
                }
 
                case MDLResourceType.Normals:
                {
                    _normGroup = group;
                    _normList = group._children;
                    break;
                }
 
                case MDLResourceType.UVs:
                {
                    _uvGroup = group;
                    _uvList = group._children;
                    break;
                }
 
                case MDLResourceType.Colors:
                {
                    _colorGroup = group;
                    _colorList = group._children;
                    break;
                }
 
                case MDLResourceType.Objects:
                {
                    _objGroup = group;
                    _objList = group._children;
                    break;
                }
 
                case MDLResourceType.Textures:
                {
                    _texGroup = group;
                    _texList = group._children;
                    break;
                }
 
                case MDLResourceType.Palettes:
                {
                    _pltGroup = group;
                    _pltList = group._children;
                    break;
                }
 
                case MDLResourceType.FurLayerCoords:
                {
                    _furPosGroup = group;
                    _furPosList = group._children;
                    break;
                }
 
                case MDLResourceType.FurVectors:
                {
                    _furVecGroup = group;
                    _furVecList = group._children;
                    break;
                }
            }
        }

◆ OnCalculateSize()

override int BrawlLib.SSBB.ResourceNodes.MDL0Node.OnCalculateSize ( bool force )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            //Clean and sort influence list
            _influences.Clean();
            //_influences.Sort();
 
            //Clean texture list
            CleanTextures();
 
            _linker = ModelLinker.Prepare(this);
            return ModelEncoder.CalcSize(_linker);
        }

◆ OnDrawCallsChanged()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.OnDrawCallsChanged ( )

inline

        {
            DrawCallsChanged?.Invoke(this, null);
        }

◆ OnInitialize()

override bool BrawlLib.SSBB.ResourceNodes.MDL0Node.OnInitialize ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.BRESEntryNode.

        {
            base.OnInitialize();
 
            _billboardBones = new List<MDL0BoneNode>();
            _errors = new List<string>();
            _influences = new InfluenceManager();
 
            MDL0Header* header = Header;
 
            if (_name == null && header->StringOffset != 0)
            {
                _name = header->ResourceString;
            }
 
            MDL0Props* props = header->Properties;
 
            if (props != null)
            {
                _scalingRule = props->_scalingRule;
                _texMtxMode = props->_texMatrixMode;
                _numFacepoints = props->_numVertices;
                _numTriangles = props->_numTriangles;
                _numNodes = props->_numNodes;
                _needsNrmMtxArray = props->_needNrmMtxArray != 0;
                _needsTexMtxArray = props->_needTexMtxArray != 0;
                _extents = props->_extents;
                _enableExtents = props->_enableExtents != 0;
                _envMtxMode = props->_envMtxMode;
 
                if (props->_origPathOffset > 0 && props->_origPathOffset < WorkingUncompressed.Length)
                {
                    _originalPath = props->OrigPath;
                }
                else if (props->_origPathOffset > 0)
                {
                    _errors.Add("Original path was found to be out of range");
                }
            }
 
            (_userEntries = new UserDataCollection()).Read(header->UserData, WorkingUncompressed);
 
            return true;
        }

◆ OnPopulate()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.OnPopulate ( )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            try
            {
                InitGroups();
                _linker = new ModelLinker(Header) {Model = this};
                _assets = new AssetStorage(_linker);
 
                //Set def flags
                _hasMix = _hasOpa = _hasTree = _hasXlu = false;
                if (_linker.Defs != null)
                {
                    foreach (ResourcePair p in *_linker.Defs)
                    {
                        if (p.Name == "NodeTree")
                        {
                            _hasTree = true;
                        }
                        else if (p.Name == "NodeMix")
                        {
                            _hasMix = true;
                        }
                        else if (p.Name == "DrawOpa")
                        {
                            _hasOpa = true;
                        }
                        else if (p.Name == "DrawXlu")
                        {
                            _hasXlu = true;
                        }
                    }
                }
 
                //These cause some complications if not parsed...
                _texGroup.Parse(this);
                _pltGroup.Parse(this);
 
                _defGroup.Parse(this);
                _boneGroup.Parse(this);
                _matGroup.Parse(this);
                _shadGroup.Parse(this);
                _vertGroup.Parse(this);
                _normGroup.Parse(this);
                _uvGroup.Parse(this);
                _colorGroup.Parse(this);
 
                if (Version >= 10)
                {
                    _furVecGroup.Parse(this);
                    _furPosGroup.Parse(this);
                }
 
                _objGroup.Parse(this); //Parse objects last!
 
                _texList.Sort();
                _pltList.Sort();
 
                if (_matGroup != null)
                {
                    foreach (MDL0MaterialNode m in _matGroup.Children)
                    {
                        if (m.IsMetal && m.Children != null && m.Children.Count > 0)
                        {
                            _metalMat = m.Children[m.Children.Count - 1].Name;
                            break;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _errors.Add("Something went wrong parsing the model: " + ex);
            }
            finally //Clean up!
            {
                //We'll use the linker to access the bone cache
                //_linker = null;
 
                //Don't dispose assets, in case an object is replaced
                //_assets.Dispose();
                //_assets = null;
 
                CleanGroups();
 
                //Check for model errors
                if (_errors.Count > 0)
                {
                    if (!SupportedVersions.Contains(_version))
                    {
                        MessageBox.Show("The model " + _name + " has a version of " + _version +
                                        " which is not supported. The model may be corrupt and data maybe be lost if you save the model.");
                    }
                    else
                    {
                        string message = _errors.Count + (_errors.Count > 1 ? " errors have" : " error has") +
                                         " been found in the model " + _name + ".\n" +
                                         (_errors.Count > 1 ? "These errors" : "This error") +
                                         " will be fixed when you save:";
                        foreach (string s in _errors)
                        {
                            message += "\n - " + s;
                        }
 
                        if (!Properties.Settings.Default.HideMDL0Errors)
                        {
                            MessageBox.Show(message);
                        }
 
                        SignalPropertyChange();
                    }
                }
            }
        }

◆ OnRebuild()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.OnRebuild	(	VoidPtr	address,
		int	length,
		bool	force
	)

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            ModelEncoder.Build(_linker, (MDL0Header*) address, length, force);
        }

◆ OnVersionChanged()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.OnVersionChanged ( int previousVersion )

inlineprotectedvirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.BRESEntryNode.

        {
            bool
                convertingDown = previousVersion > 9 && _version <= 9,
                convertingUp = previousVersion <= 9 && _version > 9;
 
            if (convertingDown)
            {
                //TODO: alert user to information that will be lost after converting down to v8 or v9,  saving and closing.
                //No need to allow cancelling the version change here, as the user can simply change the version back before saving and closing.
            }
 
            //Be sure the model is populated so that the object list is filled
            if (_children == null)
            {
                Populate(0);
            }
 
            //Version 10 and 11 objects are slighly different from 8 and 9
            if (_objList != null && (convertingDown || convertingUp))
            {
                foreach (MDL0ObjectNode o in _objList)
                {
                    o._forceRebuild = true;
                }
            }
        }

◆ PreRender()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.PreRender ( ModelPanelViewport v )

inline

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            if (_billboardBones.Count > 0)
            {
                WeightMeshes(v);
                ApplySHP(_currentSHP, _currentSHPIndex);
            }
 
            if (_matList != null)
            {
                foreach (MDL0MaterialNode m in _matList)
                {
                    foreach (MDL0MaterialRefNode mr in m.Children)
                    {
                        mr.SetEffectMatrix(_scn0, v, _scn0Frame);
                    }
                }
            }
        }

◆ Refresh()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.Refresh ( )

inline

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            if (_texList != null)
            {
                foreach (MDL0TextureNode t in _texList)
                {
                    t.Reload(this, t.Parent?.Name.EndsWith("_ExtMtl") ?? false);
                }
            }
        }

◆ RegenerateVIS0Indices()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.RegenerateVIS0Indices ( )

inline

This only needs to be called when the model is currently attached to a model renderer and the amount of objects change or an object's visibility bone changes.

        {
            int i = 0;
            VIS0Indices = new Dictionary<string, Dictionary<int, List<int>>>();
            if (_objList != null)
            {
                foreach (MDL0ObjectNode p in _objList)
                {
                    int x = 0;
                    foreach (DrawCall c in p._drawCalls)
                    {
                        if (c._visBoneNode != null && c._visBoneNode.BoneIndex != 0)
                        {
                            if (!VIS0Indices.ContainsKey(c._visBoneNode.Name))
                            {
                                VIS0Indices.Add(c._visBoneNode.Name,
                                    new Dictionary<int, List<int>> {{i, new List<int> {x}}});
                            }
                            else if (!VIS0Indices[c._visBoneNode.Name].ContainsKey(i))
                            {
                                VIS0Indices[c._visBoneNode.Name].Add(i, new List<int> {x});
                            }
                            else if (!VIS0Indices[c._visBoneNode.Name][i].Contains(x))
                            {
                                VIS0Indices[c._visBoneNode.Name][i].Add(x);
                            }
                        }
 
                        x++;
                    }
 
                    i++;
                }
            }
        }

◆ RemoveChild()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.RemoveChild ( ResourceNode child )

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            if (child is MDL0GroupNode)
            {
                UnlinkGroup(child as MDL0GroupNode);
            }
 
            base.RemoveChild(child);
        }

◆ RenderBones()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.RenderBones ( ModelPanelViewport v )

inline

Implements BrawlLib.Modeling.IModel.

        {
            GL.PushAttrib(AttribMask.AllAttribBits);
 
            GL.Enable(EnableCap.Blend);
            GL.Disable(EnableCap.Lighting);
            GL.Disable(EnableCap.DepthTest);
 
            GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
            GL.LineWidth(1.5f);
 
            if (_boneList != null)
            {
                foreach (MDL0BoneNode bone in _boneList)
                {
                    bone.Render(_isTargetModel, v);
                }
            }
 
            GL.PopAttrib();
        }

◆ RenderBoxes()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.RenderBoxes	(	bool	model,
		bool	obj,
		bool	bone,
		bool	bindState
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            if (model || obj || bone)
            {
                GL.PushAttrib(AttribMask.AllAttribBits);
 
                GL.Disable(EnableCap.Lighting);
                GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
 
                bindState = _bindFrame && bindState;
 
                if (model)
                {
                    GL.Color4(Color.Gray);
                    DrawBox(bindState);
                }
 
                if (obj && _objList != null)
                {
                    GL.Color4(Color.Purple);
                    if (_selectedObjectIndex != -1 && ((MDL0ObjectNode) _objList[_selectedObjectIndex]).IsRendering)
                    {
                        ((MDL0ObjectNode) _objList[_selectedObjectIndex]).DrawBox();
                    }
                    else
                    {
                        foreach (MDL0ObjectNode p in _objList)
                        {
                            if (p.IsRendering)
                            {
                                p.DrawBox();
                            }
                        }
                    }
                }
 
                if (bone)
                {
                    GL.Color4(Color.Orange);
                    foreach (MDL0BoneNode b in _boneList)
                    {
                        b.DrawBox(true, bindState);
                    }
                }
 
                GL.PopAttrib();
            }
        }

◆ RenderNormals()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.RenderNormals ( )

inline

Implements BrawlLib.Modeling.IModel.

        {
            if (_objList != null)
            {
                if (_selectedObjectIndex != -1)
                {
                    MDL0ObjectNode o = (MDL0ObjectNode) _objList[_selectedObjectIndex];
                    if (o.IsRendering)
                    {
                        o._manager.RenderNormals();
                    }
                }
                else
                {
                    foreach (MDL0ObjectNode p in _objList)
                    {
                        if (p.IsRendering)
                        {
                            p._manager.RenderNormals();
                        }
                    }
                }
            }
        }

◆ RenderVertices()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.RenderVertices	(	bool	depthPass,
		IBoneNode	weightTarget,
		GLCamera	camera
	)

inline

Implements BrawlLib.Modeling.IModel.

        {
            if (_objList != null)
            {
                if (_selectedObjectIndex != -1)
                {
                    MDL0ObjectNode o = (MDL0ObjectNode) _objList[_selectedObjectIndex];
                    if (o.IsRendering && o._manager != null)
                    {
                        o._manager.RenderVertices(o._matrixNode, weightTarget, depthPass, camera);
                        return;
                    }
                }
                else
                {
                    foreach (MDL0ObjectNode p in _objList)
                    {
                        if (p.IsRendering)
                        {
                            p._manager?.RenderVertices(p._matrixNode, weightTarget, depthPass, camera);
                        }
                    }
                }
            }
        }

◆ Replace()

override void BrawlLib.SSBB.ResourceNodes.MDL0Node.Replace	(	string	fileName,
		FileMapProtect	prot,
		FileOptions	options
	)

inlinevirtual

Reimplemented from BrawlLib.SSBB.ResourceNodes.ResourceNode.

        {
            MDL0Node node = FromFile(fileName, FileOptions.SequentialScan);
            if (node == null)
            {
                return;
            }
 
            //Get the original data source from the newly created model
            //and clear the reference to it so it's not disposed of
            //when the model is disposed
            DataSource m = node._uncompSource;
            node._uncompSource = DataSource.Empty;
            node._origSource = DataSource.Empty;
 
            node.Dispose();
            ReplaceRaw(m.Map);
        }

◆ ReplaceMeshes()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ReplaceMeshes	(	MDL0Node	replacement,
		bool	doSearch,
		bool	replaceIfFound,
		bool	addIfNotFound
	)

inline

        {
            if (replacement == null)
            {
                return;
            }
 
            replacement.Populate();
            replacement.ResetToBindState();
 
            // Save texture matrix settings
            Dictionary<string, bool[]> texMatrixSettings = new Dictionary<string, bool[]>();
            if (_matGroup != null && _matGroup.Children.Count > 0)
            {
                foreach (MDL0MaterialNode m in _matGroup.Children.Where(m => m.HasChildren))
                {
                    bool[] texRefSettings = new bool[m.Children.Count];
                    foreach (MDL0MaterialRefNode r in m.Children)
                    {
                        texRefSettings[r.Index] = r.HasTextureMatrix;
                    }
 
                    if (!texMatrixSettings.ContainsKey(m.Name))
                    {
                        texMatrixSettings.Add(m.Name, texRefSettings);
                    }
                }
            }
 
            bool[] addGroup = new bool[8];
            while (replacement._objList != null && replacement._objList.Count > 0)
            {
                ReplaceOrAddMeshInternal(
                    replacement._objList[0] as MDL0ObjectNode,
                    ref addGroup,
                    doSearch,
                    replaceIfFound,
                    addIfNotFound);
            }
 
            FinishReplace(addGroup);
 
            // Copy texture matrix settings from before
            if (_matGroup != null && _matGroup.Children.Count > 0)
            {
                foreach (MDL0MaterialNode m in _matGroup.Children.Where(m => m.HasChildren && texMatrixSettings.ContainsKey(m.Name)))
                {
                    if (texMatrixSettings[m.Name].Length == m.Children.Count)
                    {
                        foreach (MDL0MaterialRefNode r in m.Children)
                        {
                            r.HasTextureMatrix = texMatrixSettings[m.Name][r.Index];
                        }
                    }
                }
            }
        }

◆ ReplaceOrAddMesh()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ReplaceOrAddMesh	(	MDL0ObjectNode	replacement,
		bool	doSearch,
		bool	replaceIfFound,
		bool	addIfNotFound
	)

inline

        {
            if (replacement == null)
            {
                return;
            }
 
            MDL0Node model = replacement.Model;
            if (model != null)
            {
                model.Populate();
                model.ResetToBindState();
            }
 
            bool[] addGroup = new bool[8];
            ReplaceOrAddMeshInternal(
                replacement,
                ref addGroup,
                doSearch,
                replaceIfFound,
                addIfNotFound);
 
            FinishReplace(addGroup);
        }

◆ ResetToBindState()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.ResetToBindState ( )

inline

Implements BrawlLib.Modeling.IModel.

        {
            ApplyCHR(null, 0);
            ApplySRT(null, 0);
            ApplyVIS(null, 0);
            ApplyPAT(null, 0);
            ApplyCLR(null, 0);
            ApplySCN(null, 0);
        }

◆ StripModel()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.StripModel ( )

inline

        {
            Populate();
            while (_objGroup != null && _objGroup.HasChildren)
            {
                ((MDL0ObjectNode) _objGroup.Children[0]).Remove(true);
            }
 
            while (_matGroup != null && _matGroup.HasChildren)
            {
                ((MDL0MaterialNode) _matGroup.Children[0]).Remove(true);
            }
 
            while (_shadGroup != null && _shadGroup.HasChildren)
            {
                _shadGroup.Children[0].Remove();
            }
 
            while (_uvGroup != null && _uvGroup.HasChildren)
            {
                _uvGroup.Children[0].Remove();
            }
 
            while (_normGroup != null && _normGroup.HasChildren)
            {
                _normGroup.Children[0].Remove();
            }
 
            while (_vertGroup != null && _vertGroup.HasChildren)
            {
                _vertGroup.Children[0].Remove();
            }
 
            while (_colorGroup != null && _colorGroup.HasChildren)
            {
                _colorGroup.Children[0].Remove();
            }
 
            while (_pltGroup != null && _pltGroup.HasChildren)
            {
                _pltGroup.Children[0].Remove();
            }
        }

◆ UnlinkGroup()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.UnlinkGroup ( MDL0GroupNode group )

inline

        {
            if (group != null)
            {
                switch (group._type)
                {
                    case MDLResourceType.Definitions:
                    {
                        _defGroup = null;
                        _defList = null;
                        break;
                    }
 
                    case MDLResourceType.Bones:
                    {
                        _boneGroup = null;
                        _boneList = null;
                        break;
                    }
 
                    case MDLResourceType.Materials:
                    {
                        _matGroup = null;
                        _matList = null;
                        break;
                    }
 
                    case MDLResourceType.Shaders:
                    {
                        _shadGroup = null;
                        _shadList = null;
                        break;
                    }
 
                    case MDLResourceType.Vertices:
                    {
                        _vertGroup = null;
                        _vertList = null;
                        break;
                    }
 
                    case MDLResourceType.Normals:
                    {
                        _normGroup = null;
                        _normList = null;
                        break;
                    }
 
                    case MDLResourceType.UVs:
                    {
                        _uvGroup = null;
                        _uvList = null;
                        break;
                    }
 
                    case MDLResourceType.Colors:
                    {
                        _colorGroup = null;
                        _colorList = null;
                        break;
                    }
 
                    case MDLResourceType.Objects:
                    {
                        _objGroup = null;
                        _objList = null;
                        break;
                    }
 
                    case MDLResourceType.Textures:
                    {
                        _texGroup = null;
                        _texList = null;
                        break;
                    }
 
                    case MDLResourceType.Palettes:
                    {
                        _pltGroup = null;
                        _pltList = null;
                        break;
                    }
 
                    case MDLResourceType.FurLayerCoords:
                    {
                        _furPosGroup = null;
                        _furPosList = null;
                        break;
                    }
 
                    case MDLResourceType.FurVectors:
                    {
                        _furVecGroup = null;
                        _furVecList = null;
                        break;
                    }
                }
            }
        }

◆ WeightMeshes()

void BrawlLib.SSBB.ResourceNodes.MDL0Node.WeightMeshes ( ModelPanelViewport v = null )

inline

        {
            //Multiply matrices
            if (_boneList != null)
            {
                foreach (MDL0BoneNode b in _boneList)
                {
                    b.RecalcFrameState(v);
                }
            }
 
            foreach (Influence inf in _influences._influences)
            {
                inf.CalcMatrix();
            }
 
            //Weight vertices and normals
            if (!_dontUpdateMesh && _objList != null)
            {
                foreach (MDL0ObjectNode poly in _objList)
                {
                    poly.Weight();
                }
            }
        }

Member Data Documentation

◆ _assets

AssetStorage BrawlLib.SSBB.ResourceNodes.MDL0Node._assets

◆ _autoMetal

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._autoMetal

◆ _billboardBones

List<MDL0BoneNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._billboardBones = new List<MDL0BoneNode>()

◆ _boneGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._boneGroup

◆ _boneList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._boneList

◆ _colorGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._colorGroup

◆ _colorList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._colorList

◆ _defGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._defGroup

◆ _defList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._defList

◆ _dontUpdateMesh

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._dontUpdateMesh = false

◆ _enableExtents

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._enableExtents

◆ _envMtxMode

byte BrawlLib.SSBB.ResourceNodes.MDL0Node._envMtxMode

◆ _errors

List<string> BrawlLib.SSBB.ResourceNodes.MDL0Node._errors = new List<string>()

◆ _extents

Box BrawlLib.SSBB.ResourceNodes.MDL0Node._extents

◆ _furPosGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._furPosGroup

◆ _furPosList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._furPosList

◆ _furVecGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._furVecGroup

◆ _furVecList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._furVecList

◆ _hasMix

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._hasMix

◆ _hasOpa

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._hasOpa

◆ _hasTree

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._hasTree

◆ _hasXlu

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._hasXlu

◆ _ignoreModelViewerAttribs

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._ignoreModelViewerAttribs = false

◆ _influences

InfluenceManager BrawlLib.SSBB.ResourceNodes.MDL0Node._influences = new InfluenceManager()

◆ _isImport

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._isImport

◆ _linker

ModelLinker BrawlLib.SSBB.ResourceNodes.MDL0Node._linker

◆ _matGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._matGroup

◆ _matList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._matList

◆ _matrixOffset

Matrix? BrawlLib.SSBB.ResourceNodes.MDL0Node._matrixOffset = null

◆ _metalMat

string BrawlLib.SSBB.ResourceNodes.MDL0Node._metalMat

◆ _needsNrmMtxArray

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._needsNrmMtxArray

◆ _needsTexMtxArray

bool BrawlLib.SSBB.ResourceNodes.MDL0Node._needsTexMtxArray

◆ _normGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._normGroup

◆ _normList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._normList

◆ _numFacepoints

int BrawlLib.SSBB.ResourceNodes.MDL0Node._numFacepoints

◆ _numNodes

int BrawlLib.SSBB.ResourceNodes.MDL0Node._numNodes

◆ _numTriangles

int BrawlLib.SSBB.ResourceNodes.MDL0Node._numTriangles

◆ _objGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._objGroup

◆ _objList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._objList

◆ _pltGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._pltGroup

◆ _pltList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._pltList

◆ _renderAttribs

ModelRenderAttributes BrawlLib.SSBB.ResourceNodes.MDL0Node._renderAttribs = new ModelRenderAttributes()

◆ _selectedObjectIndex

int BrawlLib.SSBB.ResourceNodes.MDL0Node._selectedObjectIndex = -1

◆ _shadGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._shadGroup

◆ _shadList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._shadList

◆ _texGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._texGroup

◆ _texList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._texList

◆ _uvGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._uvGroup

◆ _uvList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._uvList

◆ _vertGroup

MDL0GroupNode BrawlLib.SSBB.ResourceNodes.MDL0Node._vertGroup

◆ _vertList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node._vertList

◆ MultiTypeWorks

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.MultiTypeWorks = false

static

◆ VIS0Indices

Dictionary<string, Dictionary<int, List<int> > > BrawlLib.SSBB.ResourceNodes.MDL0Node.VIS0Indices

Property Documentation

◆ AllBones

List<MDL0BoneNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.AllBones

get

        {
            get
            {
                List<MDL0BoneNode> bones = new List<MDL0BoneNode>();
                if (BoneGroup != null)
                {
                    foreach (ResourceNode r in BoneGroup.GetChildrenRecursive())
                    {
                        if (r is MDL0BoneNode b)
                        {
                            bones.Add(b);
                        }
                    }
 
                    bones = bones.OrderBy(o => o.BoneIndex).ToList();
                }
 
                return bones;
            }
        }

◆ Attached

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.Attached

get

Implements BrawlLib.OpenGL.IRenderedObject.

◆ AutoMetalMaterials

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.AutoMetalMaterials

getset

        {
            get => _autoMetal;
            set
            {
                _autoMetal = value;
                GenerateMetalMaterials(_metalMat);
            }
        }

◆ BoneCache

IBoneNode [] BrawlLib.SSBB.ResourceNodes.MDL0Node.BoneCache

get

Implements BrawlLib.Modeling.IModel.

        {
            get
            {
                if (_linker?.BoneCache != null)
                {
                    return _linker.BoneCache.Select(x => x as IBoneNode).ToArray();
                }
 
                return new IBoneNode[0];
            }
        }

◆ BoneGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.BoneGroup

get

◆ BoneList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.BoneList

get

◆ BoxMax

Vector3 BrawlLib.SSBB.ResourceNodes.MDL0Node.BoxMax

getset

        {
            get => _extents.Max;
            set
            {
                _extents.Max = value;
                SignalPropertyChange();
            }
        }

◆ BoxMin

Vector3 BrawlLib.SSBB.ResourceNodes.MDL0Node.BoxMin

getset

        {
            get => _extents.Min;
            set
            {
                _extents.Min = value;
                SignalPropertyChange();
            }
        }

◆ ColorGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.ColorGroup

get

◆ ColorList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.ColorList

get

◆ DataAlign

override int BrawlLib.SSBB.ResourceNodes.MDL0Node.DataAlign

get

◆ DefinitionsGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.DefinitionsGroup

get

◆ DefinitionsList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.DefinitionsList

get

◆ DrawCalls

List<DrawCallBase> BrawlLib.SSBB.ResourceNodes.MDL0Node.DrawCalls

get

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            get
            {
                Populate();
                return _objList == null
                    ? new List<DrawCallBase>()
                    : _objList.SelectMany(x => ((MDL0ObjectNode) x).DrawCalls).ToList();
            }
        }

◆ EnableBoundingBox

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.EnableBoundingBox

getset

        {
            get => _enableExtents;
            set
            {
                _enableExtents = value;
                SignalPropertyChange();
            }
        }

◆ EnvelopeMatrixMode

MDLEnvelopeMatrixMode BrawlLib.SSBB.ResourceNodes.MDL0Node.EnvelopeMatrixMode

getset

        {
            get => (MDLEnvelopeMatrixMode) _envMtxMode;
            set
            {
                _envMtxMode = (byte) value;
                SignalPropertyChange();
            }
        }

◆ FurPosGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FurPosGroup

get

◆ FurPosList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.FurPosList

get

◆ FurVecGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.FurVecGroup

get

◆ FurVecList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.FurVecList

get

◆ Influences

InfluenceManager BrawlLib.SSBB.ResourceNodes.MDL0Node.Influences

get

Implements BrawlLib.Modeling.IModel.

◆ IsRendering

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.IsRendering

getset

Implements BrawlLib.OpenGL.IRenderedObject.

        {
            get => DrawCalls.Where(x => x._render).Count() > 0;
            set
            {
                foreach (DrawCallBase b in DrawCalls)
                {
                    b._render = value;
                }
            }
        }

◆ IsStagePosition

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.IsStagePosition

get

◆ IsTargetModel

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.IsTargetModel

getset

Implements BrawlLib.Modeling.IModel.

        {
            get => _isTargetModel;
            set => _isTargetModel = value;
        }

◆ MaterialGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.MaterialGroup

get

◆ MaterialList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.MaterialList

get

◆ MetalTexture

string BrawlLib.SSBB.ResourceNodes.MDL0Node.MetalTexture

getset

        {
            get => _metalMat;
            set
            {
                if (_matList != null)
                {
                    foreach (MDL0MaterialNode m in _matList)
                    {
                        if (m.IsMetal)
                        {
                            foreach (MDL0MaterialRefNode mr in m.Children)
                            {
                                if (mr.Name == _metalMat)
                                {
                                    mr.Name = value;
                                }
                            }
                        }
                    }
                }
 
                _metalMat = value;
            }
        }

◆ NeedsNormalMtxArray

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.NeedsNormalMtxArray

get

◆ NeedsTextureMtxArray

bool BrawlLib.SSBB.ResourceNodes.MDL0Node.NeedsTextureMtxArray

get

◆ NormalGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.NormalGroup

get

◆ NormalList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.NormalList

get

◆ NumFacepoints

int BrawlLib.SSBB.ResourceNodes.MDL0Node.NumFacepoints

get

        {
            get
            {
                if (_objList == null)
                {
                    return 0;
                }
 
                int i = 0;
                foreach (MDL0ObjectNode n in _objList)
                {
                    i += n._numFacepoints;
                }
 
                return i;
            }
        }

◆ NumNodes

int BrawlLib.SSBB.ResourceNodes.MDL0Node.NumNodes

get

◆ NumTriangles

int BrawlLib.SSBB.ResourceNodes.MDL0Node.NumTriangles

get

        {
            get
            {
                if (_objList == null)
                {
                    return 0;
                }
 
                int i = 0;
                foreach (MDL0ObjectNode n in _objList)
                {
                    i += n._numFaces;
                }
 
                return i;
            }
        }

◆ NumVertices

int BrawlLib.SSBB.ResourceNodes.MDL0Node.NumVertices

get

        {
            get
            {
                if (_objList == null)
                {
                    return 0;
                }
 
                int i = 0;
                foreach (MDL0ObjectNode n in _objList)
                {
                    i += n.VertexCount;
                }
 
                return i;
            }
        }

◆ Objects

IObject [] BrawlLib.SSBB.ResourceNodes.MDL0Node.Objects

get

Implements BrawlLib.Modeling.IModel.

◆ PaletteGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.PaletteGroup

get

◆ PaletteList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.PaletteList

get

◆ PolygonGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.PolygonGroup

get

◆ PolygonList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.PolygonList

get

◆ ResourceFileType

override ResourceType BrawlLib.SSBB.ResourceNodes.MDL0Node.ResourceFileType

get

◆ RootBones

IBoneNode [] BrawlLib.SSBB.ResourceNodes.MDL0Node.RootBones

get

Implements BrawlLib.Modeling.IModel.

◆ ScalingRule

MDLScalingRule BrawlLib.SSBB.ResourceNodes.MDL0Node.ScalingRule

getset

        {
            get => (MDLScalingRule) _scalingRule;
            set
            {
                _scalingRule = (int) value;
                SignalPropertyChange();
            }
        }

◆ SelectedObjectIndex

int BrawlLib.SSBB.ResourceNodes.MDL0Node.SelectedObjectIndex

getset

Implements BrawlLib.Modeling.IModel.

        {
            get => _selectedObjectIndex;
            set => _selectedObjectIndex = value;
        }

◆ ShaderGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.ShaderGroup

get

◆ ShaderList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.ShaderList

get

◆ SupportedVersions

override int [] BrawlLib.SSBB.ResourceNodes.MDL0Node.SupportedVersions

get

◆ Tag

override string BrawlLib.SSBB.ResourceNodes.MDL0Node.Tag

get

◆ TextureGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.TextureGroup

get

◆ TextureList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.TextureList

get

◆ TextureMatrixMode

TexMatrixMode BrawlLib.SSBB.ResourceNodes.MDL0Node.TextureMatrixMode

getset

        {
            get => (TexMatrixMode) _texMtxMode;
            set
            {
                _texMtxMode = (int) value;
                SignalPropertyChange();
            }
        }

◆ UVGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.UVGroup

get

◆ UVList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.UVList

get

◆ VertexGroup

ResourceNode BrawlLib.SSBB.ResourceNodes.MDL0Node.VertexGroup

get

◆ VertexList

List<ResourceNode> BrawlLib.SSBB.ResourceNodes.MDL0Node.VertexList

get

Event Documentation

◆ DrawCallsChanged

EventHandler BrawlLib.SSBB.ResourceNodes.MDL0Node.DrawCallsChanged

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

BrawlLib/SSBB/ResourceNodes/MDL0/MDL0Node.cs

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Properties

Events

Constructor & Destructor Documentation

◆ MDL0Node()

Member Function Documentation

◆ AddChild()

◆ ApplyCHR()

◆ ApplyCLR()

◆ ApplyPAT()

◆ ApplySCN()

◆ ApplySHP()

◆ ApplySRT()

◆ ApplyVIS()

◆ Attach()

◆ BeginImport()

◆ CalculateBoundingBoxes()

◆ CheckTextures()

◆ CleanTextures()

◆ ConvertToShadowModel()

◆ ConvertToSpyModel()

◆ ConvertToSpyModelMultiType()

◆ Detach()

◆ DrawBox()

◆ Export()

◆ FindBone()

◆ FindBoneByIndex()

◆ FindOrCreateOpaMaterial()

◆ FindOrCreatePalette()

◆ FindOrCreateTexture()

◆ FindOrCreateXluMaterial()

◆ FinishImport()

◆ FromFile()

◆ GenerateMetalMaterials() [1/2]

◆ GenerateMetalMaterials() [2/2]

◆ GetBox()

◆ GetUsedShaders()

◆ LinkGroup()

◆ OnCalculateSize()

◆ OnDrawCallsChanged()

◆ OnInitialize()

◆ OnPopulate()

◆ OnRebuild()

◆ OnVersionChanged()

◆ PreRender()

◆ Refresh()

◆ RegenerateVIS0Indices()

◆ RemoveChild()

◆ RenderBones()

◆ RenderBoxes()

◆ RenderNormals()

◆ RenderVertices()

◆ Replace()

◆ ReplaceMeshes()

◆ ReplaceOrAddMesh()

◆ ResetToBindState()

◆ StripModel()

◆ UnlinkGroup()

◆ WeightMeshes()

Member Data Documentation

◆ _assets

◆ _autoMetal

◆ _billboardBones

◆ _boneGroup

◆ _boneList

◆ _colorGroup

◆ _colorList

◆ _defGroup

◆ _defList

◆ _dontUpdateMesh

◆ _enableExtents

◆ _envMtxMode

◆ _errors

◆ _extents

◆ _furPosGroup

◆ _furPosList