BrawlLib.Modeling.Vertex3 Class Reference

Inheritance diagram for BrawlLib.Modeling.Vertex3:

Public Member Functions
IMatrixNode	GetMatrixNode ()
Matrix	GetMatrix ()
Matrix	GetInvMatrix ()
List< BoneWeight >	GetBoneWeights ()
IBoneNode[]	GetBones ()
float[]	GetWeightValues ()
int	IndexOfBone (IBoneNode b)
BoneWeight	WeightForBone (IBoneNode b)
void	ChangeInfluence (IMatrixNode newMatrixNode)
void	DeferUpdateAssets ()
	Vertex3 ()
	Vertex3 (Vector3 position)
	Vertex3 (Vector3 position, IMatrixNode influence)
void	Weight ()
void	Unweight (bool updateVertexSets=true)
void	SetPosition (MDL0VertexNode node, Vector3 pos)
void	SetPosition ()
void	Morph (Vector3 dest, float percent)
Color	GetWeightColor (IBoneNode targetBone)
bool	Equals (Vertex3 v)
void	DeferUpdateAssets ()

Public Attributes
Vector3	_position
Vector3	_weightedPosition
List< int >	FaceDataIndices = new List<int>()
List< Facepoint >	Facepoints = new List<Facepoint>()
Color	HighlightColor = Color.Transparent

Properties
IMatrixNodeUser	Parent [get, set]
string	Influence [get]
IMatrixNode	MatrixNode [get, set]
Vector3	WeightedPosition [get, set]
Vector3	Position [get, set]
bool	Selected [get, set]
Properties inherited from BrawlLib.SSBB.ResourceNodes.IMatrixNodeUser
IMatrixNode	MatrixNode [get, set]

Constructor & Destructor Documentation

Vertex3() [1/3]

BrawlLib.Modeling.Vertex3.Vertex3 ( )

inline

        {
        }

Vertex3() [2/3]

BrawlLib.Modeling.Vertex3.Vertex3 ( Vector3  position )

inline

        {
            Position = position;
        }

Vertex3() [3/3]

BrawlLib.Modeling.Vertex3.Vertex3 ( Vector3  position, IMatrixNode  influence  )

inline

        {
            Position = position;
            MatrixNode = influence;
        }

Member Function Documentation

ChangeInfluence()

void BrawlLib.Modeling.Vertex3.ChangeInfluence ( IMatrixNode  newMatrixNode )

inline

        {
            if (_parent == null)
            {
                return;
            }
 
            IMatrixNode oldMatrixNode = GetMatrixNode();
            if (newMatrixNode is IBoneNode && (oldMatrixNode is Influence || oldMatrixNode == null))
            {
                //Move to local
                Matrix inv = ((IBoneNode) newMatrixNode).InverseBindMatrix;
 
                _position *= inv;
                UpdateNormals(Matrix.Identity, inv);
 
                if (_updateAssets)
                {
                    SetPosition();
                    SetNormals();
                }
            }
            else if ((newMatrixNode is Influence || newMatrixNode == null) && oldMatrixNode is IBoneNode)
            {
                //Move to world
                Matrix m = ((IBoneNode) oldMatrixNode).BindMatrix;
 
                _position *= m;
                UpdateNormals(m, Matrix.Identity);
 
                if (_updateAssets)
                {
                    SetPosition();
                    SetNormals();
                }
            }
            else if (newMatrixNode is IBoneNode && oldMatrixNode is IBoneNode)
            {
                //Update local position
                Matrix m = ((IBoneNode) oldMatrixNode).BindMatrix;
                Matrix inv = ((IBoneNode) newMatrixNode).InverseBindMatrix;
 
                _position *= m;
                _position *= inv;
                UpdateNormals(m, inv);
 
                if (_updateAssets)
                {
                    SetPosition();
                    SetNormals();
                }
            }
 
            _updateAssets = true;
 
            //If both are null or an influence, they're already in world position
        }

DeferUpdateAssets()

void BrawlLib.Modeling.Vertex3.DeferUpdateAssets ( )

