BrawlLib.Internal.Vector2 Struct Reference

Inheritance diagram for BrawlLib.Internal.Vector2:

Public Member Functions
	Vector2 (float x, float y)
	Vector2 (float s)
float	Dot (Vector2 v)
void	Clamp (float min, float max)
void	Min (Vector2 v)
void	Min (float f)
void	Max (Vector2 v)
void	Max (float f)
float	DistanceTo (Vector2 v)
override string	ToString ()
bool	Contained (Vector2 start, Vector2 end, float expansion)
float	TrueDistance (Vector2 p)
void	RemapToRange (float min, float max)
Vector2	RemappedToRange (float min, float max)
override int	GetHashCode ()
override bool	Equals (object obj)
int	CompareTo (object obj)

Static Public Member Functions
static Vector2	operator- (Vector2 v)
static Vector2	operator+ (Vector2 v1, Vector2 v2)
static Vector2	operator- (Vector2 v1, Vector2 v2)
static Vector2	operator- (Vector2 v1, float f)
static Vector2	operator* (Vector2 v1, Vector2 v2)
static Vector2	operator* (Vector2 v1, float s)
static Vector2	operator* (float s, Vector2 v1)
static Vector2	operator/ (Vector2 v1, Vector2 v2)
static Vector2	operator/ (Vector2 v1, float s)
static Vector2	operator+ (Vector2 v1, Vector3 v2)
static Vector2	operator+ (Vector3 v1, Vector2 v2)
static bool	operator== (Vector2 v1, Vector2 v2)
static bool	operator<= (Vector2 v1, Vector2 v2)
static bool	operator>= (Vector2 v1, Vector2 v2)
static bool	operator!= (Vector2 v1, Vector2 v2)
static float	Dot (Vector2 v1, Vector2 v2)
static Vector2	Clamp (Vector2 v1, float min, float max)
static Vector2	Min (Vector2 v1, Vector2 v2)
static Vector2	Min (Vector2 v1, float f)
static Vector2	Max (Vector2 v1, Vector2 v2)
static Vector2	Max (Vector2 v1, float f)
static Vector2	Lerp (Vector2 v1, Vector2 v2, float median)
static	operator Vector2 (Vector3 v)
static	operator Vector3 (Vector2 v)
static	operator PointF (Vector2 v)
static	operator Vector2 (PointF v)
static	operator Point (Vector2 v)
static	operator Vector2 (Point v)
static Vector2	Truncate (Vector2 v)
static bool	Contained (Vector2 point, Vector2 start, Vector2 end, float expansion)

Public Attributes
float	_x
float	_y

Properties
float	X [get, set]
float	Y [get, set]

Constructor & Destructor Documentation

Vector2() [1/2]

BrawlLib.Internal.Vector2.Vector2 ( float  x, float  y  )

inline

        {
            _x = x;
            _y = y;
        }

Vector2() [2/2]

BrawlLib.Internal.Vector2.Vector2 ( float  s )

inline

        {
            _x = s;
            _y = s;
        }

Member Function Documentation

Clamp() [1/2]

void BrawlLib.Internal.Vector2.Clamp ( float  min, float  max  )

inline

        {
            Max(min);
            Min(max);
        }

Clamp() [2/2]

static Vector2 BrawlLib.Internal.Vector2.Clamp ( Vector2  v1, float  min, float  max  )

inlinestatic

        {
            v1.Clamp(min, max);
            return v1;
        }

CompareTo()

int BrawlLib.Internal.Vector2.CompareTo ( object  obj )

inline

        {
            if (obj is Vector2)
            {
                Vector2 o = (Vector2) obj;
                if (_x > o._x)
                {
                    return 1;
                }
 
                if (_x < o._x)
                {
                    return -1;
                }
 
                if (_y > o._y)
                {
                    return 1;
                }
 
                if (_y < o._y)
                {
                    return -1;
                }
 
                return 0;
            }
 
            return 1;
        }

Contained() [1/2]

static bool BrawlLib.Internal.Vector2.Contained ( Vector2  point, Vector2  start, Vector2  end, float  expansion  )

inlinestatic

        {
            float* sPtr = (float*) &point;
            float* s1 = (float*) &start, s2 = (float*) &end;
            float* temp;
            for (int i = 0; i < 2; i++)
            {
                if (s1[i] > s2[i])
                {
                    temp = s1;
                    s1 = s2;
                    s2 = temp;
                }
 
                if (sPtr[i] < s1[i] - expansion || sPtr[i] > s2[i] + expansion)
                {
                    return false;
                }
            }
 
            return true;
        }

