BrawlLib.Internal.Vector4 Struct Reference

Inheritance diagram for BrawlLib.Internal.Vector4:

Public Member Functions
	Vector4 (float x, float y, float z, float w)
	Vector4 (float s)
	Vector4 (SerializationInfo info, StreamingContext context)
void	GetObjectData (SerializationInfo info, StreamingContext context)
float	Length ()
float	Dot ()
float	Dot (Vector4 v)
Vector4	Normalize ()
float	Dot3 ()
float	Dot3 (Vector4 v)
float	Length3 ()
Vector4	Normalize3 ()
override string	ToString ()
override bool	Equals (object obj)
override int	GetHashCode ()
void	ToAxisAngle (out Vector3 axis, out float angle)
Vector4	ToAxisAngle ()
Vector3	ToEuler ()

Static Public Member Functions
static	operator Vector4 (Vector3 v)
static Vector4	operator* (Vector4 v, float f)
static Vector4	operator/ (Vector4 v, float f)
static Vector4	operator- (Vector4 v1, Vector4 v2)
static Vector4	operator+ (Vector4 v1, Vector4 v2)
static Vector4	operator* (Vector4 v1, Vector4 v2)
static bool	operator== (Vector4 v1, Vector4 v2)
static bool	operator!= (Vector4 v1, Vector4 v2)
static Vector4	FromAxisAngle (Vector3 axis, float angle)
static Vector4	FromEulerAngles (Vector3 v)

Public Attributes
float	_x
float	_y
float	_z
float	_w

Static Public Attributes
static readonly Vector4	UnitX = new Vector4(1, 0, 0, 0)
static readonly Vector4	UnitY = new Vector4(0, 1, 0, 0)
static readonly Vector4	UnitZ = new Vector4(0, 0, 1, 0)
static readonly Vector4	UnitW = new Vector4(0, 0, 0, 1)
static readonly Vector4	Zero = new Vector4(0, 0, 0, 0)
static readonly Vector4	One = new Vector4(1, 1, 1, 1)
static readonly Vector4	Identity = new Vector4(0, 0, 0, 1)

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

Constructor & Destructor Documentation

Vector4() [1/3]

BrawlLib.Internal.Vector4.Vector4 ( float  x, float  y, float  z, float  w  )

inline

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

Vector4() [2/3]

BrawlLib.Internal.Vector4.Vector4 ( float  s )

inline

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

Vector4() [3/3]

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

inline

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

Member Function Documentation

Dot() [1/2]

float BrawlLib.Internal.Vector4.Dot ( )

inline

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

Dot() [2/2]

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

inline

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

Dot3() [1/2]

float BrawlLib.Internal.Vector4.Dot3 ( )

inline

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

Dot3() [2/2]

float BrawlLib.Internal.Vector4.Dot3 ( Vector4  v )

inline

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

Equals()

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

inline

        {
            if (obj is Vector4 vector4)
            {
                return this == vector4;
            }
 
            return false;
        }

FromAxisAngle()

static Vector4 BrawlLib.Internal.Vector4.FromAxisAngle ( Vector3  axis, float  angle  )

inlinestatic

        {
            if (axis.Dot() == 0.0f)
            {
                return Identity;
            }
 
            Vector4 result = Identity;
 
            angle *= 0.5f;
            axis.Normalize();
            result._x = axis._x * (float) Math.Sin(angle);
            result._y = axis._y * (float) Math.Sin(angle);
            result._z = axis._z * (float) Math.Sin(angle);
            result._w = (float) Math.Cos(angle);
 
            return result.Normalize();
        }

FromEulerAngles()

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

inlinestatic

        {
            Vector3
                vx = new Vector3(1, 0, 0),
                vy = new Vector3(0, 1, 0),
                vz = new Vector3(0, 0, 1);
            Vector4 qx, qy, qz;
 
            qx = FromAxisAngle(vx, v._x);
            qy = FromAxisAngle(vy, v._y);
            qz = FromAxisAngle(vz, v._z);
 
            return qx * qy * qz;
        }

GetHashCode()

override int BrawlLib.Internal.Vector4.GetHashCode ( )

inline

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

GetObjectData()

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

inline

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

Length()

float BrawlLib.Internal.Vector4.Length ( )

inline

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

Length3()

float BrawlLib.Internal.Vector4.Length3 ( )

inline

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

Normalize()

Vector4 BrawlLib.Internal.Vector4.Normalize ( )

