BrawlLib.Internal.Vector3 Struct Reference

Inheritance diagram for BrawlLib.Internal.Vector3:

Public Member Functions
	Vector3 (float x, float y, float z)
	Vector3 (float s)
	Vector3 (SerializationInfo info, StreamingContext context)
void	GetObjectData (SerializationInfo info, StreamingContext context)
void	Add (Vector3 *v)
void	Add (float v)
void	Sub (Vector3 *v)
void	Sub (float v)
void	Multiply (Vector3 *v)
void	Multiply (float v)
float	Dot (Vector3 v)
float	Dot (Vector3 *v)
float	Dot ()
void	Clamp (float min, float max)
void	Min (Vector3 v)
void	Min (Vector3 *v)
void	Min (float f)
void	Max (Vector3 v)
void	Max (Vector3 *v)
void	Max (float f)
float	DistanceTo (Vector3 v)
Vector3	Cross (Vector3 v)
Vector3	Round (int places)
override string	ToString ()
bool	Contained (Vector3 start, Vector3 end, float expansion)
float	TrueDistance (Vector3 p)
float	TrueDistance ()
Vector3	Normalize ()
Vector3	Normalize (Vector3 origin)
Vector3	GetAngles ()
Vector3	GetAngles (Vector3 origin)
Vector3	LookatAngles ()
Vector3	LookatAngles (Vector3 origin)
float	AngleX ()
float	AngleY ()
float	AngleZ ()
override int	GetHashCode ()
override bool	Equals (object obj)
void	Lerp (Vector3 dest, float percent)
Vector3	Lerped (Vector3 dest, float percent)
void	RemapToRange (float min, float max)
Vector3	RemappedToRange (float min, float max)
int	CompareTo (object obj)
Vector4	ToQuat ()
bool	IsInTriangle (Vector3 triPt1, Vector3 triPt2, Vector3 triPt3)

Static Public Member Functions
static	operator Vector3 (Vector4 v)
static	operator Vector3 (OpenTK.Vector3 v)
static	operator OpenTK.Vector3 (Vector3 v)
static	operator Vector3 (Color c)
static	operator Color (Vector3 v)
static Vector3	operator- (Vector3 v)
static Vector3	operator+ (Vector3 v1, Vector3 v2)
static Vector3	operator+ (Vector3 v1, float f)
static Vector3	operator+ (float f, Vector3 v1)
static Vector3	operator- (Vector3 v1, Vector3 v2)
static Vector3	operator- (Vector3 v1, float f)
static Vector3	operator* (Vector3 v1, Vector3 v2)
static Vector3	operator* (Vector3 v1, float s)
static Vector3	operator* (float s, Vector3 v1)
static Vector3	operator/ (Vector3 v1, Vector3 v2)
static Vector3	operator/ (Vector3 v1, float s)
static Vector3	operator/ (float s, Vector3 v1)
static bool	operator== (Vector3 v1, Vector3 v2)
static bool	operator!= (Vector3 v1, Vector3 v2)
static bool	operator< (Vector3 v1, Vector3 v2)
static bool	operator> (Vector3 v1, Vector3 v2)
static bool	operator<= (Vector3 v1, Vector3 v2)
static bool	operator>= (Vector3 v1, Vector3 v2)
static float *	Mult (float *v1, float *v2)
static float *	Mult (float *v1, float v2)
static float *	Add (float *v1, float *v2)
static float *	Add (float *v1, float v2)
static float *	Sub (float *v1, float *v2)
static float *	Sub (float *v1, float v2)
static float	Dot (Vector3 v1, Vector3 v2)
static Vector3	Clamp (Vector3 v1, float min, float max)
static Vector3	Min (Vector3 v1, Vector3 v2)
static Vector3	Min (Vector3 v1, float f)
static Vector3	Max (Vector3 v1, Vector3 v2)
static Vector3	Max (Vector3 v1, Vector3 *v2)
static Vector3	Max (Vector3 v1, float f)
static Vector3	Lerp (Vector3 v1, Vector3 v2, float median)
static Vector3	Floor (Vector3 v)
static Vector3	Cross (Vector3 v1, Vector3 v2)
static Vector3	Truncate (Vector3 v)
static bool	Contained (Vector3 point, Vector3 start, Vector3 end, float expansion)
static Vector3	IntersectZ (Vector3 ray1, Vector3 ray2, float z)

