public void QuaternionDEqualsTest()
{
QuaternionD a = new QuaternionD(1.0f, 2.0f, 3.0f, 4.0f);
QuaternionD b = new QuaternionD(1.0f, 2.0f, 3.0f, 4.0f);
// case 1: compare between same values
object?obj = b;
bool expected = true;
bool actual = a.Equals(obj);
Assert.AreEqual(expected, actual);
// case 2: compare between different values
b.X = 10.0f;
obj = b;
expected = false;
actual = a.Equals(obj);
Assert.AreEqual(expected, actual);
// case 3: compare between different types.
obj = new Vector4D();
expected = false;
actual = a.Equals(obj);
Assert.AreEqual(expected, actual);
// case 3: compare against null.
obj = null;
expected = false;
actual = a.Equals(obj);
Assert.AreEqual(expected, actual);
}
public void QuaternionDEqualsNanTest()
{
QuaternionD a = new QuaternionD(double.NaN, 0, 0, 0);
QuaternionD b = new QuaternionD(0, double.NaN, 0, 0);
QuaternionD c = new QuaternionD(0, 0, double.NaN, 0);
QuaternionD d = new QuaternionD(0, 0, 0, double.NaN);
Assert.False(a == new QuaternionD(0, 0, 0, 0));
Assert.False(b == new QuaternionD(0, 0, 0, 0));
Assert.False(c == new QuaternionD(0, 0, 0, 0));
Assert.False(d == new QuaternionD(0, 0, 0, 0));
Assert.True(a != new QuaternionD(0, 0, 0, 0));
Assert.True(b != new QuaternionD(0, 0, 0, 0));
Assert.True(c != new QuaternionD(0, 0, 0, 0));
Assert.True(d != new QuaternionD(0, 0, 0, 0));
Assert.False(a.Equals(new QuaternionD(0, 0, 0, 0)));
Assert.False(b.Equals(new QuaternionD(0, 0, 0, 0)));
Assert.False(c.Equals(new QuaternionD(0, 0, 0, 0)));
Assert.False(d.Equals(new QuaternionD(0, 0, 0, 0)));
Assert.False(a.IsIdentity);
Assert.False(b.IsIdentity);
Assert.False(c.IsIdentity);
Assert.False(d.IsIdentity);
// Counterintuitive result - IEEE rules for NaN comparison are weird!
Assert.False(a.Equals(a));
Assert.False(b.Equals(b));
Assert.False(c.Equals(c));
Assert.False(d.Equals(d));
}
public void TestEquals()
{
QuaternionD q1 = new QuaternionD(1.0, 2.0, 3.0, 4.0);
QuaternionD q2 = new QuaternionD(1.0, 2.0, 3.0, 4.0);
QuaternionD q3 = new QuaternionD(1.0, 2.0, 3.0, 0.0);
Assert.IsTrue(q1.Equals(q2));
Assert.IsFalse(q1.Equals(q3));
}
public void QuaternionDEqualsTest1()
{
QuaternionD a = new QuaternionD(1.0f, 2.0f, 3.0f, 4.0f);
QuaternionD b = new QuaternionD(1.0f, 2.0f, 3.0f, 4.0f);
// case 1: compare between same values
bool expected = true;
bool actual = a.Equals(b);
Assert.AreEqual(expected, actual);
// case 2: compare between different values
b.X = 10.0f;
expected = false;
actual = a.Equals(b);
Assert.AreEqual(expected, actual);
}
public void QuaternionDSlerpTest3()
{
Vector3D axis = Vector3D.Normalize(new Vector3D(1.0, 2.0, 3.0));
QuaternionD a = QuaternionD.CreateFromAxisAngle(axis, MathHelper.ToRadians(10.0));
QuaternionD b = -a;
double t = 1.0;
QuaternionD expected = a;
QuaternionD actual = QuaternionD.Slerp(a, b, t);
// Note that in QuaternionD world, Q == -Q. In the case of QuaternionDs dot product is zero,
// one of the QuaternionD will be flipped to compute the shortest distance. When t = 1, we
// expect the result to be the same as QuaternionD b but flipped.
Assert.That(actual, Is.EqualTo(expected).Using <QuaternionD>((a, b) => a.Equals(b, 1e-15)), $"QuaternionD.Slerp did not return the expected value: expected {expected} actual {actual}");
}
public void QuaternionDSlerpTest()
{
Vector3D axis = Vector3D.Normalize(new Vector3D(1.0, 2.0, 3.0));
QuaternionD a = QuaternionD.CreateFromAxisAngle(axis, MathHelper.ToRadians(10.0));
QuaternionD b = QuaternionD.CreateFromAxisAngle(axis, MathHelper.ToRadians(30.0));
double t = 0.5;
QuaternionD expected = QuaternionD.CreateFromAxisAngle(axis, MathHelper.ToRadians(20.0));
QuaternionD actual;
actual = QuaternionD.Slerp(a, b, t);
Assert.That(actual, Is.EqualTo(expected).Using <QuaternionD>((a, b) => a.Equals(b, 1e-15)), $"QuaternionD.Slerp did not return the expected value: expected {expected} actual {actual}");
// Case a and b are same.
expected = a;
actual = QuaternionD.Slerp(a, a, t);
Assert.AreEqual(expected, actual, $"QuaternionD.Slerp did not return the expected value: expected {expected} actual {actual}");
}
void Update()
{
//Quad Split Queue
if (quadSplitQueue.Count > 0) //Check if quads are in the queue
{
//Sorting quadSplitQueue based on quads level and distance to the camera. Quads of lowest distance to the camera and level are split first.
if (quadSplitQueue.Count > quadsSplittingSimultaneously)
{
quadSplitQueue.Sort(quadsSplittingSimultaneously - 1, quadSplitQueue.Count - quadsSplittingSimultaneously, comparer);
}
for (int i = 0; i < quadsSplittingSimultaneously; i++)
{
if (quadSplitQueue.Count >= i + 1)
{
if (quadSplitQueue[i] == null)
{
quadSplitQueue.Remove(quadSplitQueue[i]);
}
if (!quadSplitQueue[i].isSplitting && quadSplitQueue[i].coroutine == null && quadSplitQueue[i].planet)
{
quadSplitQueue[i].coroutine = StartCoroutine(quadSplitQueue[i].Split());
}
if (quadSplitQueue[i].hasSplit) //Wait until quad has split, then spot is freed
{
quadSplitQueue.Remove(quadSplitQueue[i]);
}
}
else
{
break;
}
}
}
transform.rotation = (Quaternion)rotation;
Vector3 camPos = mainCameraTr.position;
Quaternion camRot = mainCameraTr.rotation;
Vector3 trPos = transform.position;
Quaternion trRot = transform.rotation;
Vector3 relCamPos = camPos - trPos;
//Vector used by Quads when computing distance
worldToMeshVector = Quaternion.Inverse(trRot) * (mainCameraTr.position - trPos);
numQuads = quads.Count;
//radiusVisSphere is used by Quads to check if they are visible
float camHeight = (camPos - trPos).sqrMagnitude;
radiusVisSphere = (camHeight + (radiusMaxSqr - 2 * radiusSqr)) * visSphereRadiusMod;
//if (Input.GetKeyDown(KeyCode.G))
//{
// print("Update Quads");
// UpdateQuads(true);
//}
//Recompute quad positions if the planet rotation has changed
overRotationThreshold = !QuaternionD.Equals(rotation, oldPlanetRotation);
if (overRotationThreshold)
{
oldPlanetRotation = rotation;
UpdatePosition();
}
//Quad positions are also recalculated when the camera has moved farther than the threshold
bool changedViewport = (relCamPos - oldCamPosition).sqrMagnitude > rqdtSqr || overRotationThreshold || (camRot != oldCamRotation && lodModeBehindCam == LODModeBehindCam.NotComputed);
if (changedViewport)
{
oldCamPosition = relCamPos;
oldCamRotation = camRot;
}
if (scaledSpaceCopy)
{
scaledSpaceCopy.transform.rotation = trRot * Quaternion.Euler(0f, 90f, 0f); //Set scaledSpaceCopy rotation to planet's actual rotation
if (floatingOrigin == null)
{
scaledSpaceCopy.transform.position = transform.position / scaledSpaceFactor;
}
else
{
scaledSpaceCopy.transform.position = floatingOrigin.WorldSpaceToScaledSpace(transform.position, scaledSpaceFactor);
}
}
if (camHeight < scaledSpaceDisSqr * 1.5f || !useScaledSpace) //Update all quads when close to planet or not using scaled space
{
UpdateQuads(changedViewport); //If changedViewport = false, quads only check if any of their tasks on the CPU or GPU are done and apply them if so.
//otherwise, they recalculate their distance to the camera and check if they are close enough to split or far enough to combine.
}
//If cameraViewPlanes are needed to check quad visibilty they are computed here.
if (lodModeBehindCam == LODModeBehindCam.NotComputed)
{
viewPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
}
//Move all quads if planet center has moved.
if (trPos != oldPlanetPosition)
{
UpdatePosition();
originMoved = true; //Used by foliage system
oldPlanetPosition = trPos;
}
else
{
originMoved = false;
}
if (useScaledSpace && changedViewport)
{
if (camHeight > scaledSpaceDisSqr)
{
inScaledSpace = true;
}
else
{
inScaledSpace = false;
}
}
}
public void TestEquals2()
{
QuaternionD q = QuaternionD.Identity;
Assert.IsFalse(q.Equals(q.ToString()));
}
public void TestEquals()
{
QuaternionD q1 = new QuaternionD(1.0, 2.0, 3.0, 4.0);
QuaternionD q2 = new QuaternionD(1.0, 2.0, 3.0, 4.0);
QuaternionD q3 = new QuaternionD(1.0, 2.0, 3.0, 0.0);
Assert.IsTrue(q1.Equals(q2));
Assert.IsFalse(q1.Equals(q3));
}
