コード例 #1
0
 /// <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 TSVector4 value1, FP scaleFactor, out TSVector4 result)
 {
     result.x = value1.x / scaleFactor;
     result.y = value1.y / scaleFactor;
     result.z = value1.z / scaleFactor;
     result.w = value1.w / scaleFactor;
 }
コード例 #2
0
    /// <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 TSVector4 operator /(TSVector4 value1, FP value2)
    {
        TSVector4 result;

        TSVector4.Divide(ref value1, value2, out result);
        return(result);
    }
コード例 #3
0
 /// <summary>
 /// Multiplies each component of the vector by the same components of the provided vector.
 /// </summary>
 public void Scale(TSVector4 other)
 {
     this.x = x * other.x;
     this.y = y * other.y;
     this.z = z * other.z;
     this.w = w * other.w;
 }
コード例 #4
0
    /// <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 TSVector4 Subtract(TSVector4 value1, TSVector4 value2)
    {
        TSVector4 result;

        TSVector4.Subtract(ref value1, ref value2, out result);
        return(result);
    }
コード例 #5
0
    /// <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 TSVector4 Normalize(TSVector4 value)
    {
        TSVector4 result;

        TSVector4.Normalize(ref value, out result);
        return(result);
    }
コード例 #6
0
    /// <summary>
    /// Inverses the direction of a vector.
    /// </summary>
    /// <param name="value">The vector to inverse.</param>
    /// <returns>The negated vector.</returns>
    public static TSVector4 Negate(TSVector4 value)
    {
        TSVector4 result;

        TSVector4.Negate(ref value, out result);
        return(result);
    }
コード例 #7
0
 /// <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 TSVector4 value, out TSVector4 result)
 {
     result.x = -value.x;
     result.y = -value.y;
     result.z = -value.z;
     result.w = -value.w;
 }
コード例 #8
0
    /// <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 TSVector4 Divide(TSVector4 value1, FP scaleFactor)
    {
        TSVector4 result;

        TSVector4.Divide(ref value1, scaleFactor, out result);
        return(result);
    }
コード例 #9
0
 /// <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 TSVector4 value1, ref TSVector4 value2, out TSVector4 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;
 }
コード例 #10
0
    /// <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 TSVector4 operator *(FP value1, TSVector4 value2)
    {
        TSVector4 result;

        TSVector4.Multiply(ref value2, value1, out result);
        return(result);
    }
コード例 #11
0
    /// <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 TSVector4 Add(TSVector4 value1, TSVector4 value2)
    {
        TSVector4 result;

        TSVector4.Add(ref value1, ref value2, out result);
        return(result);
    }
コード例 #12
0
 /// <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 TSVector4 value1, ref TSVector4 value2, out TSVector4 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;
 }
コード例 #13
0
 /// <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 TSVector4 value1, FP scaleFactor, out TSVector4 result)
 {
     result.x = value1.x * scaleFactor;
     result.y = value1.y * scaleFactor;
     result.z = value1.z * scaleFactor;
     result.w = value1.w * scaleFactor;
 }
コード例 #14
0
    /// <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 TSVector4 Multiply(TSVector4 value1, FP scaleFactor)
    {
        TSVector4 result;

        TSVector4.Multiply(ref value1, scaleFactor, out result);
        return(result);
    }
コード例 #15
0
 public static void Transform(ref TSVector4 vector, ref TSMatrix4x4 matrix, out TSVector4 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;
 }
コード例 #16
0
    public static TSVector4 Transform(TSVector position, TSMatrix4x4 matrix)
    {
        TSVector4 result;

        TSVector4.Transform(ref position, ref matrix, out result);
        return(result);
    }
コード例 #17
0
 /// <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 TSVector4 value1, ref TSVector4 value2, out TSVector4 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;
 }
コード例 #18
0
 static TSVector4()
 {
     one          = new TSVector4(1, 1, 1, 1);
     zero         = new TSVector4(0, 0, 0, 0);
     MinValue     = new TSVector4(FP.MinValue);
     MaxValue     = new TSVector4(FP.MaxValue);
     InternalZero = zero;
 }
コード例 #19
0
    /// <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 TSVector4 value, out TSVector4 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;
    }
コード例 #20
0
    /// <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 TSVector4))
        {
            return(false);
        }
        TSVector4 other = (TSVector4)obj;

        return(((x == other.x) && (y == other.y)) && (z == other.z) && (w == other.w));
    }
コード例 #21
0
    /// <summary>
    /// Multiplies each component of the vector by the same components of the provided vector.
    /// </summary>
    public static TSVector4 Scale(TSVector4 vecA, TSVector4 vecB)
    {
        TSVector4 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);
    }
コード例 #22
0
    /// <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 TSVector4 vector1, ref TSVector4 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;
    }
コード例 #23
0
 public static TSVector4 Abs(TSVector4 other)
 {
     return(new TSVector4(FP.Abs(other.x), FP.Abs(other.y), FP.Abs(other.z), FP.Abs(other.z)));
 }
コード例 #24
0
 /// <summary>
 /// Calculates the dot product of two vectors.
 /// </summary>
 /// <param name="value1">The first vector.</param>
 /// <param name="value2">The second vector.</param>
 /// <returns>Returns the dot product of both.</returns>
 #region public static FP operator *(JVector value1, JVector value2)
 public static FP operator *(TSVector4 value1, TSVector4 value2)
 {
     return(TSVector4.Dot(ref value1, ref value2));
 }
コード例 #25
0
 /// <summary>
 /// Calculates the dot product of two vectors.
 /// </summary>
 /// <param name="vector1">The first vector.</param>
 /// <param name="vector2">The second vector.</param>
 /// <returns>Returns the dot product of both vectors.</returns>
 #region public static FP Dot(JVector vector1, JVector vector2)
 public static FP Dot(TSVector4 vector1, TSVector4 vector2)
 {
     return(TSVector4.Dot(ref vector1, ref vector2));
 }
コード例 #26
0
 /// <summary>
 /// Calculates the dot product of both vectors.
 /// </summary>
 /// <param name="vector1">The first vector.</param>
 /// <param name="vector2">The second vector.</param>
 /// <returns>Returns the dot product of both vectors.</returns>
 public static FP Dot(ref TSVector4 vector1, ref TSVector4 vector2)
 {
     return(((vector1.x * vector2.x) + (vector1.y * vector2.y)) + (vector1.z * vector2.z) + (vector1.w * vector2.w));
 }
コード例 #27
0
 public static FP Distance(TSVector4 v1, TSVector4 v2)
 {
     return(FP.Sqrt((v1.x - v2.x) * (v1.x - v2.x) + (v1.y - v2.y) * (v1.y - v2.y) + (v1.z - v2.z) * (v1.z - v2.z) + (v1.w - v2.w) * (v1.w - v2.w)));
 }
コード例 #28
0
 public static TSVector4 ClampMagnitude(TSVector4 vector, FP maxLength)
 {
     return(Normalize(vector) * maxLength);
 }
コード例 #29
0
 public static TSVector4 Lerp(TSVector4 from, TSVector4 to, FP percent)
 {
     return(from + (to - from) * percent);
 }