Contained() [2/2]

bool BrawlLib.Internal.Vector2.Contained ( Vector2  start, Vector2  end, float  expansion  )

inline

        {
            return Contained(this, start, end, expansion);
        }

DistanceTo()

float BrawlLib.Internal.Vector2.DistanceTo ( Vector2  v )

inline

        {
            Vector2 v1 = this - v;
            return Dot(v1, v1);
        }

Dot() [1/2]

float BrawlLib.Internal.Vector2.Dot ( Vector2  v )

inline

        {
            return _x * v._x + _y * v._y;
        }

Dot() [2/2]

static float BrawlLib.Internal.Vector2.Dot ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return v1._x * v2._x + v1._y * v2._y;
        }

Equals()

override bool BrawlLib.Internal.Vector2.Equals ( object  obj )

inline

        {
            if (obj is Vector2 vector2)
            {
                return this == vector2;
            }
 
            return false;
        }

GetHashCode()

override int BrawlLib.Internal.Vector2.GetHashCode ( )

inline

        {
            fixed (Vector2* p = &this)
            {
                int* p2 = (int*) p;
                return p2[0] ^ p2[1];
            }
        }

Lerp()

static Vector2 BrawlLib.Internal.Vector2.Lerp ( Vector2  v1, Vector2  v2, float  median  )

inlinestatic

        {
            return v1 * median + v2 * (1.0f - median);
        }

Max() [1/4]

void BrawlLib.Internal.Vector2.Max ( float  f )

inline

        {
            _x = Math.Max(_x, f);
            _y = Math.Max(_y, f);
        }

Max() [2/4]

void BrawlLib.Internal.Vector2.Max ( Vector2  v )

inline

        {
            if (_x < v._x)
            {
                _x = v._x;
            }
 
            if (_y < v._y)
            {
                _y = v._y;
            }
        }

Max() [3/4]

static Vector2 BrawlLib.Internal.Vector2.Max ( Vector2  v1, float  f  )

inlinestatic

        {
            return new Vector2(Math.Max(v1._x, f), Math.Max(v1._y, f));
        }

Max() [4/4]

static Vector2 BrawlLib.Internal.Vector2.Max ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(Math.Max(v1._x, v2._x), Math.Max(v1._y, v2._y));
        }

Min() [1/4]

void BrawlLib.Internal.Vector2.Min ( float  f )

inline

        {
            _x = Math.Min(_x, f);
            _y = Math.Min(_y, f);
        }

Min() [2/4]

void BrawlLib.Internal.Vector2.Min ( Vector2  v )

inline

        {
            if (_x > v._x)
            {
                _x = v._x;
            }
 
            if (_y > v._y)
            {
                _y = v._y;
            }
        }

Min() [3/4]

static Vector2 BrawlLib.Internal.Vector2.Min ( Vector2  v1, float  f  )

inlinestatic

        {
            return new Vector2(Math.Min(v1._x, f), Math.Min(v1._y, f));
        }

Min() [4/4]

static Vector2 BrawlLib.Internal.Vector2.Min ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(Math.Min(v1._x, v2._x), Math.Min(v1._y, v2._y));
        }

operator Point()

static BrawlLib.Internal.Vector2.operator Point ( Vector2  v )

inlineexplicitstatic

        {
            Vector2 t = Truncate(v);
            return new Point((int) t._x, (int) t._y);
        }

operator PointF()

static BrawlLib.Internal.Vector2.operator PointF ( Vector2  v )

inlineexplicitstatic

        {
            return new PointF(v._x, v._y);
        }

operator Vector2() [1/3]

static BrawlLib.Internal.Vector2.operator Vector2 ( Point  v )

inlineexplicitstatic

        {
            return new Vector2(v.X, v.Y);
        }

operator Vector2() [2/3]

static BrawlLib.Internal.Vector2.operator Vector2 ( PointF  v )

inlineexplicitstatic

        {
            return new Vector2(v.X, v.Y);
        }

operator Vector2() [3/3]

static BrawlLib.Internal.Vector2.operator Vector2 ( Vector3  v )

inlineexplicitstatic

        {
            return new Vector2(v._x, v._y);
        }

operator Vector3()

static BrawlLib.Internal.Vector2.operator Vector3 ( Vector2  v )

inlineexplicitstatic

        {
            return new Vector3(v._x, v._y, 0.0f);
        }

operator!=()

static bool BrawlLib.Internal.Vector2.operator!= ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return v1._x != v2._x || v1._y != v2._y;
        }

