/// <summary> /// Inverses the direction of a vector. /// </summary> /// <param name="value">The vector to inverse.</param> /// <param name="result">The negated vector.</param> public static void Negate(ref FPVector4 value, out FPVector4 result) { result.x = -value.x; result.y = -value.y; result.z = -value.z; result.w = -value.w; }
/// <summary> /// Subtracts to vectors. /// </summary> /// <param name="value1">The first vector.</param> /// <param name="value2">The second vector.</param> /// <param name="result">The difference of both vectors.</param> public static void Subtract(ref FPVector4 value1, ref FPVector4 value2, out FPVector4 result) { result.x = value1.x - value2.x; result.y = value1.y - value2.y; result.z = value1.z - value2.z; result.w = value1.w - value2.w; }
/// <summary> /// Inverses the direction of a vector. /// </summary> /// <param name="value">The vector to inverse.</param> /// <returns>The negated vector.</returns> public static FPVector4 Negate(FPVector4 value) { FPVector4 result; FPVector4.Negate(ref value, out result); return(result); }
/// <summary> /// Divides a vector by a factor. /// </summary> /// <param name="value1">The vector to divide.</param> /// <param name="scaleFactor">The scale factor.</param> /// <param name="result">Returns the scaled vector.</param> public static void Divide(ref FPVector4 value1, FP scaleFactor, out FPVector4 result) { result.x = value1.x / scaleFactor; result.y = value1.y / scaleFactor; result.z = value1.z / scaleFactor; result.w = value1.w / scaleFactor; }
/// <summary> /// Multiplies a vector by a scale factor. /// </summary> /// <param name="value2">The vector to scale.</param> /// <param name="value1">The scale factor.</param> /// <returns>Returns the scaled vector.</returns> #region public static JVector operator *(FP value1, JVector value2) public static FPVector4 operator *(FP value1, FPVector4 value2) { FPVector4 result; FPVector4.Multiply(ref value2, value1, out result); return(result); }
/// <summary> /// Adds to vectors. /// </summary> /// <param name="value1">The first vector.</param> /// <param name="value2">The second vector.</param> /// <param name="result">The sum of both vectors.</param> public static void Add(ref FPVector4 value1, ref FPVector4 value2, out FPVector4 result) { result.x = value1.x + value2.x; result.y = value1.y + value2.y; result.z = value1.z + value2.z; result.w = value1.w + value2.w; }
/// <summary> /// Divides a vector by a factor. /// </summary> /// <param name="value1">The vector to divide.</param> /// <param name="scaleFactor">The scale factor.</param> /// <returns>Returns the scaled vector.</returns> public static FPVector4 Divide(FPVector4 value1, FP scaleFactor) { FPVector4 result; FPVector4.Divide(ref value1, scaleFactor, out result); return(result); }
public static void Transform(ref FPVector4 vector, ref FPMatrix4x4 matrix, out FPVector4 result) { result.x = vector.x * matrix.M11 + vector.y * matrix.M12 + vector.z * matrix.M13 + vector.w * matrix.M14; result.y = vector.x * matrix.M21 + vector.y * matrix.M22 + vector.z * matrix.M23 + vector.w * matrix.M24; result.z = vector.x * matrix.M31 + vector.y * matrix.M32 + vector.z * matrix.M33 + vector.w * matrix.M34; result.w = vector.x * matrix.M41 + vector.y * matrix.M42 + vector.z * matrix.M43 + vector.w * matrix.M44; }
/// <summary> /// Adds two vectors. /// </summary> /// <param name="value1">The first vector.</param> /// <param name="value2">The second vector.</param> /// <returns>The sum of both vectors.</returns> #region public static void Add(JVector value1, JVector value2) public static FPVector4 Add(FPVector4 value1, FPVector4 value2) { FPVector4 result; FPVector4.Add(ref value1, ref value2, out result); return(result); }
public static FPVector4 Transform(FPVector position, FPMatrix4x4 matrix) { FPVector4 result; FPVector4.Transform(ref position, ref matrix, out result); return(result); }
/// <summary> /// Gets a vector with the maximum x,y and z values of both vectors. /// </summary> /// <param name="value1">The first value.</param> /// <param name="value2">The second value.</param> /// <param name="result">A vector with the maximum x,y and z values of both vectors.</param> public static void Max(ref FPVector4 value1, ref FPVector4 value2, out FPVector4 result) { result.x = (value1.x > value2.x) ? value1.x : value2.x; result.y = (value1.y > value2.y) ? value1.y : value2.y; result.z = (value1.z > value2.z) ? value1.z : value2.z; result.w = (value1.w > value2.w) ? value1.w : value2.w; }
/** * @brief Transform a direction from world space to local space. **/ public FPVector4 InverseTransformDirection(FPVector4 direction) { Debug.Assert(direction.w == FP.Zero); FPMatrix4x4 matrix = FPMatrix4x4.Translate(position) * FPMatrix4x4.Rotate(rotation); return(FPVector4.Transform(direction, FPMatrix4x4.Inverse(matrix))); }
/// <summary> /// Normalizes the given vector. /// </summary> /// <param name="value">The vector which should be normalized.</param> /// <returns>A normalized vector.</returns> #region public static JVector Normalize(JVector value) public static FPVector4 Normalize(FPVector4 value) { FPVector4 result; FPVector4.Normalize(ref value, out result); return(result); }
/// <summary> /// Subtracts two vectors. /// </summary> /// <param name="value1">The first vector.</param> /// <param name="value2">The second vector.</param> /// <returns>The difference of both vectors.</returns> #region public static JVector Subtract(JVector value1, JVector value2) public static FPVector4 Subtract(FPVector4 value1, FPVector4 value2) { FPVector4 result; FPVector4.Subtract(ref value1, ref value2, out result); return(result); }
/// <summary> /// Multiply a vector with a factor. /// </summary> /// <param name="value1">The vector to multiply.</param> /// <param name="scaleFactor">The scale factor.</param> /// <param name="result">Returns the multiplied vector.</param> public static void Multiply(ref FPVector4 value1, FP scaleFactor, out FPVector4 result) { result.x = value1.x * scaleFactor; result.y = value1.y * scaleFactor; result.z = value1.z * scaleFactor; result.w = value1.w * scaleFactor; }
/// <summary> /// Multiplies each component of the vector by the same components of the provided vector. /// </summary> public void Scale(FPVector4 other) { this.x = x * other.x; this.y = y * other.y; this.z = z * other.z; this.w = w * other.w; }
/// <summary> /// Multiply a vector with a factor. /// </summary> /// <param name="value1">The vector to multiply.</param> /// <param name="scaleFactor">The scale factor.</param> /// <returns>Returns the multiplied vector.</returns> #region public static JVector Multiply(JVector value1, FP scaleFactor) public static FPVector4 Multiply(FPVector4 value1, FP scaleFactor) { FPVector4 result; FPVector4.Multiply(ref value1, scaleFactor, out result); return(result); }
/// <summary> /// Divides a vector by a factor. /// </summary> /// <param name="value1">The vector to divide.</param> /// <param name="scaleFactor">The scale factor.</param> /// <returns>Returns the scaled vector.</returns> public static FPVector4 operator /(FPVector4 value1, FP value2) { FPVector4 result; FPVector4.Divide(ref value1, value2, out result); return(result); }
static FPVector4() { one = new FPVector4(1, 1, 1, 1); zero = new FPVector4(0, 0, 0, 0); MinValue = new FPVector4(FP.MinValue); MaxValue = new FPVector4(FP.MaxValue); InternalZero = zero; }
/// <summary> /// Tests if an object is equal to this vector. /// </summary> /// <param name="obj">The object to test.</param> /// <returns>Returns true if they are euqal, otherwise false.</returns> #region public override bool Equals(object obj) public override bool Equals(object obj) { if (!(obj is FPVector4)) { return(false); } FPVector4 other = (FPVector4)obj; return(((x == other.x) && (y == other.y)) && (z == other.z) && (w == other.w)); }
/// <summary> /// Normalizes the given vector. /// </summary> /// <param name="value">The vector which should be normalized.</param> /// <param name="result">A normalized vector.</param> public static void Normalize(ref FPVector4 value, out FPVector4 result) { FP num2 = ((value.x * value.x) + (value.y * value.y)) + (value.z * value.z) + (value.w * value.w); FP num = FP.One / FP.Sqrt(num2); result.x = value.x * num; result.y = value.y * num; result.z = value.z * num; result.w = value.w * num; }
/// <summary> /// Multiplies each component of the vector by the same components of the provided vector. /// </summary> public static FPVector4 Scale(FPVector4 vecA, FPVector4 vecB) { FPVector4 result; result.x = vecA.x * vecB.x; result.y = vecA.y * vecB.y; result.z = vecA.z * vecB.z; result.w = vecA.w * vecB.w; return(result); }
/// <summary> /// Swaps the components of both vectors. /// </summary> /// <param name="vector1">The first vector to swap with the second.</param> /// <param name="vector2">The second vector to swap with the first.</param> public static void Swap(ref FPVector4 vector1, ref FPVector4 vector2) { FP temp; temp = vector1.x; vector1.x = vector2.x; vector2.x = temp; temp = vector1.y; vector1.y = vector2.y; vector2.y = temp; temp = vector1.z; vector1.z = vector2.z; vector2.z = temp; temp = vector1.w; vector1.w = vector2.w; vector2.w = temp; }
/** * @brief Transform a vector from world space to local space. **/ public FPVector4 InverseTransformVector(FPVector4 vector) { Debug.Assert(vector.w == FP.Zero); return(FPVector4.Transform(vector, worldToLocalMatrix)); }
/** * @brief Transform a vector from local space to world space. **/ public FPVector4 TransformVector(FPVector4 vector) { Debug.Assert(vector.w == FP.Zero); return(FPVector4.Transform(vector, localToWorldMatrix)); }
public FPVector InverseTransformPoint(FPVector point) { return(FPVector4.Transform(point, worldToLocalMatrix).ToFPVector()); }
/** * @brief Transform a point from world space to local space. **/ public FPVector4 InverseTransformPoint(FPVector4 point) { Debug.Assert(point.w == FP.One); return(FPVector4.Transform(point, worldToLocalMatrix)); }
public FPVector TransformPoint(FPVector point) { return(FPVector4.Transform(point, localToWorldMatrix).ToFPVector()); }
/** * @brief Transform a point from local space to world space. **/ public FPVector4 TransformPoint(FPVector4 point) { Debug.Assert(point.w == FP.One); return(FPVector4.Transform(point, localToWorldMatrix)); }
public static FPVector4 Abs(FPVector4 other) { return(new FPVector4(FP.Abs(other.x), FP.Abs(other.y), FP.Abs(other.z), FP.Abs(other.z))); }