public static VectorF CrossProduct2D(VectorFParam1_3 left, VectorFParam1_3 right)
{
/* Cross product of A(x, y, _, _) and B(x, y, _, _) is
* 'E = (Ax * By) - (Ay * Bx)'
* 'E'. We expand this (like with DotProduct) to the whole vector
*/
if (Sse.IsSupported)
{
// Transform B(x, y, ?, ?) to (y, x, y, x)
VectorF permute = Sse.Shuffle(right, right, Shuffle(0, 1, 0, 1));
// Multiply A(x, y, ?, ?) by B(y, x, y, x)
// Resulting in (Ax * By, Ay * Bx, ?, ?)
permute = Sse.Multiply(left, right);
// Create a vector of (Ay * Bx, ?, ?, ?, ?)
VectorF temp = Sse.Shuffle(permute, permute, Shuffle(1, 0, 0, 0));
// Subtract it to get ((Ax * By) - (Ay * Bx), ?, ?, ?) the desired result
permute = Sse.Subtract(permute, temp);
// Fill the vector with it (like DotProduct)
return(Sse.Shuffle(permute, permute, Shuffle(0, 0, 0, 0)));
}
return(CrossProduct2D_Software(left, right));
}
public static VectorF Normalize4D(VectorFParam1_3 vector)
{
if (Sse41.IsSupported)
{
// This multiplies the first 4 elems of each and broadcasts it into each element of the returning vector
const byte control = 0b_1111_1111;
return(Sse.Divide(vector, Sse41.DotProduct(vector, vector, control)));
}
else if (Sse3.IsSupported)
{
VectorF mul = Sse.Multiply(vector, vector);
mul = Sse3.HorizontalAdd(mul, mul);
return(Sse.Divide(vector, Sse.Sqrt(Sse3.HorizontalAdd(mul, mul))));
}
else if (Sse.IsSupported)
{
VectorF copy = vector;
VectorF mul = Sse.Multiply(vector, copy);
copy = Sse.Shuffle(copy, mul, Shuffle(1, 0, 0, 0));
copy = Sse.Add(copy, mul);
mul = Sse.Shuffle(mul, copy, Shuffle(0, 3, 0, 0));
mul = Sse.AddScalar(mul, copy);
return(Sse.Divide(vector, Sse.Sqrt(Sse.Shuffle(mul, mul, Shuffle(2, 2, 2, 2)))));
}
return(Normalize4D_Software(vector));
}
public static Vector128 <float> DotProduct2D_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
Helpers.X(left) * Helpers.X(right) +
+Helpers.Y(left) * Helpers.Y(right)
));
}
public static VectorF CrossProduct4D(VectorFParam1_3 one, VectorFParam1_3 two, VectorFParam1_3 three)
{
throw new NotImplementedException();
// hardware
return(CrossProduct4D_Software(one, two, three));
}
public static Vector128 <float> CrossProduct4D_Software(VectorFParam1_3 one, VectorFParam1_3 two, VectorFParam1_3 three)
{
return(Vector128.Create(
(two.GetElement(2) * three.GetElement(3) - two.GetElement(3) * three.GetElement(2)) *
one.GetElement(1) -
(two.GetElement(1) * three.GetElement(3) - two.GetElement(3) * three.GetElement(1)) *
one.GetElement(2) +
(two.GetElement(1) * three.GetElement(2) - two.GetElement(2) * three.GetElement(1)) *
one.GetElement(3),
(two.GetElement(3) * three.GetElement(2) - two.GetElement(2) * three.GetElement(3)) *
one.GetElement(0) -
(two.GetElement(3) * three.GetElement(0) - two.GetElement(0) * three.GetElement(3)) *
one.GetElement(2) +
(two.GetElement(2) * three.GetElement(0) - two.GetElement(0) * three.GetElement(2)) *
one.GetElement(3),
(two.GetElement(1) * three.GetElement(3) - two.GetElement(3) * three.GetElement(1)) *
one.GetElement(0) -
(two.GetElement(0) * three.GetElement(3) - two.GetElement(3) * three.GetElement(0)) *
one.GetElement(1) +
(two.GetElement(0) * three.GetElement(1) - two.GetElement(1) * three.GetElement(0)) *
one.GetElement(3),
(two.GetElement(2) * three.GetElement(1) - two.GetElement(1) * three.GetElement(2)) *
one.GetElement(0) -
(two.GetElement(2) * three.GetElement(0) - two.GetElement(0) * three.GetElement(2)) *
one.GetElement(1) +
(two.GetElement(1) * three.GetElement(0) - two.GetElement(0) * three.GetElement(1)) *
one.GetElement(2)
));
}
public static VectorF DotProduct4D(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse41.IsSupported)
{
// This multiplies the first 4 elems of each and broadcasts it into each element of the returning vector
const byte control = 0b_1111_1111;
return(Sse41.DotProduct(left, right, control));
}
else if (Sse3.IsSupported)
{
VectorF mul = Sse.Multiply(left, right);
mul = Sse3.HorizontalAdd(mul, mul);
return(Sse3.HorizontalAdd(mul, mul));
}
else if (Sse.IsSupported)
{
VectorF copy = right;
VectorF mul = Sse.Multiply(left, copy);
copy = Sse.Shuffle(copy, mul, Shuffle(1, 0, 0, 0));
copy = Sse.Add(copy, mul);
mul = Sse.Shuffle(mul, copy, Shuffle(0, 3, 0, 0));
mul = Sse.AddScalar(mul, copy);
return(Sse.Shuffle(mul, mul, Shuffle(2, 2, 2, 2)));
}
return(DotProduct4D_Software(left, right));
}
public static Vector128 <float> Normalize4D_Software(VectorFParam1_3 vector)
{
// No software fallback needed, these methods cover it
Vector128 <float> magnitude = Length4D_Software(vector);
return(Divide_Software(vector, magnitude));
}
public static VectorF Xor(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.Xor(left, right));
}
return(Xor_Software(left, right));
}
public static VectorF DotProduct4D_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
Helpers.X(left) * Helpers.X(right)
+ Helpers.Y(left) * Helpers.Y(right)
+ Helpers.Z(left) * Helpers.Z(right)
+ Helpers.W(left) * Helpers.W(right)
));
}
public static VectorF Subtract(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.Subtract(left, right));
}
return(Subtract_Software(left, right));
}
public static VectorF Sqrt(VectorFParam1_3 vector)
{
if (Sse.IsSupported)
{
return(Sse.Sqrt(vector));
}
return(Sqrt_Software(vector));
}
public static VectorF Divide(VectorFParam1_3 dividend, VectorFParam1_3 divisor)
{
if (Sse.IsSupported)
{
return(Sse.Divide(dividend, divisor));
}
return(Divide_Software(dividend, divisor));
}
public static VectorF Multiply(VectorFParam1_3 left, float scalar)
{
if (Sse.IsSupported)
{
return(Sse.Multiply(left, Vector128.Create(scalar)));
}
return(Multiply_Software(left, scalar));
}
public static Vector128 <float> Subtract_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
X(left) - X(right),
Y(left) - Y(right),
Z(left) - Z(right),
W(left) - W(right)
));
}
public static Vector128 <float> Multiply_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
X(left) * X(right),
Y(left) * Y(right),
Z(left) * Z(right),
W(left) * W(right)
));
}
public static VectorF Subtract_Software(VectorFParam1_3 vector, float scalar)
{
return(Vector128.Create(
Helpers.X(vector) - scalar,
Helpers.Y(vector) - scalar,
Helpers.Z(vector) - scalar,
Helpers.W(vector) - scalar
));
}
public static VectorF Multiply_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
Helpers.X(left) * Helpers.X(right),
Helpers.Y(left) * Helpers.Y(right),
Helpers.Z(left) * Helpers.Z(right),
Helpers.W(left) * Helpers.W(right)
));
}
public static VectorF Subtract_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
Helpers.X(left) - Helpers.X(right),
Helpers.Y(left) - Helpers.Y(right),
Helpers.Z(left) - Helpers.Z(right),
Helpers.W(left) - Helpers.W(right)
));
}
public static VectorF HorizontalAdd_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
Helpers.X(left) + Helpers.Y(left),
Helpers.Z(left) + Helpers.W(left),
Helpers.X(right) + Helpers.Y(right),
Helpers.Z(right) + Helpers.W(right)
));
}
public static VectorF Abs_Software(VectorFParam1_3 vector)
{
return(Vector128.Create(
MathF.Abs(Helpers.X(vector)),
MathF.Abs(Helpers.Y(vector)),
MathF.Abs(Helpers.Z(vector)),
MathF.Abs(Helpers.W(vector))
));
}
public static VectorF Divide_Software(VectorFParam1_3 dividend, float scalarDivisor)
{
return(Vector128.Create(
Helpers.X(dividend) / scalarDivisor,
Helpers.Y(dividend) / scalarDivisor,
Helpers.Z(dividend) / scalarDivisor,
Helpers.W(dividend) / scalarDivisor
));
}
public static Vector128 <float> Multiply_Software(VectorFParam1_3 left, float scalar)
{
return(Vector128.Create(
X(left) * scalar,
Y(left) * scalar,
Z(left) * scalar,
W(left) * scalar
));
}
public static VectorF Multiply_Software(VectorFParam1_3 left, float scalar)
{
return(Vector128.Create(
Helpers.X(left) * scalar,
Helpers.Y(left) * scalar,
Helpers.Z(left) * scalar,
Helpers.W(left) * scalar
));
}
public static Vector128 <float> Subtract_Software(VectorFParam1_3 vector, float scalar)
{
return(Vector128.Create(
X(vector) - scalar,
Y(vector) - scalar,
Z(vector) - scalar,
W(vector) - scalar
));
}
public static VectorF AndNot(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.AndNot(left, right));
}
return(AndNot_Software(left, right));
}
public static Vector128 <float> Abs_Software(VectorFParam1_3 vector)
{
return(Vector128.Create(
MathF.Abs(X(vector)),
MathF.Abs(Y(vector)),
MathF.Abs(Z(vector)),
MathF.Abs(W(vector))
));
}
public static Vector128 <float> Add(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.Add(left, right));
}
return(Add_Software(left, right));
}
public static Vector128 <float> Add_Software(VectorFParam1_3 left, VectorFParam1_3 right)
{
return(Vector128.Create(
X(left) + X(right),
Y(left) + Y(right),
Z(left) + Z(right),
W(left) + W(right)
));
}
public static VectorF Multiply(VectorFParam1_3 left, VectorFParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.Multiply(left, right));
}
return(Multiply_Software(left, right));
}
public static Vector128 <float> Sqrt_Software(VectorFParam1_3 vector)
{
return(Vector128.Create(
MathF.Sqrt(X(vector)),
MathF.Sqrt(Y(vector)),
MathF.Sqrt(Z(vector)),
MathF.Sqrt(W(vector))
));
}