Public Attributes
float	_x
float	_y
float	_z

Static Public Attributes
static readonly Vector3	UnitX = new Vector3(1.0f, 0.0f, 0.0f)
static readonly Vector3	UnitY = new Vector3(0.0f, 1.0f, 0.0f)
static readonly Vector3	UnitZ = new Vector3(0.0f, 0.0f, 1.0f)
static readonly Vector3	Zero = new Vector3(0.0f)
static readonly Vector3	One = new Vector3(1.0f)

Properties
float	this[int index] [get, set]
VoidPtr	Address [get]

Constructor & Destructor Documentation

Vector3() [1/3]

BrawlLib.Internal.Vector3.Vector3 ( float  x, float  y, float  z  )

inline

        {
            _x = x;
            _y = y;
            _z = z;
        }

Vector3() [2/3]

BrawlLib.Internal.Vector3.Vector3 ( float  s )

inline

        {
            _x = s;
            _y = s;
            _z = s;
        }

Vector3() [3/3]

BrawlLib.Internal.Vector3.Vector3 ( SerializationInfo  info, StreamingContext  context  )

inline

        {
            _x = info.GetSingle("_x");
            _y = info.GetSingle("_y");
            _z = info.GetSingle("_z");
        }

Member Function Documentation

Add() [1/4]

static float * BrawlLib.Internal.Vector3.Add ( float *  v1, float *  v2  )

inlinestatic

        {
            v1[0] = v1[0] + v2[0];
            v1[1] = v1[1] + v2[1];
            v1[2] = v1[2] + v2[2];
            return v1;
        }

Add() [2/4]

static float * BrawlLib.Internal.Vector3.Add ( float *  v1, float  v2  )

inlinestatic

        {
            v1[0] = v1[0] + v2;
            v1[1] = v1[1] + v2;
            v1[2] = v1[2] + v2;
            return v1;
        }

Add() [3/4]

void BrawlLib.Internal.Vector3.Add ( float  v )

inline

        {
            _x += v;
            _y += v;
            _z += v;
        }

Add() [4/4]

void BrawlLib.Internal.Vector3.Add ( Vector3 *  v )

inline

        {
            _x += v->_x;
            _y += v->_y;
            _z += v->_z;
        }

AngleX()

float BrawlLib.Internal.Vector3.AngleX ( )

inline

        {
            return (float) Math.Atan2(_y, -_z);
        }

AngleY()

float BrawlLib.Internal.Vector3.AngleY ( )

inline

        {
            return (float) Math.Atan2(-_z, _x);
        }

AngleZ()

float BrawlLib.Internal.Vector3.AngleZ ( )

inline

        {
            return (float) Math.Atan2(_y, _x);
        }

Clamp() [1/2]

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

inline

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

Clamp() [2/2]

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

inlinestatic

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

CompareTo()

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

inline

        {
            if (obj is Vector3)
            {
                Vector3 o = (Vector3) 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;
                }
 
                if (_z > o._z)
                {
                    return 1;
                }
 
                if (_z < o._z)
                {
                    return -1;
                }
 
                return 0;
            }
 
            return 1;
        }

Contained() [1/2]

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

