1474 lines
39 KiB
Java
1474 lines
39 KiB
Java
package Microsoft.Xna.Framework;
|
|
|
|
import java.util.Locale;
|
|
|
|
import System.*;
|
|
|
|
/**
|
|
* Defines a vector with four components.
|
|
*
|
|
* @author Halofreak1990
|
|
*/
|
|
public final class Vector4 extends ValueType implements IEquatable<Vector4>
|
|
{
|
|
/**
|
|
* Returns a Vector4 with all of its components set to one.
|
|
*/
|
|
public static final Vector4 One = new Vector4(1f, 1f, 1f, 1f);
|
|
/**
|
|
* Returns the Vector4 (0, 0, 0, 1).
|
|
*/
|
|
public static final Vector4 UnitW = new Vector4(1f, 1f, 1f, 1f);
|
|
/**
|
|
* Returns the Vector4 (1, 0, 0, 0).
|
|
*/
|
|
public static final Vector4 UnitX = new Vector4(1f, 0f, 0f, 0f);
|
|
/**
|
|
* Returns the Vector4 (0, 1, 0, 0).
|
|
*/
|
|
public static final Vector4 UnitY = new Vector4(0f, 1f, 0f, 0f);
|
|
/**
|
|
* Returns the Vector4 (0, 0, 1, 0).
|
|
*/
|
|
public static final Vector4 UnitZ = new Vector4(0f, 0f, 1f, 0f);
|
|
/**
|
|
* Gets or sets the w-component of the vector.
|
|
*/
|
|
public float W;
|
|
/**
|
|
* Gets or sets the x-component of the vector.
|
|
*/
|
|
public float X;
|
|
/**
|
|
* Gets or sets the y-component of the vector.
|
|
*/
|
|
public float Y;
|
|
/**
|
|
* Gets or sets the z-component of the vector.
|
|
*/
|
|
public float Z;
|
|
/**
|
|
* Returns a Vector4 with all of its components set to zero.
|
|
*/
|
|
public static final Vector4 Zero = new Vector4(0f, 0f, 0f, 0f);
|
|
|
|
/**
|
|
* Creates a new instance of Vector4.
|
|
*
|
|
* @param value
|
|
* Value to initialize each component to.
|
|
*/
|
|
public Vector4(float value)
|
|
{
|
|
this.X = this.Y = this.Z = this.W = value;
|
|
}
|
|
|
|
/**
|
|
* Creates a new instance of Vector4.
|
|
*
|
|
* @param value
|
|
* A vector containing the values to initialize x, y, and z components with.
|
|
*
|
|
* @param w
|
|
* Initial value for the w-component of the vector.
|
|
*/
|
|
public Vector4(Vector3 value, float w)
|
|
{
|
|
this.X = value.X;
|
|
this.Y = value.Y;
|
|
this.Z = value.Z;
|
|
this.W = w;
|
|
}
|
|
|
|
/**
|
|
* Creates a new instance of Vector4.
|
|
*
|
|
* @param value
|
|
* A vector containing the values to initialize x and y components with.
|
|
*
|
|
* @param z
|
|
* Initial value for the z-component of the vector.
|
|
*
|
|
* @param w
|
|
* Initial value for the w-component of the vector.
|
|
*/
|
|
public Vector4(Vector2 value, float z, float w)
|
|
{
|
|
this.X = value.X;
|
|
this.Y = value.Y;
|
|
this.Z = z;
|
|
this.W = w;
|
|
}
|
|
|
|
/**
|
|
* Creates a new instance of Vector4.
|
|
*
|
|
* @param x
|
|
* Initial value for the x-component of the vector.
|
|
* @param y
|
|
* Initial value for the y-component of the vector.
|
|
* @param z
|
|
* Initial value for the z-component of the vector.
|
|
*
|
|
* @param w
|
|
* Initial value for the w-component of the vector.
|
|
*/
|
|
public Vector4(float x, float y, float z, float w)
|
|
{
|
|
this.X = x;
|
|
this.Y = y;
|
|
this.Z = z;
|
|
this.W = w;
|
|
}
|
|
|
|
/**
|
|
* Creates a new instance of Vector4.
|
|
*/
|
|
public Vector4()
|
|
{
|
|
this.X = this.Y = this.Z = this.W = 0f;
|
|
}
|
|
|
|
/**
|
|
* Adds the specified vector to the current vector.
|
|
*
|
|
* @param other
|
|
* Source vector.
|
|
*/
|
|
public void Add(Vector4 other)
|
|
{
|
|
Add(this, other, this);
|
|
}
|
|
|
|
/**
|
|
* Adds two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Add(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Add(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Adds two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] Sum of the source vectors.
|
|
*/
|
|
public static void Add(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Returns a Vector4 containing the 4D Cartesian coordinates of a point specified in barycentric (areal) coordinates relative to a 4D triangle.
|
|
*
|
|
* @param value1
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 1 of the triangle.
|
|
*
|
|
* @param value2
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 2 of the triangle.
|
|
*
|
|
* @param value3
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 4 of the triangle.
|
|
*
|
|
* @param amount1
|
|
* Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in value2).
|
|
*
|
|
* @param amount2
|
|
* Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in value3).
|
|
*/
|
|
public static Vector4 Barycentric(Vector4 value1, Vector4 value2, Vector4 value3, float amount1, float amount2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Barycentric(value1, value2, value3, amount1, amount2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a Vector4 containing the 4D Cartesian coordinates of a point specified in barycentric (areal) coordinates relative to a 4D triangle.
|
|
*
|
|
* @param value1
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 1 of the triangle.
|
|
*
|
|
* @param value2
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 2 of the triangle.
|
|
*
|
|
* @param value3
|
|
* A Vector4 containing the 4D Cartesian coordinates of vertex 4 of the triangle.
|
|
*
|
|
* @param amount1
|
|
* Barycentric coordinate b2, which expresses the weighting factor toward vertex 2 (specified in value2).
|
|
*
|
|
* @param amount2
|
|
* Barycentric coordinate b3, which expresses the weighting factor toward vertex 3 (specified in value3).
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The 4D Cartesian coordinates of the specified point are placed in this Vector4 on exit.
|
|
*/
|
|
public static void Barycentric(Vector4 value1, Vector4 value2, Vector4 value3, float amount1, float amount2, Vector4 result)
|
|
{
|
|
result.X = (value1.X + (amount1 * (value2.X - value1.X))) + (amount2 * (value3.X - value1.X));
|
|
result.Y = (value1.Y + (amount1 * (value2.Y - value1.Y))) + (amount2 * (value3.Y - value1.Y));
|
|
result.Z = (value1.Z + (amount1 * (value2.Z - value1.Z))) + (amount2 * (value3.Z - value1.Z));
|
|
result.W = (value1.W + (amount1 * (value2.W - value1.W))) + (amount2 * (value3.W - value1.W));
|
|
}
|
|
|
|
/**
|
|
* Performs a Catmull-Rom interpolation using the specified positions.
|
|
*
|
|
* @param value1
|
|
* The first position in the interpolation.
|
|
*
|
|
* @param value2
|
|
* The second position in the interpolation.
|
|
*
|
|
* @param value3
|
|
* The third position in the interpolation.
|
|
*
|
|
* @param value4
|
|
* The fourth position in the interpolation.
|
|
*
|
|
* @param amount
|
|
* Weighting factor.
|
|
*/
|
|
public static Vector4 CatmullRom(Vector4 value1, Vector4 value2, Vector4 value3, Vector4 value4, float amount)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
CatmullRom(value1, value2, value3, value4, amount, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Performs a Catmull-Rom interpolation using the specified positions.
|
|
*
|
|
* @param value1
|
|
* The first position in the interpolation.
|
|
*
|
|
* @param value2
|
|
* The second position in the interpolation.
|
|
*
|
|
* @param value3
|
|
* The third position in the interpolation.
|
|
*
|
|
* @param value4
|
|
* The fourth position in the interpolation.
|
|
*
|
|
* @param amount
|
|
* Weighting factor.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] A vector that is the result of the Catmull-Rom interpolation.
|
|
*/
|
|
public static void CatmullRom(Vector4 value1, Vector4 value2, Vector4 value3, Vector4 value4, float amount, Vector4 result)
|
|
{
|
|
float num = amount * amount;
|
|
float num2 = amount * num;
|
|
result.X = 0.5f * ((((2f * value2.X) + ((-value1.X + value3.X) * amount)) + (((((2f * value1.X) - (5f * value2.X)) + (4f * value3.X)) - value4.X) * num)) + ((((-value1.X + (3f * value2.X)) - (3f * value3.X)) + value4.X) * num2));
|
|
result.Y = 0.5f * ((((2f * value2.Y) + ((-value1.Y + value3.Y) * amount)) + (((((2f * value1.Y) - (5f * value2.Y)) + (4f * value3.Y)) - value4.Y) * num)) + ((((-value1.Y + (3f * value2.Y)) - (3f * value3.Y)) + value4.Y) * num2));
|
|
result.Z = 0.5f * ((((2f * value2.Z) + ((-value1.Z + value3.Z) * amount)) + (((((2f * value1.Z) - (5f * value2.Z)) + (4f * value3.Z)) - value4.Z) * num)) + ((((-value1.Z + (3f * value2.Z)) - (3f * value3.Z)) + value4.Z) * num2));
|
|
result.W = 0.5f * ((((2f * value2.W) + ((-value1.W + value3.W) * amount)) + (((((2f * value1.W) - (5f * value2.W)) + (4f * value3.W)) - value4.W) * num)) + ((((-value1.W + (3f * value2.W)) - (3f * value3.W)) + value4.W) * num2));
|
|
}
|
|
|
|
/**
|
|
* Restricts a value to be within a specified range.
|
|
*
|
|
* @param value1
|
|
* The value to clamp.
|
|
*
|
|
* @param min
|
|
* The minimum value.
|
|
*
|
|
* @param max
|
|
* The maximum value.
|
|
*/
|
|
public static Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Clamp(value1, min, max, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Restricts a value to be within a specified range.
|
|
*
|
|
* @param value1
|
|
* The value to clamp.
|
|
*
|
|
* @param min
|
|
* The minimum value.
|
|
*
|
|
* @param max
|
|
* The maximum value.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The clamped value.
|
|
*/
|
|
public static void Clamp(Vector4 value1, Vector4 min, Vector4 max, Vector4 result)
|
|
{
|
|
result.X = MathHelper.Clamp(value1.X, min.X, max.X);
|
|
result.Y = MathHelper.Clamp(value1.Y, min.Y, max.Y);
|
|
result.Z = MathHelper.Clamp(value1.Z, min.Z, max.Z);
|
|
result.W = MathHelper.Clamp(value1.W, min.W, max.W);
|
|
}
|
|
|
|
/**
|
|
* Calculates the distance between two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static float Distance(Vector4 value1, Vector4 value2)
|
|
{
|
|
float num4 = value1.X - value2.X;
|
|
float num3 = value1.Y - value2.Y;
|
|
float num2 = value1.Z - value2.Z;
|
|
float num = value1.W - value2.W;
|
|
float num5 = (((num4 * num4) + (num3 * num3)) + (num2 * num2)) + (num * num);
|
|
return (float) Math.sqrt((double) num5);
|
|
}
|
|
|
|
/**
|
|
* Calculates the distance between two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The distance between the vectors.
|
|
*/
|
|
public static void Distance(Vector4 value1, Vector4 value2, float result)
|
|
{
|
|
float num4 = value1.X - value2.X;
|
|
float num3 = value1.Y - value2.Y;
|
|
float num2 = value1.Z - value2.Z;
|
|
float num = value1.W - value2.W;
|
|
float num5 = (((num4 * num4) + (num3 * num3)) + (num2 * num2)) + (num * num);
|
|
result = (float) Math.sqrt((double) num5);
|
|
}
|
|
|
|
/**
|
|
* Calculates the distance between two vectors squared.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static float DistanceSquared(Vector4 value1, Vector4 value2)
|
|
{
|
|
float num4 = value1.X - value2.X;
|
|
float num3 = value1.Y - value2.Y;
|
|
float num2 = value1.Z - value2.Z;
|
|
float num = value1.W - value2.W;
|
|
return ((((num4 * num4) + (num3 * num3)) + (num2 * num2)) + (num * num));
|
|
}
|
|
|
|
/**
|
|
* Calculates the distance between two vectors squared.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The distance between the two vectors squared.
|
|
*/
|
|
public static void DistanceSquared(Vector4 value1, Vector4 value2, float result)
|
|
{
|
|
float num4 = value1.X - value2.X;
|
|
float num3 = value1.Y - value2.Y;
|
|
float num2 = value1.Z - value2.Z;
|
|
float num = value1.W - value2.W;
|
|
result = (((num4 * num4) + (num3 * num3)) + (num2 * num2)) + (num * num);
|
|
}
|
|
|
|
/**
|
|
* Divides the components of the current vector by the components of another vector.
|
|
*
|
|
* @param other
|
|
* Divisor vector.
|
|
*/
|
|
public void Divide(Vector4 other)
|
|
{
|
|
Divide(this, other, this);
|
|
}
|
|
|
|
/**
|
|
* Divides the components of a vector by the components of another vector.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Divisor vector.
|
|
*/
|
|
public static Vector4 Divide(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Divide(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Divides the current vector by a scalar value.
|
|
*
|
|
* @param divider
|
|
* The divisor.
|
|
*/
|
|
public void Divide(float divider)
|
|
{
|
|
Divide(this, divider, this);
|
|
}
|
|
|
|
/**
|
|
* Divides a vector by a scalar value.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param divider
|
|
* The divisor.
|
|
*/
|
|
public static Vector4 Divide(Vector4 value1, float divider)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Divide(value1, divider, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Divides the components of a vector by the components of another vector.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Divisor vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the division.
|
|
*/
|
|
public static void Divide(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Divides a vector by a scalar value.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param divider
|
|
* The divisor.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the division.
|
|
*/
|
|
public static void Divide(Vector4 value1, float divider, Vector4 result)
|
|
{
|
|
float num = 1f / divider;
|
|
result.X = value1.X * num;
|
|
result.Y = value1.Y * num;
|
|
result.Z = value1.Z * num;
|
|
result.W = value1.W * num;
|
|
}
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors.
|
|
*
|
|
* @param vector1
|
|
* Source vector.
|
|
*
|
|
* @param vector2
|
|
* Source vector.
|
|
*/
|
|
public static float Dot(Vector4 vector1, Vector4 vector2)
|
|
{
|
|
return ((((vector1.X * vector2.X) + (vector1.Y * vector2.Y)) + (vector1.Z * vector2.Z)) + (vector1.W * vector2.W));
|
|
}
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors.
|
|
*
|
|
* @param vector1
|
|
* Source vector.
|
|
*
|
|
* @param vector2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The dot product of the two vectors.
|
|
*/
|
|
public static void Dot(Vector4 vector1, Vector4 vector2, float result)
|
|
{
|
|
result = (((vector1.X * vector2.X) + (vector1.Y * vector2.Y)) + (vector1.Z * vector2.Z)) + (vector1.W * vector2.W);
|
|
}
|
|
|
|
/**
|
|
* Returns a value that indicates whether the current instance is equal to a specified object.
|
|
*
|
|
* @param obj
|
|
* Object with which to make the comparison.
|
|
*/
|
|
@Override
|
|
public boolean equals(Object obj)
|
|
{
|
|
return (obj != null && obj instanceof Vector4) ? this.Equals((Vector4)obj) : false;
|
|
}
|
|
|
|
/**
|
|
* Determines whether the specified Object is equal to the Vector4.
|
|
*
|
|
* @param other
|
|
* The Vector4 to compare with the current Vector4.
|
|
*/
|
|
public boolean Equals(Vector4 other)
|
|
{
|
|
return ((((this.X == other.X) && (this.Y == other.Y)) && (this.Z == other.Z)) && (this.W == other.W));
|
|
}
|
|
|
|
/**
|
|
* Gets the hash code of this object.
|
|
*/
|
|
@Override
|
|
public int hashCode()
|
|
{
|
|
return ((((int)this.X ^ (int)this.Y) ^ (int)this.Z) ^ (int)this.W);
|
|
}
|
|
|
|
/**
|
|
* Performs a Hermite spline interpolation.
|
|
*
|
|
* @param value1
|
|
* Source position vector.
|
|
*
|
|
* @param tangent1
|
|
* Source tangent vector.
|
|
*
|
|
* @param value2
|
|
* Source position vector.
|
|
*
|
|
* @param tangent2
|
|
* Source tangent vector.
|
|
*
|
|
* @param amount
|
|
* Weighting factor.
|
|
*/
|
|
public static Vector4 Hermite(Vector4 value1, Vector4 tangent1, Vector4 value2, Vector4 tangent2, float amount)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Hermite(value1, tangent1, value2, tangent2, amount, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Performs a Hermite spline interpolation.
|
|
*
|
|
* @param value1
|
|
* Source position vector.
|
|
*
|
|
* @param tangent1
|
|
* Source tangent vector.
|
|
*
|
|
* @param value2
|
|
* Source position vector.
|
|
*
|
|
* @param tangent2
|
|
* Source tangent vector.
|
|
*
|
|
* @param amount
|
|
* Weighting factor.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the Hermite spline interpolation.
|
|
*/
|
|
public static void Hermite(Vector4 value1, Vector4 tangent1, Vector4 value2, Vector4 tangent2, float amount, Vector4 result)
|
|
{
|
|
float num = amount * amount;
|
|
float num6 = amount * num;
|
|
float num5 = ((2f * num6) - (3f * num)) + 1f;
|
|
float num4 = (-2f * num6) + (3f * num);
|
|
float num3 = (num6 - (2f * num)) + amount;
|
|
float num2 = num6 - num;
|
|
result.X = (((value1.X * num5) + (value2.X * num4)) + (tangent1.X * num3)) + (tangent2.X * num2);
|
|
result.Y = (((value1.Y * num5) + (value2.Y * num4)) + (tangent1.Y * num3)) + (tangent2.Y * num2);
|
|
result.Z = (((value1.Z * num5) + (value2.Z * num4)) + (tangent1.Z * num3)) + (tangent2.Z * num2);
|
|
result.W = (((value1.W * num5) + (value2.W * num4)) + (tangent1.W * num3)) + (tangent2.W * num2);
|
|
}
|
|
|
|
/**
|
|
* Calculates the length of the vector.
|
|
*/
|
|
public float Length()
|
|
{
|
|
float num = (((this.X * this.X) + (this.Y * this.Y)) + (this.Z * this.Z)) + (this.W * this.W);
|
|
return (float) Math.sqrt((double) num);
|
|
}
|
|
|
|
/**
|
|
* Calculates the length of the vector squared.
|
|
*/
|
|
public float LengthSquared()
|
|
{
|
|
return ((((this.X * this.X) + (this.Y * this.Y)) + (this.Z * this.Z)) + (this.W * this.W));
|
|
}
|
|
|
|
/**
|
|
* Performs a linear interpolation between two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param amount
|
|
* Value between 0 and 1 indicating the weight of value2.
|
|
*/
|
|
public static Vector4 Lerp(Vector4 value1, Vector4 value2, float amount)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Lerp(value1, value2, amount);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Performs a linear interpolation between two vectors.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param amount
|
|
* Value between 0 and 1 indicating the weight of value2.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the interpolation.
|
|
*/
|
|
public static void Lerp(Vector4 value1, Vector4 value2, float amount, Vector4 result)
|
|
{
|
|
result.X = value1.X + ((value2.X - value1.X) * amount);
|
|
result.Y = value1.Y + ((value2.Y - value1.Y) * amount);
|
|
result.Z = value1.Z + ((value2.Z - value1.Z) * amount);
|
|
result.W = value1.W + ((value2.W - value1.W) * amount);
|
|
}
|
|
|
|
/**
|
|
* Returns a vector that contains the highest value from each matching pair of components.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Max(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Max(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector that contains the highest value from each matching pair of components.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The maximized vector.
|
|
*/
|
|
public static void Max(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector that contains the lowest value from each matching pair of components.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Min(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Min(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector that contains the lowest value from each matching pair of components.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The minimized vector.
|
|
*/
|
|
public static void Min(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Multiplies the components of the current vector by the components of another vector.
|
|
*
|
|
* @param other
|
|
* Source vector.
|
|
*/
|
|
public void Multiply(Vector4 other)
|
|
{
|
|
Multiply(this, other, this);
|
|
}
|
|
|
|
/**
|
|
* Multiplies the components of two vectors by each other.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Multiply(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Multiply(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Multiplies the current vector by a scalar.
|
|
*
|
|
* @param scaleFactor
|
|
* Scalar value.
|
|
*/
|
|
public void Multiply(float scaleFactor)
|
|
{
|
|
Multiply(this, scaleFactor, this);
|
|
}
|
|
|
|
/**
|
|
* Multiplies a vector by a scalar.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param scaleFactor
|
|
* Scalar value.
|
|
*/
|
|
public static Vector4 Multiply(Vector4 value1, float scaleFactor)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Multiply(value1, scaleFactor, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Multiplies the components of two vectors by each other.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the multiplication.
|
|
*/
|
|
public static void Multiply(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Multiplies a vector by a scalar.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param scaleFactor
|
|
* Scalar value.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the multiplication.
|
|
*/
|
|
public static void Multiply(Vector4 value1, float scaleFactor, Vector4 result)
|
|
{
|
|
result.X = value1.X * scaleFactor;
|
|
result.Y = value1.Y * scaleFactor;
|
|
result.Z = value1.Z * scaleFactor;
|
|
result.W = value1.W * scaleFactor;
|
|
}
|
|
|
|
/**
|
|
* Returns the current vector pointing in the opposite direction.
|
|
*/
|
|
public void Negate()
|
|
{
|
|
Negate(this, this);
|
|
}
|
|
|
|
/**
|
|
* Returns a vector pointing in the opposite direction.
|
|
*
|
|
* @param value
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Negate(Vector4 value)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Negate(value, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a vector pointing in the opposite direction.
|
|
*
|
|
* @param value
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] Vector pointing in the opposite direction.
|
|
*/
|
|
public static void Negate(Vector4 value, Vector4 result)
|
|
{
|
|
result.X = -value.X;
|
|
result.Y = -value.Y;
|
|
result.Z = -value.Z;
|
|
result.W = -value.W;
|
|
}
|
|
|
|
/**
|
|
* Turns the current vector into a unit vector.
|
|
*/
|
|
public void Normalize()
|
|
{
|
|
float num2 = (((this.X * this.X) + (this.Y * this.Y)) + (this.Z * this.Z)) + (this.W * this.W);
|
|
float num = 1f / ((float) Math.sqrt((double) num2));
|
|
this.X *= num;
|
|
this.Y *= num;
|
|
this.Z *= num;
|
|
this.W *= num;
|
|
}
|
|
|
|
/**
|
|
* Creates a unit vector from the specified vector.
|
|
*
|
|
* @param vector
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Normalize(Vector4 vector)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Normalize(vector, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a normalized version of the specified vector.
|
|
*
|
|
* @param vector
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The normalized vector.
|
|
*/
|
|
public static void Normalize(Vector4 vector, Vector4 result)
|
|
{
|
|
float num2 = (((vector.X * vector.X) + (vector.Y * vector.Y)) + (vector.Z * vector.Z)) + (vector.W * vector.W);
|
|
float num = 1f / ((float) Math.sqrt((double) num2));
|
|
result.X = vector.X * num;
|
|
result.Y = vector.Y * num;
|
|
result.Z = vector.Z * num;
|
|
result.W = vector.W * num;
|
|
}
|
|
|
|
/**
|
|
* Interpolates between two values using a cubic equation.
|
|
*
|
|
* @param value1
|
|
* Source value.
|
|
*
|
|
* @param value2
|
|
* Source value.
|
|
*
|
|
* @param amount
|
|
* Weighting value.
|
|
*/
|
|
public static Vector4 SmoothStep(Vector4 value1, Vector4 value2, float amount)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
SmoothStep(value1, value2, amount, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Interpolates between two values using a cubic equation.
|
|
*
|
|
* @param value1
|
|
* Source value.
|
|
*
|
|
* @param value2
|
|
* Source value.
|
|
*
|
|
* @param amount
|
|
* Weighting value.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The interpolated value.
|
|
*/
|
|
public static void SmoothStep(Vector4 value1, Vector4 value2, float amount, Vector4 result)
|
|
{
|
|
amount = (amount > 1f) ? 1f : ((amount < 0f) ? 0f : amount);
|
|
amount = (amount * amount) * (3f - (2f * amount));
|
|
result.X = value1.X + ((value2.X - value1.X) * amount);
|
|
result.Y = value1.Y + ((value2.Y - value1.Y) * amount);
|
|
result.Z = value1.Z + ((value2.Z - value1.Z) * amount);
|
|
result.W = value1.W + ((value2.W - value1.W) * amount);
|
|
}
|
|
|
|
/**
|
|
* Subtracts a vector from the current vector.
|
|
*
|
|
* @param other
|
|
*/
|
|
public void Subtract(Vector4 other)
|
|
{
|
|
Subtract(this, other, this);
|
|
}
|
|
|
|
/**
|
|
* Subtracts a vector from a vector.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*/
|
|
public static Vector4 Subtract(Vector4 value1, Vector4 value2)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Subtract(value1, value2, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Subtracts a vector from a vector.
|
|
*
|
|
* @param value1
|
|
* Source vector.
|
|
*
|
|
* @param value2
|
|
* Source vector.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The result of the subtraction.
|
|
*/
|
|
public static void Subtract(Vector4 value1, Vector4 value2, Vector4 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;
|
|
}
|
|
|
|
/**
|
|
* Retrieves a string representation of the current object.
|
|
*/
|
|
@Override
|
|
public String toString()
|
|
{
|
|
return String.format(Locale.getDefault(), "{X:%f Y:%f Z:%f W:%f}", this.X, this.Y, this.Z, this.W);
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector2 by the given Matrix.
|
|
*
|
|
* @param position
|
|
* The source Vector2.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*/
|
|
public static Vector4 Transform(Vector2 position, Matrix matrix)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(position, matrix, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector2 by a specified Quaternion into a Vector4.
|
|
*
|
|
* @param value
|
|
* The Vector2 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*/
|
|
public static Vector4 Transform(Vector2 value, Quaternion rotation)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(value, rotation, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector3 by the given Matrix.
|
|
*
|
|
* @param position
|
|
* The source Vector3.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*/
|
|
public static Vector4 Transform(Vector3 position, Matrix matrix)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(position, matrix, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector3 by a specified Quaternion into a Vector4.
|
|
*
|
|
* @param value
|
|
* The Vector3 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*/
|
|
public static Vector4 Transform(Vector3 value, Quaternion rotation)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(value, rotation, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector4 by the specified Matrix.
|
|
*
|
|
* @param vector
|
|
* The source Vector4.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*/
|
|
public static Vector4 Transform(Vector4 vector, Matrix matrix)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(vector, matrix, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector4 by a specified Quaternion.
|
|
*
|
|
* @param value
|
|
* The Vector4 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*/
|
|
public static Vector4 Transform(Vector4 value, Quaternion rotation)
|
|
{
|
|
Vector4 result = new Vector4();
|
|
Transform(value, rotation, result);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Transforms an array of Vector4s by a specified Quaternion.
|
|
*
|
|
* @param sourceArray
|
|
* The array of Vector4s to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*
|
|
* @param destinationArray
|
|
* The existing destination array into which the transformed Vector4s are written.
|
|
*/
|
|
public static void Transform(Vector4[] sourceArray, Quaternion rotation, Vector4[] destinationArray)
|
|
{
|
|
Transform(sourceArray, 0, rotation, destinationArray, 0, sourceArray.length);
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector2 by the given Matrix.
|
|
*
|
|
* @param position
|
|
* The source Vector2.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector2 position, Matrix matrix, Vector4 result)
|
|
{
|
|
float num4 = ((position.X * matrix.M11) + (position.Y * matrix.M21)) + matrix.M41;
|
|
float num3 = ((position.X * matrix.M12) + (position.Y * matrix.M22)) + matrix.M42;
|
|
float num2 = ((position.X * matrix.M13) + (position.Y * matrix.M23)) + matrix.M43;
|
|
float num = ((position.X * matrix.M14) + (position.Y * matrix.M24)) + matrix.M44;
|
|
result.X = num4;
|
|
result.Y = num3;
|
|
result.Z = num2;
|
|
result.W = num;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector2 by a specified Quaternion into a Vector4.
|
|
*
|
|
* @param value
|
|
* The Vector2 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector2 value, Quaternion rotation, Vector4 result)
|
|
{
|
|
float num6 = rotation.X + rotation.X;
|
|
float num2 = rotation.Y + rotation.Y;
|
|
float num = rotation.Z + rotation.Z;
|
|
float num15 = rotation.W * num6;
|
|
float num14 = rotation.W * num2;
|
|
float num5 = rotation.W * num;
|
|
float num13 = rotation.X * num6;
|
|
float num4 = rotation.X * num2;
|
|
float num12 = rotation.X * num;
|
|
float num11 = rotation.Y * num2;
|
|
float num10 = rotation.Y * num;
|
|
float num3 = rotation.Z * num;
|
|
float num9 = (value.X * ((1f - num11) - num3)) + (value.Y * (num4 - num5));
|
|
float num8 = (value.X * (num4 + num5)) + (value.Y * ((1f - num13) - num3));
|
|
float num7 = (value.X * (num12 - num14)) + (value.Y * (num10 + num15));
|
|
result.X = num9;
|
|
result.Y = num8;
|
|
result.Z = num7;
|
|
result.W = 1f;
|
|
}
|
|
|
|
/**
|
|
* Transforms an array of Vector4s by a specified Matrix.
|
|
*
|
|
* @param sourceArray
|
|
* The array of Vector4s to transform.
|
|
*
|
|
* @param matrix
|
|
* The transform Matrix to apply.
|
|
*
|
|
* @param destinationArray
|
|
* The existing destination array into which the transformed Vector4s are written.
|
|
*/
|
|
public static void Transform(Vector4[] sourceArray, Matrix matrix, Vector4[] destinationArray)
|
|
{
|
|
Transform(sourceArray, 0, matrix, destinationArray, 0, sourceArray.length);
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector3 by the given Matrix.
|
|
*
|
|
* @param position
|
|
* The source Vector3.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector3 position, Matrix matrix, Vector4 result)
|
|
{
|
|
float num4 = (((position.X * matrix.M11) + (position.Y * matrix.M21)) + (position.Z * matrix.M31)) + matrix.M41;
|
|
float num3 = (((position.X * matrix.M12) + (position.Y * matrix.M22)) + (position.Z * matrix.M32)) + matrix.M42;
|
|
float num2 = (((position.X * matrix.M13) + (position.Y * matrix.M23)) + (position.Z * matrix.M33)) + matrix.M43;
|
|
float num = (((position.X * matrix.M14) + (position.Y * matrix.M24)) + (position.Z * matrix.M34)) + matrix.M44;
|
|
result.X = num4;
|
|
result.Y = num3;
|
|
result.Z = num2;
|
|
result.W = num;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector3 by a specified Quaternion into a Vector4.
|
|
*
|
|
* @param value
|
|
* The Vector3 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector3 value, Quaternion rotation, Vector4 result)
|
|
{
|
|
float num12 = rotation.X + rotation.X;
|
|
float num2 = rotation.Y + rotation.Y;
|
|
float num = rotation.Z + rotation.Z;
|
|
float num11 = rotation.W * num12;
|
|
float num10 = rotation.W * num2;
|
|
float num9 = rotation.W * num;
|
|
float num8 = rotation.X * num12;
|
|
float num7 = rotation.X * num2;
|
|
float num6 = rotation.X * num;
|
|
float num5 = rotation.Y * num2;
|
|
float num4 = rotation.Y * num;
|
|
float num3 = rotation.Z * num;
|
|
float num15 = ((value.X * ((1f - num5) - num3)) + (value.Y * (num7 - num9))) + (value.Z * (num6 + num10));
|
|
float num14 = ((value.X * (num7 + num9)) + (value.Y * ((1f - num8) - num3))) + (value.Z * (num4 - num11));
|
|
float num13 = ((value.X * (num6 - num10)) + (value.Y * (num4 + num11))) + (value.Z * ((1f - num8) - num5));
|
|
result.X = num15;
|
|
result.Y = num14;
|
|
result.Z = num13;
|
|
result.W = 1f;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector4 by the given Matrix.
|
|
*
|
|
* @param vector
|
|
* The source Vector4.
|
|
*
|
|
* @param matrix
|
|
* The transformation Matrix.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector4 vector, Matrix matrix, Vector4 result)
|
|
{
|
|
float num4 = (((vector.X * matrix.M11) + (vector.Y * matrix.M21)) + (vector.Z * matrix.M31)) + (vector.W * matrix.M41);
|
|
float num3 = (((vector.X * matrix.M12) + (vector.Y * matrix.M22)) + (vector.Z * matrix.M32)) + (vector.W * matrix.M42);
|
|
float num2 = (((vector.X * matrix.M13) + (vector.Y * matrix.M23)) + (vector.Z * matrix.M33)) + (vector.W * matrix.M43);
|
|
float num = (((vector.X * matrix.M14) + (vector.Y * matrix.M24)) + (vector.Z * matrix.M34)) + (vector.W * matrix.M44);
|
|
result.X = num4;
|
|
result.Y = num3;
|
|
result.Z = num2;
|
|
result.W = num;
|
|
}
|
|
|
|
/**
|
|
* Transforms a Vector4 by a specified Quaternion.
|
|
*
|
|
* @param value
|
|
* The Vector4 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*
|
|
* @param result
|
|
* [OutAttribute] The Vector4 resulting from the transformation.
|
|
*/
|
|
public static void Transform(Vector4 value, Quaternion rotation, Vector4 result)
|
|
{
|
|
float num12 = rotation.X + rotation.X;
|
|
float num2 = rotation.Y + rotation.Y;
|
|
float num = rotation.Z + rotation.Z;
|
|
float num11 = rotation.W * num12;
|
|
float num10 = rotation.W * num2;
|
|
float num9 = rotation.W * num;
|
|
float num8 = rotation.X * num12;
|
|
float num7 = rotation.X * num2;
|
|
float num6 = rotation.X * num;
|
|
float num5 = rotation.Y * num2;
|
|
float num4 = rotation.Y * num;
|
|
float num3 = rotation.Z * num;
|
|
float num15 = ((value.X * ((1f - num5) - num3)) + (value.Y * (num7 - num9))) + (value.Z * (num6 + num10));
|
|
float num14 = ((value.X * (num7 + num9)) + (value.Y * ((1f - num8) - num3))) + (value.Z * (num4 - num11));
|
|
float num13 = ((value.X * (num6 - num10)) + (value.Y * (num4 + num11))) + (value.Z * ((1f - num8) - num5));
|
|
result.X = num15;
|
|
result.Y = num14;
|
|
result.Z = num13;
|
|
result.W = value.W;
|
|
}
|
|
|
|
/**
|
|
* Transforms a specified range in an array of Vector4s by a specified Matrix into a specified range in a destination array.
|
|
*
|
|
* @param sourceArray
|
|
* The array of Vector4s containing the range to transform.
|
|
*
|
|
* @param sourceIndex
|
|
* The index in the source array of the first Vector4 to transform.
|
|
*
|
|
* @param matrix
|
|
* The transform Matrix to apply.
|
|
*
|
|
* @param destinationArray
|
|
* The existing destination array of Vector4s into which to write the results.
|
|
*
|
|
* @param destinationIndex
|
|
* The index in the destination array of the first result Vector4 to write.
|
|
*
|
|
* @param length
|
|
* The number of Vector4s to transform.
|
|
*/
|
|
public static void Transform(Vector4[] sourceArray, int sourceIndex, Matrix matrix, Vector4[] destinationArray, int destinationIndex, int length)
|
|
{
|
|
if (sourceArray == null)
|
|
{
|
|
throw new ArgumentNullException("sourceArray");
|
|
}
|
|
if (destinationArray == null)
|
|
{
|
|
throw new ArgumentNullException("destinationArray");
|
|
}
|
|
if (sourceArray.length < (sourceIndex + length))
|
|
{
|
|
throw new ArgumentException("Source array must be equal or bigger than requested length.");
|
|
}
|
|
if (destinationArray.length < (destinationIndex + length))
|
|
{
|
|
throw new ArgumentException("Target array size must be equal to, or bigger than source array size.");
|
|
}
|
|
while (length > 0)
|
|
{
|
|
float x = sourceArray[sourceIndex].X;
|
|
float y = sourceArray[sourceIndex].Y;
|
|
float z = sourceArray[sourceIndex].Z;
|
|
float w = sourceArray[sourceIndex].W;
|
|
destinationArray[destinationIndex].X = (((x * matrix.M11) + (y * matrix.M21)) + (z * matrix.M31)) + (w * matrix.M41);
|
|
destinationArray[destinationIndex].Y = (((x * matrix.M12) + (y * matrix.M22)) + (z * matrix.M32)) + (w * matrix.M42);
|
|
destinationArray[destinationIndex].Z = (((x * matrix.M13) + (y * matrix.M23)) + (z * matrix.M33)) + (w * matrix.M43);
|
|
destinationArray[destinationIndex].W = (((x * matrix.M14) + (y * matrix.M24)) + (z * matrix.M34)) + (w * matrix.M44);
|
|
sourceIndex++;
|
|
destinationIndex++;
|
|
length--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Transforms a specified range in an array of Vector4s by a specified Quaternion into a specified range in a destination array.
|
|
*
|
|
* @param sourceArray
|
|
* The array of Vector4s containing the range to transform.
|
|
*
|
|
* @param sourceIndex
|
|
* The index in the source array of the first Vector4 to transform.
|
|
*
|
|
* @param rotation
|
|
* The Quaternion rotation to apply.
|
|
*
|
|
* @param destinationArray
|
|
* The existing destination array of Vector4s into which to write the results.
|
|
*
|
|
* @param destinationIndex
|
|
* The index in the destination array of the first result Vector4 to write.
|
|
*
|
|
* @param length
|
|
* The number of Vector4s to transform.
|
|
*/
|
|
public static void Transform(Vector4[] sourceArray, int sourceIndex, Quaternion rotation, Vector4[] destinationArray, int destinationIndex, int length)
|
|
{
|
|
if (sourceArray == null)
|
|
{
|
|
throw new ArgumentNullException("sourceArray");
|
|
}
|
|
if (destinationArray == null)
|
|
{
|
|
throw new ArgumentNullException("destinationArray");
|
|
}
|
|
if (sourceArray.length < (sourceIndex + length))
|
|
{
|
|
throw new ArgumentException("Source array must be equal to, or bigger than requested length.");
|
|
}
|
|
if (destinationArray.length < (destinationIndex + length))
|
|
{
|
|
throw new ArgumentException("Target array size must be equal to, or bigger than source array size.");
|
|
}
|
|
float num15 = rotation.X + rotation.X;
|
|
float num5 = rotation.Y + rotation.Y;
|
|
float num = rotation.Z + rotation.Z;
|
|
float num14 = rotation.W * num15;
|
|
float num13 = rotation.W * num5;
|
|
float num12 = rotation.W * num;
|
|
float num11 = rotation.X * num15;
|
|
float num10 = rotation.X * num5;
|
|
float num9 = rotation.X * num;
|
|
float num8 = rotation.Y * num5;
|
|
float num7 = rotation.Y * num;
|
|
float num6 = rotation.Z * num;
|
|
float num25 = (1f - num8) - num6;
|
|
float num24 = num10 - num12;
|
|
float num23 = num9 + num13;
|
|
float num22 = num10 + num12;
|
|
float num21 = (1f - num11) - num6;
|
|
float num20 = num7 - num14;
|
|
float num19 = num9 - num13;
|
|
float num18 = num7 + num14;
|
|
float num17 = (1f - num11) - num8;
|
|
while (length > 0)
|
|
{
|
|
float x = sourceArray[sourceIndex].X;
|
|
float y = sourceArray[sourceIndex].Y;
|
|
float z = sourceArray[sourceIndex].Z;
|
|
float w = sourceArray[sourceIndex].W;
|
|
destinationArray[destinationIndex].X = ((x * num25) + (y * num24)) + (z * num23);
|
|
destinationArray[destinationIndex].Y = ((x * num22) + (y * num21)) + (z * num20);
|
|
destinationArray[destinationIndex].Z = ((x * num19) + (y * num18)) + (z * num17);
|
|
destinationArray[destinationIndex].W = w;
|
|
sourceIndex++;
|
|
destinationIndex++;
|
|
length--;
|
|
}
|
|
}
|
|
}
|