public void PerspectiveFovRH() => Trials(1000, r => {
var fov = RandomFloat(r) * 2;
var aspect = RandomFloat(r) * 2;
var(znear, zfar) = RandomFloatOrderedPair(r, 0, 10000);
AssertAlike(FMatrix4x4.PerspectiveFovRH(fov, aspect, znear, zfar), Matrix4x4.CreatePerspectiveFieldOfView(fov, aspect, znear, zfar));
});
/**
* Converts {@link FMatrixRMaj} into {@link FMatrix4x4}
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FMatrix4x4 convert(FMatrixRMaj input, FMatrix4x4 output)
{
if (output == null)
{
output = new FMatrix4x4();
}
if (input.getNumRows() != output.getNumRows())
{
throw new ArgumentException("Number of rows do not match");
}
if (input.getNumCols() != output.getNumCols())
{
throw new ArgumentException("Number of columns do not match");
}
output.a11 = input.data[0];
output.a12 = input.data[1];
output.a13 = input.data[2];
output.a14 = input.data[3];
output.a21 = input.data[4];
output.a22 = input.data[5];
output.a23 = input.data[6];
output.a24 = input.data[7];
output.a31 = input.data[8];
output.a32 = input.data[9];
output.a33 = input.data[10];
output.a34 = input.data[11];
output.a41 = input.data[12];
output.a42 = input.data[13];
output.a43 = input.data[14];
output.a44 = input.data[15];
return(output);
}
public void OrthoOffCenterRH() => Trials(1000, r => {
var(left, right) = RandomFloatOrderedPair(r, -1000, 1000);
var(bottom, top) = RandomFloatOrderedPair(r, -1000, 1000);
var(znear, zfar) = RandomFloatOrderedPair(r, 0, 10000);
AssertAlike(FMatrix4x4.OrthoOffCenterRH(left, right, bottom, top, znear, zfar), Matrix4x4.CreateOrthographicOffCenter(left, right, bottom, top, znear, zfar));
});
public void OrthoRH() => Trials(1000, r => {
var width = RandomFloat(r) * 1000;
var height = RandomFloat(r) * 1000;
var(znear, zfar) = RandomFloatOrderedPair(r, 0, 10000);
AssertAlike(FMatrix4x4.OrthoRH(width, height, znear, zfar), Matrix4x4.CreateOrthographic(width, height, znear, zfar));
});
/**
* Converts {@link FMatrix4x4} into {@link FMatrixRMaj}.
*
* @param input Input matrix.
* @param output Output matrix. If null a new matrix will be declared.
* @return Converted matrix.
*/
public static FMatrixRMaj convert(FMatrix4x4 input, FMatrixRMaj output)
{
if (output == null)
{
output = new FMatrixRMaj(4, 4);
}
if (input.getNumRows() != output.getNumRows())
{
throw new ArgumentException("Number of rows do not match");
}
if (input.getNumCols() != output.getNumCols())
{
throw new ArgumentException("Number of columns do not match");
}
output.data[0] = input.a11;
output.data[1] = input.a12;
output.data[2] = input.a13;
output.data[3] = input.a14;
output.data[4] = input.a21;
output.data[5] = input.a22;
output.data[6] = input.a23;
output.data[7] = input.a24;
output.data[8] = input.a31;
output.data[9] = input.a32;
output.data[10] = input.a33;
output.data[11] = input.a34;
output.data[12] = input.a41;
output.data[13] = input.a42;
output.data[14] = input.a43;
output.data[15] = input.a44;
return(output);
}
public Shader <Vector2, Vector3> Configure(FMatrix4x4 projViewInv, AtmosphereConfiguration atmosphereConfiguration)
{
return(ProxyIn <Vector2>(uv => new PixelInput {
UV = uv,
CameraProjViewInv = projViewInv,
AtmosphereConfiguration = atmosphereConfiguration
}));
}
public void Trivial()
{
// Convention is UnitZ forward, UnitX right, UnitY up in local space.
var mat = FMatrix4x4.RotationLookAtRH(Vector3.Zero, Vector3.UnitZ, Vector3.UnitY);
AssertAlike(mat.Transform(Vector3.UnitZ), Vector3.UnitZ);
AssertAlike(mat.Transform(Vector3.UnitX), Vector3.UnitX);
AssertAlike(mat.Transform(Vector3.UnitY), Vector3.UnitY);
}
public void TryInvert() => Trials(1000, r => {
var fm = RandomMatrix(r);
var snm = ToNumericsTransposed(fm);
AssertAlike(fm, snm);
var fmInvSuccess = FMatrix4x4.TryInvert(fm, out var fmInv);
var snmInvSuccess = Matrix4x4.Invert(snm, out var snmInv);
Assert.Equal(fmInvSuccess, snmInvSuccess);
AssertAlike(fmInv, snmInv, -0.005f);
});
public static float fastNormF(FMatrix4x4 M)
{
float sum = 0;
sum += M.a11 * M.a11 + M.a12 * M.a12 + M.a13 * M.a13 + M.a14 * M.a14;
sum += M.a21 * M.a21 + M.a22 * M.a22 + M.a23 * M.a23 + M.a24 * M.a24;
sum += M.a31 * M.a31 + M.a32 * M.a32 + M.a33 * M.a33 + M.a34 * M.a34;
sum += M.a41 * M.a41 + M.a42 * M.a42 + M.a43 * M.a43 + M.a44 * M.a44;
return((float)Math.Sqrt(sum));
}
public float Custom()
{
var a = new FMatrix4x4(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
var b = new FMatrix4x4(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32);
var acc = 0.0f;
for (var i = 0; i < 1000; i++)
{
acc += (a * b).Row1.X;
}
return(acc);
}
public void RotationLookAt() => Trials(1000, r => {
var a = RandomVector3(r);
var b = RandomVector3(r);
var c = RandomVector3(r);
// Rotation lookat RH is lookat LH with flipped Z
var la = Matrix4x4.CreateLookAt(b, a, c);
// And additionally, no translation
la.M41 = la.M42 = la.M43 = 0.0f;
// LookAt is meant for camera. Does the opposite motion of what we want,
// so invert (orthonormal matrix, so transpose equivalent)
la = Matrix4x4.Transpose(la);
AssertAlike(FMatrix4x4.RotationLookAtRH(a, b, c), la);
});
public void Turn111()
{
// Convention is UnitZ forward, UnitX right, UnitY up in local space.
var mat = FMatrix4x4.RotationLookAtRH(Vector3.Zero, Vector3.One, Vector3.UnitY);
output.WriteLine(mat.ToStringNewline());
AssertAlike(mat.Transform(Vector3.UnitZ), Vec3(1, 1, 1).Normalize());
output.WriteLine(mat.Transform(Vector3.UnitY).ToString());
Assert.True(mat.Transform(Vector3.UnitY).Dot(Vector3.UnitX) < 0);
Assert.True(mat.Transform(Vector3.UnitY).Dot(Vector3.UnitY) > 0);
Assert.True(mat.Transform(Vector3.UnitY).Dot(Vector3.UnitZ) < 0);
output.WriteLine(mat.Transform(Vector3.UnitX).ToString());
Assert.True(mat.Transform(Vector3.UnitX).Dot(Vector3.UnitX) > 0);
Assert.True(mat.Transform(Vector3.UnitX).Dot(Vector3.UnitY) >= 0);
Assert.True(mat.Transform(Vector3.UnitX).Dot(Vector3.UnitZ) < 0);
}
public static void convert(FMatrix4x4 src, DMatrix4x4 dst)
{
dst.a11 = src.a11;
dst.a12 = src.a12;
dst.a13 = src.a13;
dst.a14 = src.a14;
dst.a21 = src.a21;
dst.a22 = src.a22;
dst.a23 = src.a23;
dst.a24 = src.a24;
dst.a31 = src.a31;
dst.a32 = src.a32;
dst.a33 = src.a33;
dst.a34 = src.a34;
dst.a41 = src.a41;
dst.a42 = src.a42;
dst.a43 = src.a43;
dst.a44 = src.a44;
}
public static bool hasUncountable(FMatrix4x4 a)
{
if (UtilEjml.isUncountable(a.a11 + a.a12 + a.a13 + a.a14))
{
return(true);
}
if (UtilEjml.isUncountable(a.a21 + a.a22 + a.a23 + a.a24))
{
return(true);
}
if (UtilEjml.isUncountable(a.a31 + a.a32 + a.a33 + a.a34))
{
return(true);
}
if (UtilEjml.isUncountable(a.a41 + a.a42 + a.a43 + a.a44))
{
return(true);
}
return(false);
}
public static float normF(FMatrix4x4 M)
{
float scale = CommonOps_FDF4.elementMaxAbs(M);
if (scale == 0.0f)
{
return(0.0f);
}
float a11 = M.a11 / scale, a12 = M.a12 / scale, a13 = M.a13 / scale, a14 = M.a14 / scale;
float a21 = M.a21 / scale, a22 = M.a22 / scale, a23 = M.a23 / scale, a24 = M.a24 / scale;
float a31 = M.a31 / scale, a32 = M.a32 / scale, a33 = M.a33 / scale, a34 = M.a34 / scale;
float a41 = M.a41 / scale, a42 = M.a42 / scale, a43 = M.a43 / scale, a44 = M.a44 / scale;
float sum = 0;
sum += a11 * a11 + a12 * a12 + a13 * a13 + a14 * a14;
sum += a21 * a21 + a22 * a22 + a23 * a23 + a24 * a24;
sum += a31 * a31 + a32 * a32 + a33 * a33 + a34 * a34;
sum += a41 * a41 + a42 * a42 + a43 * a43 + a44 * a44;
return(scale * (float)Math.Sqrt(sum));
}
public void Translation() => Trials(1000, r => {
var v = RandomVector3(r);
AssertAlike(FMatrix4x4.Translation(v), Matrix4x4.CreateTranslation(v));
});
public static void normalizeF(FMatrix4x4 M)
{
float val = normF(M);
CommonOps_FDF4.divide(M, val);
}
public void FromQuaternion() => Trials(1000, r => {
var q = new Quaternion(RandomFloat(r), RandomFloat(r), RandomFloat(r), RandomFloat(r)).Normalize();
AssertAlike(FMatrix4x4.FromQuaternion(q), Matrix4x4.CreateFromQuaternion(q));
});
public void RotationZ() => Trials(1000, r => {
var theta = (RandomFloat(r) - 0.5f) * 8.0f * MathF.PI;
AssertAlike(FMatrix4x4.RotationZ(theta), Matrix4x4.CreateRotationZ(theta));
});
public void LookAt() => Trials(1000, r => {
var a = RandomVector3(r);
var b = RandomVector3(r);
var c = RandomVector3(r);
AssertAlike(FMatrix4x4.ViewLookAtRH(a, b, c), Matrix4x4.CreateLookAt(a, b, c));
});
public static bool isIdentical(FMatrix4x4 a, FMatrix4x4 b, float tol)
{
if (!MatrixFeatures_FDRM.isIdentical(a.a11, b.a11, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a12, b.a12, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a13, b.a13, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a14, b.a14, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a21, b.a21, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a22, b.a22, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a23, b.a23, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a24, b.a24, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a31, b.a31, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a32, b.a32, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a33, b.a33, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a34, b.a34, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a41, b.a41, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a42, b.a42, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a43, b.a43, tol))
{
return(false);
}
if (!MatrixFeatures_FDRM.isIdentical(a.a44, b.a44, tol))
{
return(false);
}
return(true);
}
public void Scale() => Trials(1000, r => {
var v = RandomVector3(r);
AssertAlike(FMatrix4x4.Scale(v), Matrix4x4.CreateScale(v));
});
public static FMatrix4x4 CreateLookatProjView(Vector3 cameraPosition, Vector3 cameraLookat, Vector3 up, Size renderTargetSize, float vFov = (float)Math.PI / 4, float znear = 5.0f, float zfar = 1000.0f)
{
var aspect = renderTargetSize.Width / (float)renderTargetSize.Height;
return(FMatrix4x4.PerspectiveFovRH(vFov, aspect, znear, zfar) * FMatrix4x4.ViewLookAtRH(cameraPosition, cameraLookat, up));
}
public void FromAxisAngle() => Trials(1000, r => {
var axis = RandomVector3(r);
var theta = (RandomFloat(r) - 0.5f) * 8.0f * MathF.PI;
AssertAlike(FMatrix4x4.FromAxisAngle(axis, theta), Matrix4x4.CreateFromAxisAngle(axis, theta));
});
