BrawlLib.Wii.Models.Influence Class Reference

Inheritance diagram for BrawlLib.Wii.Models.Influence:

Public Member Functions
override string	ToString ()
void	AddWeight (BoneWeight weight)
void	RemoveWeight (BoneWeight weight)
void	SetWeights (List< BoneWeight > newWeights)
void	Normalize ()
Influence	Clone ()
	Influence ()
	Influence (List< BoneWeight > weights)
	Influence (IBoneNode bone)
void	CalcMatrix ()
override int	GetHashCode ()
override bool	Equals (object obj)
bool	Equals (Influence inf)

Static Public Member Functions
static int	Compare (Influence i1, Influence i2)
static bool	operator== (Influence i1, Influence i2)
static bool	operator!= (Influence i1, Influence i2)

Properties
List< BoneWeight >	Weights [get]
	Don't modify this array! More...
List< IMatrixNodeUser >	Users [get, set]
int	NodeIndex [get]
Matrix	Matrix [get]
Matrix	InverseMatrix [get]
bool	IsPrimaryNode [get]
bool	IsWeighted [get]
IBoneNode	Bone [get]
Properties inherited from BrawlLib.Modeling.IMatrixNode
List< IMatrixNodeUser >	Users [get, set]
int	NodeIndex [get]
Matrix	Matrix [get]
Matrix	InverseMatrix [get]
bool	IsPrimaryNode [get]
List< BoneWeight >	Weights [get]

Constructor & Destructor Documentation

Influence() [1/3]

BrawlLib.Wii.Models.Influence.Influence ( )

inline

        {
            _weights = new List<BoneWeight>();
        }

Influence() [2/3]

BrawlLib.Wii.Models.Influence.Influence ( List< BoneWeight >  weights )

inline

        {
            _weights = weights;
            foreach (BoneWeight b in _weights)
            {
                if (b.Bone != null && !b.Bone.LinkedInfluences.Contains(this))
                {
                    b.Bone.LinkedInfluences.Add(this);
                }
            }
        }

Influence() [3/3]

BrawlLib.Wii.Models.Influence.Influence ( IBoneNode  bone )

inline

        {
            _weights = new List<BoneWeight> {new BoneWeight(bone)};
            if (!bone.LinkedInfluences.Contains(this))
            {
                bone.LinkedInfluences.Add(this);
            }
        }

Member Function Documentation

AddWeight()

void BrawlLib.Wii.Models.Influence.AddWeight ( BoneWeight  weight )

inline

        {
            _weights.Add(weight);
            if (weight.Bone != null && !weight.Bone.LinkedInfluences.Contains(this))
            {
                weight.Bone.LinkedInfluences.Add(this);
            }
        }

CalcMatrix()

void BrawlLib.Wii.Models.Influence.CalcMatrix ( )

inline

        {
            if (IsWeighted)
            {
                _matrix = Matrix.InfluenceMatrix(_weights);
                _invMatrix = Matrix.ReverseInfluenceMatrix(_weights);
            }
            else if (_weights.Count == 1 && Bone != null)
            {
                _matrix = Bone.Matrix;
                _invMatrix = Bone.InverseMatrix;
            }
            else
            {
                _invMatrix = _matrix = Matrix.Identity;
            }
        }

Clone()

Influence BrawlLib.Wii.Models.Influence.Clone ( )

inline

        {
            Influence i = new Influence();
            foreach (BoneWeight b in _weights)
            {
                i.AddWeight(new BoneWeight(b.Bone, b.Weight) {Locked = b.Locked});
            }
 
            return i;
        }

Compare()

static int BrawlLib.Wii.Models.Influence.Compare ( Influence  i1, Influence  i2  )

inlinestatic

        {
            if (i1._weights.Count < i2._weights.Count)
            {
                return -1;
            }
 
            if (i1._weights.Count > i2._weights.Count)
            {
                return 1;
            }
 
            if (i1.Users.Count > i2.Users.Count)
            {
                return -1;
            }
 
            if (i1.Users.Count < i2.Users.Count)
            {
                return 1;
            }
 
            return 0;
        }

Equals() [1/2]

bool BrawlLib.Wii.Models.Influence.Equals ( Influence  inf )

