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())); }