inline

Implements BrawlLib.SSBB.ResourceNodes.IMatrixNodeUser.

        {
            _updateAssets = false;
        }

Equals()

bool BrawlLib.Modeling.Vertex3.Equals ( Vertex3  v )

inline

        {
            if (ReferenceEquals(this, v))
            {
                return true;
            }
 
            return Position == v.Position && _matrixNode == v._matrixNode;
        }

GetBones()

IBoneNode[] BrawlLib.Modeling.Vertex3.GetBones ( )

inline

        {
            List<BoneWeight> b = GetBoneWeights();
            return b?.Select(x => x.Bone).ToArray();
        }

GetBoneWeights()

List< BoneWeight > BrawlLib.Modeling.Vertex3.GetBoneWeights ( )

inline

        {
            return MatrixNode == null ? _parent.MatrixNode.Weights : MatrixNode.Weights;
        }

GetInvMatrix()

Matrix BrawlLib.Modeling.Vertex3.GetInvMatrix ( )

inline

        {
            IMatrixNode node = GetMatrixNode();
            if (node != null)
            {
                return node.InverseMatrix;
            }
 
            return Matrix.Identity;
        }

GetMatrix()

Matrix BrawlLib.Modeling.Vertex3.GetMatrix ( )

inline

        {
            IMatrixNode node = GetMatrixNode();
            if (node != null)
            {
                return node.Matrix;
            }
 
            return Matrix.Identity;
        }

GetMatrixNode()

IMatrixNode BrawlLib.Modeling.Vertex3.GetMatrixNode ( )

inline

        {
            if (_parent?.MatrixNode != null)
            {
                return _parent.MatrixNode;
            }
 
            return MatrixNode;
        }

GetWeightColor()

Color BrawlLib.Modeling.Vertex3.GetWeightColor ( IBoneNode  targetBone )

inline

        {
            float weight = -1.0f;
            if (_matrixNode == null || targetBone == null)
            {
                return Color.Transparent;
            }
 
            if (_matrixNode is MDL0BoneNode mNode)
            {
                if (mNode == targetBone)
                {
                    weight = 1.0f;
                }
                else
                {
                    return Color.Transparent;
                }
            }
            else
            {
                foreach (BoneWeight b in ((Influence) _matrixNode).Weights)
                {
                    if (b.Bone == targetBone)
                    {
                        weight = b.Weight;
                        break;
                    }
                }
            }
 
            if (weight < 0.0f || weight > 1.0f)
            {
                return Color.Transparent;
            }
 
            int r = ((int) (weight * 255.0f)).Clamp(0, 0xFF);
            return Color.FromArgb(r, 0, 0xFF - r);
        }

GetWeightValues()

float[] BrawlLib.Modeling.Vertex3.GetWeightValues ( )

inline

        {
            List<BoneWeight> b = GetBoneWeights();
            return b?.Select(x => x.Weight).ToArray();
        }

IndexOfBone()

int BrawlLib.Modeling.Vertex3.IndexOfBone ( IBoneNode  b )

inline

        {
            return Array.IndexOf(GetBones(), b);
        }

Morph()

void BrawlLib.Modeling.Vertex3.Morph ( Vector3  dest, float  percent  )

inline

        {
            _weightedPosition.Lerp(dest, percent);
        }

SetPosition() [1/2]

void BrawlLib.Modeling.Vertex3.SetPosition ( )

inline

        {
            MDL0VertexNode node = ((MDL0ObjectNode) _parent)?._vertexNode;
 
            if (node == null || Facepoints.Count < 1 || node.Vertices.Length <= Facepoints[0]._vertexIndex)
            {
                return;
            }
 
            node.Vertices[Facepoints[0]._vertexIndex] = Position;
            node.ForceRebuild = true;
            if (node.Format == WiiVertexComponentType.Float)
            {
                node.ForceFloat = true;
            }
        }

SetPosition() [2/2]

void BrawlLib.Modeling.Vertex3.SetPosition ( MDL0VertexNode  node, Vector3  pos  )