inline

        {
            return this * (1.0f / Length());
        }

Normalize3()

Vector4 BrawlLib.Internal.Vector4.Normalize3 ( )

inline

        {
            float scale = 1.0f / Length3();
            return new Vector4(_x * scale, _y * scale, _z * scale, _w);
        }

operator Vector4()

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

inlineexplicitstatic

        {
            return new Vector4(v._x, v._y, v._z, 1.0f);
        }

operator!=()

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

inlinestatic

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

operator*() [1/2]

static Vector4 BrawlLib.Internal.Vector4.operator* ( Vector4  v, float  f  )

inlinestatic

        {
            return new Vector4(v._x * f, v._y * f, v._z * f, v._w * f);
        }

operator*() [2/2]

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

inlinestatic

        {
            Vector4 v = new Vector4();
 
            Vector3 x1 = new Vector3(v1._x, v1._y, v1._z);
            Vector3 x2 = new Vector3(v2._x, v2._y, v2._z);
            float w1 = v1._w;
            float w2 = v2._w;
 
            //Vector3 s = new Vector3(w1 * w2 - x1.Dot(x2), w1 * x2 + w2 * x1 + x1.Cross(x2));
 
            return v;
        }

operator+()

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

inlinestatic

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

operator-()

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

inlinestatic

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

operator/()

static Vector4 BrawlLib.Internal.Vector4.operator/ ( Vector4  v, float  f  )

inlinestatic

        {
            return new Vector4(v._x / f, v._y / f, v._z / f, v._w / f);
        }

operator==()

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

inlinestatic

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

ToAxisAngle() [1/2]

Vector4 BrawlLib.Internal.Vector4.ToAxisAngle ( )

inline

        {
            Vector4 q = this;
            if (q._w > 1.0f)
            {
                q.Normalize();
            }
 
            Vector4 result = new Vector4
            {
                _w = 2.0f * (float) Math.Acos(q._w)
            };
            float den = (float) Math.Sqrt(1.0 - q._w * q._w);
            if (den > 0.0001f)
            {
                result._x = q._x / den;
                result._y = q._y / den;
                result._z = q._z / den;
            }
            else
            {
                result._x = 1;
            }
 
            return result;
        }

ToAxisAngle() [2/2]

void BrawlLib.Internal.Vector4.ToAxisAngle ( out Vector3  axis, out float  angle  )

inline

        {
            Vector4 result = ToAxisAngle();
            axis = new Vector3(result._x, result._y, result._z);
            angle = result._w;
        }

ToEuler()

Vector3 BrawlLib.Internal.Vector4.ToEuler ( )

inline

        {
            return new Vector3(
                (float) Math.Atan2(2 * (_x * _y + _z * _w), 1 - 2 * (_y * _y + _z * _z)),
                (float) Math.Asin(2 * (_x * _z - _w * _y)),
                (float) Math.Atan2(2 * (_x * _w + _y * _z), 1 - 2 * (_z * _z + _w * _w)));
        }

ToString()

override string BrawlLib.Internal.Vector4.ToString ( )

inline

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

Member Data Documentation

_w

float BrawlLib.Internal.Vector4._w

_x

float BrawlLib.Internal.Vector4._x

_y

float BrawlLib.Internal.Vector4._y

_z

float BrawlLib.Internal.Vector4._z

Identity

readonly Vector4 BrawlLib.Internal.Vector4.Identity = new Vector4(0, 0, 0, 1)

static

One

readonly Vector4 BrawlLib.Internal.Vector4.One = new Vector4(1, 1, 1, 1)

static

UnitW

readonly Vector4 BrawlLib.Internal.Vector4.UnitW = new Vector4(0, 0, 0, 1)

static

UnitX

readonly Vector4 BrawlLib.Internal.Vector4.UnitX = new Vector4(1, 0, 0, 0)

static

UnitY

readonly Vector4 BrawlLib.Internal.Vector4.UnitY = new Vector4(0, 1, 0, 0)

static

UnitZ

readonly Vector4 BrawlLib.Internal.Vector4.UnitZ = new Vector4(0, 0, 1, 0)

static

Zero

readonly Vector4 BrawlLib.Internal.Vector4.Zero = new Vector4(0, 0, 0, 0)

static

Property Documentation

Address

VoidPtr BrawlLib.Internal.Vector4.Address

get

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

this[int index]

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

getset

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

---

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

• BrawlLib/Internal/Vector4.cs