operator*() [1/3]

static Vector2 BrawlLib.Internal.Vector2.operator* ( float  s, Vector2  v1  )

inlinestatic

        {
            return new Vector2(v1._x * s, v1._y * s);
        }

operator*() [2/3]

static Vector2 BrawlLib.Internal.Vector2.operator* ( Vector2  v1, float  s  )

inlinestatic

        {
            return new Vector2(v1._x * s, v1._y * s);
        }

operator*() [3/3]

static Vector2 BrawlLib.Internal.Vector2.operator* ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(v1._x * v2._x, v1._y * v2._y);
        }

operator+() [1/3]

static Vector2 BrawlLib.Internal.Vector2.operator+ ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(v1._x + v2._x, v1._y + v2._y);
        }

operator+() [2/3]

static Vector2 BrawlLib.Internal.Vector2.operator+ ( Vector2  v1, Vector3  v2  )

inlinestatic

        {
            return new Vector2(v1._x + v2._x, v1._y + v2._y);
        }

operator+() [3/3]

static Vector2 BrawlLib.Internal.Vector2.operator+ ( Vector3  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(v1._x + v2._x, v1._y + v2._y);
        }

operator-() [1/3]

static Vector2 BrawlLib.Internal.Vector2.operator- ( Vector2  v )

inlinestatic

        {
            return new Vector2(-v._x, -v._y);
        }

operator-() [2/3]

static Vector2 BrawlLib.Internal.Vector2.operator- ( Vector2  v1, float  f  )

inlinestatic

        {
            return new Vector2(v1._x - f, v1._y - f);
        }

operator-() [3/3]

static Vector2 BrawlLib.Internal.Vector2.operator- ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(v1._x - v2._x, v1._y - v2._y);
        }

operator/() [1/2]

static Vector2 BrawlLib.Internal.Vector2.operator/ ( Vector2  v1, float  s  )

inlinestatic

        {
            return new Vector2(v1._x / s, v1._y / s);
        }

operator/() [2/2]

static Vector2 BrawlLib.Internal.Vector2.operator/ ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return new Vector2(v1._x / v2._x, v1._y / v2._y);
        }

operator<=()

static bool BrawlLib.Internal.Vector2.operator<= ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return v1._x <= v2._x && v1._y <= v2._y;
        }

operator==()

static bool BrawlLib.Internal.Vector2.operator== ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return v1._x == v2._x && v1._y == v2._y;
        }

operator>=()

static bool BrawlLib.Internal.Vector2.operator>= ( Vector2  v1, Vector2  v2  )

inlinestatic

        {
            return v1._x >= v2._x && v1._y >= v2._y;
        }

RemappedToRange()

Vector2 BrawlLib.Internal.Vector2.RemappedToRange ( float  min, float  max  )

inline

        {
            return new Vector2(_x.RemapToRange(min, max), _y.RemapToRange(min, max));
        }

RemapToRange()

void BrawlLib.Internal.Vector2.RemapToRange ( float  min, float  max  )

inline

        {
            _x = _x.RemapToRange(min, max);
            _y = _y.RemapToRange(min, max);
        }

ToString()

override string BrawlLib.Internal.Vector2.ToString ( )

inline

        {
            return CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator.Contains(",")
                ? $"({_x} {_y})"
                : $"({_x},{_y})";
        }

TrueDistance()

float BrawlLib.Internal.Vector2.TrueDistance ( Vector2  p )

inline

        {
            float lenX = Math.Abs(p._x - _x);
            float lenY = Math.Abs(p._y - _y);
 
            if (lenX == 0.0f)
            {
                return lenY;
            }
 
            if (lenY == 0.0f)
            {
                return lenX;
            }
 
            return (float) (lenX / Math.Cos(Math.Atan(lenY / lenX)));
        }

Truncate()

static Vector2 BrawlLib.Internal.Vector2.Truncate ( Vector2  v )

inlinestatic

        {
            return new Vector2(
                v._x > 0.0f ? (float) Math.Floor(v._x) : (float) Math.Ceiling(v._x),
                v._y > 0.0f ? (float) Math.Floor(v._y) : (float) Math.Ceiling(v._y));
        }

Member Data Documentation

_x

float BrawlLib.Internal.Vector2._x

_y

float BrawlLib.Internal.Vector2._y

Property Documentation

X

float BrawlLib.Internal.Vector2.X

getset

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

Y

float BrawlLib.Internal.Vector2.Y

getset

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

---

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

• BrawlLib/Internal/Vector2.cs