inline

        {
            //if (node == null)
            //    return;
 
            //node.Vertices[_facepoints[0]._vertexIndex] = pos;
            //node.ForceRebuild = true;
            //if (node.Format == WiiVertexComponentType.Float)
            //    node.ForceFloat = true;
 
            //Have to use this function instead of setting the vertices directly
            //This is because the vertex set may be used by other objects
            MDL0ObjectNode obj = _parent as MDL0ObjectNode;
            obj?.SetEditedVertices();
        }

Unweight()

void BrawlLib.Modeling.Vertex3.Unweight ( bool  updateVertexSets = true )

inline

        {
            //Unweight overall position
            _position = GetInvMatrix() * WeightedPosition;
 
            //Distribute weights for the position across all vertex set influences
            if (updateVertexSets)
            {
                if (_weights != null && _nodes != null)
                {
                    Vector3 trans = _weightedPosition - _bCenter;
                    for (int i = 0; i < _nodes.Length; i++)
                    {
                        MDL0VertexNode set = _nodes[i];
                        SetPosition(set,
                            GetInvMatrix() * (GetMatrix() * set.Vertices[Facepoints[0]._vertexIndex] + trans));
                    }
 
                    MDL0ObjectNode obj = (MDL0ObjectNode) _parent;
                    SetPosition(obj._vertexNode,
                        GetInvMatrix() * (GetMatrix() * obj._vertexNode.Vertices[Facepoints[0]._vertexIndex] + trans));
                }
                else
                {
                    SetPosition();
                }
            }
        }

Weight()

void BrawlLib.Modeling.Vertex3.Weight ( )

inline

        {
            _weightedPosition = GetMatrix() * Position;
 
            _weights = null;
            _nodes = null;
        }

WeightForBone()

BoneWeight BrawlLib.Modeling.Vertex3.WeightForBone ( IBoneNode  b )

inline

        {
            int i = IndexOfBone(b);
            if (i == -1)
            {
                return null;
            }
 
            return GetBoneWeights()[i];
        }

Member Data Documentation

_position

Vector3 BrawlLib.Modeling.Vertex3._position

_weightedPosition

Vector3 BrawlLib.Modeling.Vertex3._weightedPosition

FaceDataIndices

List<int> BrawlLib.Modeling.Vertex3.FaceDataIndices = new List<int>()

Facepoints

List<Facepoint> BrawlLib.Modeling.Vertex3.Facepoints = new List<Facepoint>()

HighlightColor

Color BrawlLib.Modeling.Vertex3.HighlightColor = Color.Transparent

Property Documentation

Influence

string BrawlLib.Modeling.Vertex3.Influence

get

MatrixNode

IMatrixNode BrawlLib.Modeling.Vertex3.MatrixNode

getset

Implements BrawlLib.SSBB.ResourceNodes.IMatrixNodeUser.

        {
            get => _matrixNode;
            set
            {
                if (_matrixNode == value)
                {
                    return;
                }
 
                ChangeInfluence(value);
 
                if (_matrixNode != null && _matrixNode.Users.Contains(this))
                {
                    _matrixNode.Users.Remove(this);
                }
 
                if ((_matrixNode = value) != null && !_matrixNode.Users.Contains(this))
                {
                    _matrixNode.Users.Add(this);
                }
            }
        }

Parent

IMatrixNodeUser BrawlLib.Modeling.Vertex3.Parent

getset

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

Position

Vector3 BrawlLib.Modeling.Vertex3.Position

getset

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

Selected

bool BrawlLib.Modeling.Vertex3.Selected

getset

        {
            get => _selected;
            set
            {
                _selected = value;
                HighlightColor = _selected ? Color.Orange : Color.Transparent;
            }
        }

WeightedPosition

Vector3 BrawlLib.Modeling.Vertex3.WeightedPosition

getset

        {
            get => _weightedPosition;
            set
            {
                _weightedPosition = value;
                Unweight();
            }
        }

---

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

• BrawlLib/Modeling/Vertex.cs