inlinestatic

        {
            float* sPtr = (float*) &point;
            float* s1 = (float*) &start, s2 = (float*) &end;
            float* temp;
            for (int i = 0; i < 3; 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.Vector3.Contained ( Vector3  start, Vector3  end, float  expansion  )

inline

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

Cross() [1/2]

Vector3 BrawlLib.Internal.Vector3.Cross ( Vector3  v )

inline

        {
            return new Vector3(_y * v._z - v._y * _z, _z * v._x - v._z * _x, _x * v._y - v._x * _y);
        }

Cross() [2/2]

static Vector3 BrawlLib.Internal.Vector3.Cross ( Vector3  v1, Vector3  v2  )

inlinestatic

        {
            return new Vector3(v1._y * v2._z - v2._y * v1._z, v1._z * v2._x - v2._z * v1._x,
                v1._x * v2._y - v2._x * v1._y);
        }

DistanceTo()

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

inline

        {
            return (v - this).Dot();
        }

Dot() [1/4]

float BrawlLib.Internal.Vector3.Dot ( )

inline

        {
            return _x * _x + _y * _y + _z * _z;
        }

Dot() [2/4]

float BrawlLib.Internal.Vector3.Dot ( Vector3 *  v )

inline

        {
            return _x * v->_x + _y * v->_y + _z * v->_z;
        }

Dot() [3/4]

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

inline

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

Dot() [4/4]

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

inlinestatic

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

Equals()

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

inline

        {
            if (obj is Vector3 vector3)
            {
                return this == vector3;
            }
 
            return false;
        }

Floor()

static Vector3 BrawlLib.Internal.Vector3.Floor ( Vector3  v )

inlinestatic

        {
            return new Vector3((int) v._x, (int) v._y, (int) v._z);
        }

GetAngles() [1/2]

Vector3 BrawlLib.Internal.Vector3.GetAngles ( )

inline

        {
            return new Vector3(AngleX(), AngleY(), AngleZ());
        }

GetAngles() [2/2]

Vector3 BrawlLib.Internal.Vector3.GetAngles ( Vector3  origin )

inline

        {
            return (this - origin).GetAngles();
        }

GetHashCode()

override int BrawlLib.Internal.Vector3.GetHashCode ( )

inline

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

GetObjectData()

void BrawlLib.Internal.Vector3.GetObjectData ( SerializationInfo  info, StreamingContext  context  )

inline

        {
            info.AddValue("_x", _x);
            info.AddValue("_y", _y);
            info.AddValue("_z", _z);
        }

IntersectZ()

static Vector3 BrawlLib.Internal.Vector3.IntersectZ ( Vector3  ray1, Vector3  ray2, float  z  )

inlinestatic

        {
            float a = ray2._z - ray1._z;
 
            float tanX = (ray1._y - ray2._y) / a;
            float tanY = (ray2._x - ray1._x) / a;
 
            a = z - ray1._z;
            return new Vector3(tanY * a + ray1._x, -tanX * a + ray1._y, z);
        }

IsInTriangle()

bool BrawlLib.Internal.Vector3.IsInTriangle ( Vector3  triPt1, Vector3  triPt2, Vector3  triPt3  )

inline

        {
            Vector3 v0 = triPt2 - triPt1;
            Vector3 v1 = triPt3 - triPt1;
            Vector3 v2 = this - triPt1;
 
            float dot00 = v0.Dot(v0);
            float dot01 = v0.Dot(v1);
            float dot02 = v0.Dot(v2);
            float dot11 = v1.Dot(v1);
            float dot12 = v1.Dot(v2);
 
            //Get barycentric coordinates
            float d = dot00 * dot11 - dot01 * dot01;
            float u = (dot11 * dot02 - dot01 * dot12) / d;
            float v = (dot00 * dot12 - dot01 * dot02) / d;
 
            return u >= 0 && v >= 0 && u + v < 1;
        }

Lerp() [1/2]

void BrawlLib.Internal.Vector3.Lerp ( Vector3  dest, float  percent  )

inline

        {
            this += (dest - this) * percent;
        }

Lerp() [2/2]

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

inlinestatic

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

Lerped()

Vector3 BrawlLib.Internal.Vector3.Lerped ( Vector3  dest, float  percent  )

inline

        {
            return this + (dest - this) * percent;
        }

LookatAngles() [1/2]

Vector3 BrawlLib.Internal.Vector3.LookatAngles ( )

inline

        {
            return new Vector3((float) Math.Atan2(_y, Math.Sqrt(_x * _x + _z * _z)), (float) Math.Atan2(-_x, -_z),
                0.0f);
        }

LookatAngles() [2/2]

Vector3 BrawlLib.Internal.Vector3.LookatAngles ( Vector3  origin )

inline

        {
            return (this - origin).LookatAngles();
        }

Max() [1/6]

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

inline

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

Max() [2/6]

void BrawlLib.Internal.Vector3.Max ( Vector3 *  v )

inline

        {
            if (v->_x > _x)
            {
                _x = v->_x;
            }
 
            if (v->_y > _y)
            {
                _y = v->_y;
            }
 
            if (v->_z > _z)
            {
                _z = v->_z;
            }
        }

Max() [3/6]

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

inline

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

Max() [4/6]

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

inlinestatic

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

Max() [5/6]

static Vector3 BrawlLib.Internal.Vector3.Max ( Vector3  v1, Vector3 *  v2  )

inlinestatic

        {
            return new Vector3(Math.Max(v1._x, v2->_x), Math.Max(v1._y, v2->_y), Math.Max(v1._z, v2->_z));
        }

Max() [6/6]

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

inlinestatic

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

Min() [1/5]

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

inline

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

Min() [2/5]

void BrawlLib.Internal.Vector3.Min ( Vector3 *  v )

inline

        {
            if (v->_x < _x)
            {
                _x = v->_x;
            }
 
            if (v->_y < _y)
            {
                _y = v->_y;
            }
 
            if (v->_z < _z)
            {
                _z = v->_z;
            }
        }

Min() [3/5]

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

inline

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

Min() [4/5]

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

inlinestatic

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

Min() [5/5]

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

inlinestatic

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

Mult() [1/2]

static float * BrawlLib.Internal.Vector3.Mult ( float *  v1, float *  v2  )

inlinestatic

        {
            v1[0] = v1[0] * v2[0];
            v1[1] = v1[1] * v2[1];
            v1[2] = v1[2] * v2[2];
            return v1;
        }

Mult() [2/2]

static float * BrawlLib.Internal.Vector3.Mult ( float *  v1, float  v2  )

inlinestatic

        {
            v1[0] = v1[0] * v2;
            v1[1] = v1[1] * v2;
            v1[2] = v1[2] * v2;
            return v1;
        }

Multiply() [1/2]

void BrawlLib.Internal.Vector3.Multiply ( float  v )

inline

        {
            _x *= v;
            _y *= v;
            _z *= v;
        }

Multiply() [2/2]

void BrawlLib.Internal.Vector3.Multiply ( Vector3 *  v )

inline

        {
            _x *= v->_x;
            _y *= v->_y;
            _z *= v->_z;
        }

Normalize() [1/2]

Vector3 BrawlLib.Internal.Vector3.Normalize ( )

inline

        {
            return this / TrueDistance();
        }

Normalize() [2/2]

Vector3 BrawlLib.Internal.Vector3.Normalize ( Vector3  origin )

inline

        {
            return (this - origin).Normalize();
        }

operator Color()

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

inlineexplicitstatic

        {
            return Color.FromArgb((int) (v._x / _colorFactor), (int) (v._y / _colorFactor),
                (int) (v._z / _colorFactor));
        }

operator OpenTK.Vector3()

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

inlineexplicitstatic

        {
            return new OpenTK.Vector3(v._x, v._y, v._z);
        }

operator Vector3() [1/3]

static BrawlLib.Internal.Vector3.operator Vector3 ( Color  c )

inlineexplicitstatic

        {
            return new Vector3(c.R * _colorFactor, c.G * _colorFactor, c.B * _colorFactor);
        }

operator Vector3() [2/3]

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

inlineexplicitstatic

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

operator Vector3() [3/3]

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

inlineexplicitstatic

        {
            if (v._w == 0.0f)
            {
                return new Vector3(v._x, v._y, v._z);
            }
 
            return new Vector3(v._x / v._w, v._y / v._w, v._z / v._w);
        }

operator!=()

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

inlinestatic

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

operator*() [1/3]

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

inlinestatic

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

operator*() [2/3]

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

inlinestatic

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

operator*() [3/3]

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

inlinestatic

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

operator+() [1/3]

static Vector3 BrawlLib.Internal.Vector3.operator+ ( float  f, Vector3  v1  )

inlinestatic

        {
            return new Vector3(v1._x + f, v1._y + f, v1._z + f);
        }

operator+() [2/3]

static Vector3 BrawlLib.Internal.Vector3.operator+ ( Vector3  v1, float  f  )

inlinestatic

        {
            return new Vector3(v1._x + f, v1._y + f, v1._z + f);
        }

operator+() [3/3]

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

inlinestatic

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

operator-() [1/3]

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

inlinestatic

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

operator-() [2/3]

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

inlinestatic

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

operator-() [3/3]

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

inlinestatic

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

operator/() [1/3]

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

inlinestatic

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

operator/() [2/3]

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

inlinestatic

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

operator/() [3/3]

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

inlinestatic

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

operator<()

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

inlinestatic

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

operator<=()

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

inlinestatic

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

operator==()

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

inlinestatic

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

operator>()

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

inlinestatic

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

operator>=()

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

inlinestatic

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

RemappedToRange()

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

inline

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

RemapToRange()

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

inline

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

Round()

Vector3 BrawlLib.Internal.Vector3.Round ( int  places )

inline

        {
            return new Vector3((float) Math.Round(_x, places), (float) Math.Round(_y, places),
                (float) Math.Round(_z, places));
        }

Sub() [1/4]

static float * BrawlLib.Internal.Vector3.Sub ( float *  v1, float *  v2  )

inlinestatic

        {
            v1[0] = v1[0] - v2[0];
            v1[1] = v1[1] - v2[1];
            v1[2] = v1[2] - v2[2];
            return v1;
        }

Sub() [2/4]

static float * BrawlLib.Internal.Vector3.Sub ( float *  v1, float  v2  )

inlinestatic

        {
            v1[0] = v1[0] - v2;
            v1[1] = v1[1] - v2;
            v1[2] = v1[2] - v2;
            return v1;
        }

Sub() [3/4]

void BrawlLib.Internal.Vector3.Sub ( float  v )

inline

        {
            _x -= v;
            _y -= v;
            _z -= v;
        }

Sub() [4/4]

void BrawlLib.Internal.Vector3.Sub ( Vector3 *  v )

inline

        {
            _x -= v->_x;
            _y -= v->_y;
            _z -= v->_z;
        }

ToQuat()

Vector4 BrawlLib.Internal.Vector3.ToQuat ( )

inline

        {
            Vector4 q = new Vector4();
 
            double
                xRadian = _x / 2.0f,
                yRadian = _y / 2.0f,
                zRadian = _z / 2.0f,
                sinX = Math.Sin(xRadian),
                cosX = Math.Cos(xRadian),
                sinY = Math.Sin(yRadian),
                cosY = Math.Cos(yRadian),
                sinZ = Math.Sin(zRadian),
                cosZ = Math.Cos(zRadian);
 
            q._x = (float) (cosX * cosY * cosZ + sinX * sinY * sinZ);
            q._y = (float) (sinX * cosY * cosZ - cosX * sinY * sinZ);
            q._z = (float) (cosX * sinY * cosZ + sinX * cosY * sinZ);
            q._w = (float) (cosX * cosY * sinZ - sinX * sinY * cosZ);
 
            return q;
        }

ToString()

override string BrawlLib.Internal.Vector3.ToString ( )

inline

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

TrueDistance() [1/2]

float BrawlLib.Internal.Vector3.TrueDistance ( )

inline

        {
            return (float) Math.Sqrt(Dot());
        }

TrueDistance() [2/2]

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

inline

        {
            return (float) Math.Sqrt((p - this).Dot());
        }

Truncate()

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

inlinestatic

        {
            return new Vector3(
                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._z),
                v._z > 0.0f ? (float) Math.Floor(v._z) : (float) Math.Ceiling(v._z));
        }

Member Data Documentation

_x

float BrawlLib.Internal.Vector3._x

_y

float BrawlLib.Internal.Vector3._y

_z

float BrawlLib.Internal.Vector3._z

One

readonly Vector3 BrawlLib.Internal.Vector3.One = new Vector3(1.0f)

static

UnitX

readonly Vector3 BrawlLib.Internal.Vector3.UnitX = new Vector3(1.0f, 0.0f, 0.0f)

static

UnitY

readonly Vector3 BrawlLib.Internal.Vector3.UnitY = new Vector3(0.0f, 1.0f, 0.0f)

static

UnitZ

readonly Vector3 BrawlLib.Internal.Vector3.UnitZ = new Vector3(0.0f, 0.0f, 1.0f)

static

Zero

readonly Vector3 BrawlLib.Internal.Vector3.Zero = new Vector3(0.0f)

static

Property Documentation

Address

VoidPtr BrawlLib.Internal.Vector3.Address

get

        {
            get
            {
                fixed (void* p = &this)
                {
                    return p;
                }
            }
        }

this[int index]

float BrawlLib.Internal.Vector3.this[int index]

getset

        {
            get
            {
                fixed (Vector3* p = &this)
                {
                    return ((float*) p)[index];
                }
            }
            set
            {
                fixed (Vector3* p = &this)
                {
                    ((float*) p)[index] = value;
                }
            }
        }

---

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

• BrawlLib/Internal/Vector3.cs