inline

        {
            bool found;
 
            if (ReferenceEquals(this, inf))
            {
                return true;
            }
 
            if (ReferenceEquals(inf, null))
            {
                return false;
            }
 
            if (_weights.Count != inf._weights.Count)
            {
                return false;
            }
 
            foreach (BoneWeight w1 in _weights)
            {
                found = false;
                foreach (BoneWeight w2 in inf._weights)
                {
                    if (w1 == w2)
                    {
                        found = true;
                        break;
                    }
                }
 
                if (!found)
                {
                    return false;
                }
            }
 
            return true;
        }

Equals() [2/2]

override bool BrawlLib.Wii.Models.Influence.Equals ( object  obj )

inline

        {
            if (obj is Influence)
            {
                return Equals(obj as Influence);
            }
 
            return false;
        }

GetHashCode()

override int BrawlLib.Wii.Models.Influence.GetHashCode ( )

inline

        {
            return base.GetHashCode();
        }

Normalize()

void BrawlLib.Wii.Models.Influence.Normalize ( )

inline

        {
            //Denominator and numerator to convert each unlocked weight with
            float denom = 0.0f, num = 1.0f;
 
            foreach (BoneWeight b in Weights)
            {
                if (b.Locked)
                {
                    num -= b.Weight;
                }
                else
                {
                    denom += b.Weight;
                }
            }
 
            //Don't do anything if all weights are locked
            if (denom != 0.0f && num != 0.0f)
            {
                foreach (BoneWeight b in Weights)
                {
                    if (!b.Locked) //Only normalize unlocked weights used in the calculation
                    {
                        b.Weight = (float) Math.Round(b.Weight / denom * num, 7);
                    }
                }
            }
        }

operator!=()

static bool BrawlLib.Wii.Models.Influence.operator!= ( Influence  i1, Influence  i2  )

inlinestatic

        {
            return !i1.Equals(i2);
        }

operator==()

static bool BrawlLib.Wii.Models.Influence.operator== ( Influence  i1, Influence  i2  )

inlinestatic

        {
            return i1.Equals(i2);
        }

RemoveWeight()

void BrawlLib.Wii.Models.Influence.RemoveWeight ( BoneWeight  weight )

inline

        {
            if (_weights.Contains(weight))
            {
                _weights.Remove(weight);
                if (weight.Bone != null && weight.Bone.LinkedInfluences.Contains(this))
                {
                    weight.Bone.LinkedInfluences.Remove(this);
                }
            }
        }

SetWeights()

void BrawlLib.Wii.Models.Influence.SetWeights ( List< BoneWeight >  newWeights )

inline

        {
            foreach (BoneWeight b in _weights)
            {
                if (b.Bone != null && b.Bone.LinkedInfluences.Contains(this))
                {
                    b.Bone.LinkedInfluences.Remove(this);
                }
            }
 
            _weights = newWeights;
            foreach (BoneWeight b in _weights)
            {
                if (b.Bone != null && !b.Bone.LinkedInfluences.Contains(this))
                {
                    b.Bone.LinkedInfluences.Add(this);
                }
            }
        }

ToString()

override string BrawlLib.Wii.Models.Influence.ToString ( )

inline

        {
            return "";
        }

Property Documentation

Bone

IBoneNode BrawlLib.Wii.Models.Influence.Bone

get

InverseMatrix

Matrix BrawlLib.Wii.Models.Influence.InverseMatrix

get

Implements BrawlLib.Modeling.IMatrixNode.

        {
            get
            {
                if (_invMatrix == null)
                {
                    try
                    {
                        _invMatrix = Matrix.Invert(_matrix);
                    }
                    catch
                    {
                        _invMatrix = Matrix.Identity;
                    }
                }
 
                return (Matrix) _invMatrix;
            }
        }

IsPrimaryNode

bool BrawlLib.Wii.Models.Influence.IsPrimaryNode

get

Implements BrawlLib.Modeling.IMatrixNode.

IsWeighted

bool BrawlLib.Wii.Models.Influence.IsWeighted

get

Matrix

Matrix BrawlLib.Wii.Models.Influence.Matrix

get

Implements BrawlLib.Modeling.IMatrixNode.

NodeIndex

int BrawlLib.Wii.Models.Influence.NodeIndex

get

Implements BrawlLib.Modeling.IMatrixNode.

Users

List<IMatrixNodeUser> BrawlLib.Wii.Models.Influence.Users

getset

Implements BrawlLib.Modeling.IMatrixNode.

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

Weights

List<BoneWeight> BrawlLib.Wii.Models.Influence.Weights

get

Don't modify this array!

Implements BrawlLib.Modeling.IMatrixNode.

---

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

• BrawlLib/Wii/Models/InfluenceManager.cs