get rid of the euler angles component #1

popcron · popcron · commit 9cf5ccd05242 · 2025-05-01T19:39:38.000-04:00
diff --git a/source/Components/Anchor.cs b/source/Components/Anchor.cs
@@ -21,12 +21,12 @@ public struct Anchor : IEquatable<Anchor>
         public static readonly Anchor Right = new(new(1f, false), new(0.5f, false), new(0f, false), new(1f, false), new(0.5f, false), new(0f, false));
         public static readonly Anchor Default = default;
 
-        public value minX;
-        public value minY;
-        public value minZ;
-        public value maxX;
-        public value maxY;
-        public value maxZ;
+        public Number minX;
+        public Number minY;
+        public Number minZ;
+        public Number maxX;
+        public Number maxY;
+        public Number maxZ;
 
 #if NET
         /// <summary>
@@ -43,7 +43,7 @@ public Anchor()
         }
 #endif
 
-        public Anchor(value minX, value minY, value minZ, value maxX, value maxY, value maxZ)
+        public Anchor(Number minX, Number minY, Number minZ, Number maxX, Number maxY, Number maxZ)
         {
             this.minX = minX;
             this.minY = minY;
@@ -78,15 +78,15 @@ public readonly override int GetHashCode()
             return !(left == right);
         }
 
-        public struct value : IEquatable<value>
+        public struct Number : IEquatable<Number>
         {
             public const int NumberRange = 65536;
             public const int MaxNumberValue = 32768;
             public const float Precision = 0.00003051757f;
 
             private int data;
 
-            public bool Absolute
+            public bool IsAbsolute
             {
                 readonly get
                 {
@@ -106,7 +106,7 @@ readonly get
                 }
             }
 
-            public float Number
+            public float Value
             {
                 readonly get
                 {
@@ -116,7 +116,7 @@ readonly get
                 }
                 set
                 {
-                    bool absolute = Absolute;
+                    bool absolute = IsAbsolute;
                     int valueInt = (int)(value * NumberRange) >> 1;
                     data = valueInt;
                     if (absolute)
@@ -130,12 +130,12 @@ readonly get
                 }
             }
 
-            public value(float number, bool fromEdge)
+            public Number(float value, bool absolute)
             {
-                ThrowIfOutOfRange(number);
+                ThrowIfOutOfRange(value);
 
-                data = (int)(number * NumberRange) >> 1;
-                if (fromEdge)
+                data = (int)(value * NumberRange) >> 1;
+                if (absolute)
                 {
                     data &= ~1;
                 }
@@ -145,7 +145,7 @@ public value(float number, bool fromEdge)
                 }
             }
 
-            public value(ReadOnlySpan<char> text)
+            public Number(ReadOnlySpan<char> text)
             {
                 bool negative = false;
                 int index = 0;
@@ -199,14 +199,22 @@ public value(ReadOnlySpan<char> text)
                     number = -number;
                 }
 
-                Absolute = absolute;
                 if (absolute)
                 {
-                    Number = number;
+                    data &= ~1;
+                }
+                else
+                {
+                    data |= 1;
+                }
+
+                if (absolute)
+                {
+                    Value = number;
                 }
                 else
                 {
-                    Number = number / 100f;
+                    Value = number / 100f;
                 }
             }
 
@@ -219,8 +227,8 @@ public readonly override string ToString()
 
             public readonly int ToString(Span<char> destination)
             {
-                bool isRelative = Absolute;
-                float number = Number;
+                bool isRelative = IsAbsolute;
+                float number = Value;
                 int length = 0;
                 if (isRelative)
                 {
@@ -241,10 +249,10 @@ public readonly int ToString(Span<char> destination)
 
             public readonly override bool Equals(object? obj)
             {
-                return obj is value value && Equals(value);
+                return obj is Number value && Equals(value);
             }
 
-            public readonly bool Equals(value other)
+            public readonly bool Equals(Number other)
             {
                 return data == other.data;
             }
@@ -254,27 +262,27 @@ public readonly override int GetHashCode()
                 return data.GetHashCode();
             }
 
-            public static bool operator ==(value left, value right)
+            public static bool operator ==(Number left, Number right)
             {
                 return left.Equals(right);
             }
 
-            public static bool operator !=(value left, value right)
+            public static bool operator !=(Number left, Number right)
             {
                 return !(left == right);
             }
 
-            public static implicit operator float(value value)
+            public static implicit operator float(Number value)
             {
-                return value.Number;
+                return value.Value;
             }
 
-            public static implicit operator value(ReadOnlySpan<char> text)
+            public static implicit operator Number(ReadOnlySpan<char> text)
             {
                 return new(text);
             }
 
-            public static implicit operator value(string text)
+            public static implicit operator Number(string text)
             {
                 return new(text.AsSpan());
             }
diff --git a/source/Components/EulerAngles.cs b/source/Components/EulerAngles.cs
diff --git a/source/Transform.cs b/source/Transform.cs
@@ -43,21 +43,9 @@ public readonly ref Quaternion LocalRotation
             }
         }
 
-        public readonly ref Vector3 EulerAngles
-        {
-            get
-            {
-                ref EulerAngles component = ref TryGetComponent<EulerAngles>(out bool contains);
-                if (!contains)
-                {
-                    component = ref AddComponent<EulerAngles>();
-                    component = Components.EulerAngles.Default;
-                }
-
-                return ref component.value;
-            }
-        }
-
+        /// <summary>
+        /// The anchor of this entity relative to the parent entity.
+        /// </summary>
         public readonly ref Anchor Anchor
         {
             get
@@ -73,6 +61,9 @@ public readonly ref Anchor Anchor
             }
         }
 
+        /// <summary>
+        /// The pivot of this entity relative to the parent entity.
+        /// </summary>
         public readonly ref Pivot Pivot
         {
             get
diff --git a/tests/AnchorTypeTests.cs b/tests/AnchorTypeTests.cs
@@ -8,56 +8,56 @@ public class AnchorTypeTests
         [Test]
         public void CheckAnchorDataType()
         {
-            Anchor.value left = new(0.92123f, true);
-            Assert.That(left.Absolute, Is.True);
-            Assert.That(left.Number, Is.EqualTo(0.92123f).Within(0.1f));
+            Anchor.Number left = new(0.92123f, true);
+            Assert.That(left.IsAbsolute, Is.True);
+            Assert.That(left.Value, Is.EqualTo(0.92123f).Within(0.1f));
 
-            Anchor.value right = new(456f, false);
-            Assert.That(right.Absolute, Is.False);
-            Assert.That(right.Number, Is.EqualTo(456f).Within(0.1f));
+            Anchor.Number right = new(456f, false);
+            Assert.That(right.IsAbsolute, Is.False);
+            Assert.That(right.Value, Is.EqualTo(456f).Within(0.1f));
 
             Assert.That(left, Is.Not.EqualTo(right));
-            Anchor.value up = new(0.5f, true);
+            Anchor.Number up = new(0.5f, true);
             Assert.That(up, Is.Not.EqualTo(left));
-            Assert.That(up.Absolute, Is.True);
-            Assert.That(up.Number, Is.EqualTo(0.5f).Within(0.1f));
+            Assert.That(up.IsAbsolute, Is.True);
+            Assert.That(up.Value, Is.EqualTo(0.5f).Within(0.1f));
 
-            Anchor.value down = new(-3.1412f, false);
+            Anchor.Number down = new(-3.1412f, false);
             Assert.That(down, Is.Not.EqualTo(right));
-            Assert.That(down.Absolute, Is.False);
-            Assert.That(down.Number, Is.EqualTo(-3.1412f).Within(0.1f));
+            Assert.That(down.IsAbsolute, Is.False);
+            Assert.That(down.Value, Is.EqualTo(-3.1412f).Within(0.1f));
 
             using RandomGenerator rng = new();
             for (uint i = 0; i < 1024; i++)
             {
                 float number = rng.NextFloat(-1000f, 1000f);
                 bool isNormalized = rng.NextBool();
-                Anchor.value value = new(number, isNormalized);
-                value.Number *= 2;
-                value.Absolute = !value.Absolute;
-                Assert.That(value.Number, Is.EqualTo(number * 2).Within(0.1f));
-                Assert.That(value.Absolute, Is.EqualTo(!isNormalized));
+                Anchor.Number value = new(number, isNormalized);
+                value.Value *= 2;
+                value.IsAbsolute = !value.IsAbsolute;
+                Assert.That(value.Value, Is.EqualTo(number * 2).Within(0.1f));
+                Assert.That(value.IsAbsolute, Is.EqualTo(!isNormalized));
             }
         }
 
         [Test]
         public void BuildAnchorValuesFromText()
         {
-            Anchor.value a = "0.5f";
-            Assert.That(a.Number, Is.EqualTo(0.5f).Within(0.001f));
-            Assert.That(a.Absolute, Is.True);
+            Anchor.Number a = "0.5f";
+            Assert.That(a.Value, Is.EqualTo(0.5f).Within(0.001f));
+            Assert.That(a.IsAbsolute, Is.True);
 
-            Anchor.value b = "50%";
-            Assert.That(b.Number, Is.EqualTo(0.5f).Within(0.001f));
-            Assert.That(b.Absolute, Is.False);
+            Anchor.Number b = "50%";
+            Assert.That(b.Value, Is.EqualTo(0.5f).Within(0.001f));
+            Assert.That(b.IsAbsolute, Is.False);
 
-            Anchor.value c = "-25%";
-            Assert.That(c.Number, Is.EqualTo(-0.25f).Within(0.001f));
-            Assert.That(c.Absolute, Is.False);
+            Anchor.Number c = "-25%";
+            Assert.That(c.Value, Is.EqualTo(-0.25f).Within(0.001f));
+            Assert.That(c.IsAbsolute, Is.False);
 
-            Anchor.value d = "0";
-            Assert.That(d.Number, Is.EqualTo(0f).Within(0.001f));
-            Assert.That(d.Absolute, Is.True);
+            Anchor.Number d = "0";
+            Assert.That(d.Value, Is.EqualTo(0f).Within(0.001f));
+            Assert.That(d.IsAbsolute, Is.True);
         }
     }
 }
diff --git a/tests/LocalToWorldTests.cs b/tests/LocalToWorldTests.cs
@@ -158,17 +158,5 @@ public void LocalPositionFromWorld()
             Assert.That(desiredLocalPosition.Y, Is.EqualTo(-0.6666f).Within(0.1f));
             Assert.That(desiredLocalPosition.Z, Is.EqualTo(-1f).Within(0.1f));
         }
-
-        [Test]
-        public void ConvertEulerToRotation()
-        {
-            EulerAngles euler = EulerAngles.CreateFromDegrees(0f, 90f, 0f);
-            Quaternion a = Quaternion.CreateFromYawPitchRoll(euler.value.Y, euler.value.X, euler.value.Z);
-            Quaternion b = euler.AsQuaternion();
-            Assert.That(a.X, Is.EqualTo(b.X).Within(0.001f));
-            Assert.That(a.Y, Is.EqualTo(b.Y).Within(0.001f));
-            Assert.That(a.Z, Is.EqualTo(b.Z).Within(0.001f));
-            Assert.That(a.W, Is.EqualTo(b.W).Within(0.001f));
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,12 @@ public struct Anchor : IEquatable<Anchor>`
`21`	`21`	`public static readonly Anchor Right = new(new(1f, false), new(0.5f, false), new(0f, false), new(1f, false), new(0.5f, false), new(0f, false));`
`22`	`22`	`public static readonly Anchor Default = default;`
`23`	`23`
`24`		`- public value minX;`
`25`		`- public value minY;`
`26`		`- public value minZ;`
`27`		`- public value maxX;`
`28`		`- public value maxY;`
`29`		`- public value maxZ;`
	`24`	`+ public Number minX;`
	`25`	`+ public Number minY;`
	`26`	`+ public Number minZ;`
	`27`	`+ public Number maxX;`
	`28`	`+ public Number maxY;`
	`29`	`+ public Number maxZ;`
`30`	`30`
`31`	`31`	`#if NET`
`32`	`32`	`/// <summary>`
`@@ -43,7 +43,7 @@ public Anchor()`
`43`	`43`	`}`
`44`	`44`	`#endif`
`45`	`45`
`46`		`- public Anchor(value minX, value minY, value minZ, value maxX, value maxY, value maxZ)`
	`46`	`+ public Anchor(Number minX, Number minY, Number minZ, Number maxX, Number maxY, Number maxZ)`
`47`	`47`	`{`
`48`	`48`	`this.minX = minX;`
`49`	`49`	`this.minY = minY;`
`@@ -78,15 +78,15 @@ public readonly override int GetHashCode()`
`78`	`78`	`return !(left == right);`
`79`	`79`	`}`
`80`	`80`
`81`		`- public struct value : IEquatable<value>`
	`81`	`+ public struct Number : IEquatable<Number>`
`82`	`82`	`{`
`83`	`83`	`public const int NumberRange = 65536;`
`84`	`84`	`public const int MaxNumberValue = 32768;`
`85`	`85`	`public const float Precision = 0.00003051757f;`
`86`	`86`
`87`	`87`	`private int data;`
`88`	`88`
`89`		`- public bool Absolute`
	`89`	`+ public bool IsAbsolute`
`90`	`90`	`{`
`91`	`91`	`readonly get`
`92`	`92`	`{`
`@@ -106,7 +106,7 @@ readonly get`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`109`		`- public float Number`
	`109`	`+ public float Value`
`110`	`110`	`{`
`111`	`111`	`readonly get`
`112`	`112`	`{`
`@@ -116,7 +116,7 @@ readonly get`
`116`	`116`	`}`
`117`	`117`	`set`
`118`	`118`	`{`
`119`		`- bool absolute = Absolute;`
	`119`	`+ bool absolute = IsAbsolute;`
`120`	`120`	`int valueInt = (int)(value * NumberRange) >> 1;`
`121`	`121`	`data = valueInt;`
`122`	`122`	`if (absolute)`
`@@ -130,12 +130,12 @@ readonly get`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`- public value(float number, bool fromEdge)`
	`133`	`+ public Number(float value, bool absolute)`
`134`	`134`	`{`
`135`		`- ThrowIfOutOfRange(number);`
	`135`	`+ ThrowIfOutOfRange(value);`
`136`	`136`
`137`		`- data = (int)(number * NumberRange) >> 1;`
`138`		`- if (fromEdge)`
	`137`	`+ data = (int)(value * NumberRange) >> 1;`
	`138`	`+ if (absolute)`
`139`	`139`	`{`
`140`	`140`	`data &= ~1;`
`141`	`141`	`}`
`@@ -145,7 +145,7 @@ public value(float number, bool fromEdge)`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`
`148`		`- public value(ReadOnlySpan<char> text)`
	`148`	`+ public Number(ReadOnlySpan<char> text)`
`149`	`149`	`{`
`150`	`150`	`bool negative = false;`
`151`	`151`	`int index = 0;`
`@@ -199,14 +199,22 @@ public value(ReadOnlySpan<char> text)`
`199`	`199`	`number = -number;`
`200`	`200`	`}`
`201`	`201`
`202`		`- Absolute = absolute;`
`203`	`202`	`if (absolute)`
`204`	`203`	`{`
`205`		`- Number = number;`
	`204`	`+ data &= ~1;`
	`205`	`+ }`
	`206`	`+ else`
	`207`	`+ {`
	`208`	`+ data \|= 1;`
	`209`	`+ }`
	`210`	`+`
	`211`	`+ if (absolute)`
	`212`	`+ {`
	`213`	`+ Value = number;`
`206`	`214`	`}`
`207`	`215`	`else`
`208`	`216`	`{`
`209`		`- Number = number / 100f;`
	`217`	`+ Value = number / 100f;`
`210`	`218`	`}`
`211`	`219`	`}`
`212`	`220`
`@@ -219,8 +227,8 @@ public readonly override string ToString()`
`219`	`227`
`220`	`228`	`public readonly int ToString(Span<char> destination)`
`221`	`229`	`{`
`222`		`- bool isRelative = Absolute;`
`223`		`- float number = Number;`
	`230`	`+ bool isRelative = IsAbsolute;`
	`231`	`+ float number = Value;`
`224`	`232`	`int length = 0;`
`225`	`233`	`if (isRelative)`
`226`	`234`	`{`
`@@ -241,10 +249,10 @@ public readonly int ToString(Span<char> destination)`
`241`	`249`
`242`	`250`	`public readonly override bool Equals(object? obj)`
`243`	`251`	`{`
`244`		`- return obj is value value && Equals(value);`
	`252`	`+ return obj is Number value && Equals(value);`
`245`	`253`	`}`
`246`	`254`
`247`		`- public readonly bool Equals(value other)`
	`255`	`+ public readonly bool Equals(Number other)`
`248`	`256`	`{`
`249`	`257`	`return data == other.data;`
`250`	`258`	`}`
`@@ -254,27 +262,27 @@ public readonly override int GetHashCode()`
`254`	`262`	`return data.GetHashCode();`
`255`	`263`	`}`
`256`	`264`
`257`		`- public static bool operator ==(value left, value right)`
	`265`	`+ public static bool operator ==(Number left, Number right)`
`258`	`266`	`{`
`259`	`267`	`return left.Equals(right);`
`260`	`268`	`}`
`261`	`269`
`262`		`- public static bool operator !=(value left, value right)`
	`270`	`+ public static bool operator !=(Number left, Number right)`
`263`	`271`	`{`
`264`	`272`	`return !(left == right);`
`265`	`273`	`}`
`266`	`274`
`267`		`- public static implicit operator float(value value)`
	`275`	`+ public static implicit operator float(Number value)`
`268`	`276`	`{`
`269`		`- return value.Number;`
	`277`	`+ return value.Value;`
`270`	`278`	`}`
`271`	`279`
`272`		`- public static implicit operator value(ReadOnlySpan<char> text)`
	`280`	`+ public static implicit operator Number(ReadOnlySpan<char> text)`
`273`	`281`	`{`
`274`	`282`	`return new(text);`
`275`	`283`	`}`
`276`	`284`
`277`		`- public static implicit operator value(string text)`
	`285`	`+ public static implicit operator Number(string text)`
`278`	`286`	`{`
`279`	`287`	`return new(text.AsSpan());`
`280`	`288`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,21 +43,9 @@ public readonly ref Quaternion LocalRotation`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`		`- public readonly ref Vector3 EulerAngles`
`47`		`- {`
`48`		`- get`
`49`		`- {`
`50`		`- ref EulerAngles component = ref TryGetComponent<EulerAngles>(out bool contains);`
`51`		`- if (!contains)`
`52`		`- {`
`53`		`- component = ref AddComponent<EulerAngles>();`
`54`		`- component = Components.EulerAngles.Default;`
`55`		`- }`
`56`		`-`
`57`		`- return ref component.value;`
`58`		`- }`
`59`		`- }`
`60`		`-`
	`46`	`+ /// <summary>`
	`47`	`+ /// The anchor of this entity relative to the parent entity.`
	`48`	`+ /// </summary>`
`61`	`49`	`public readonly ref Anchor Anchor`
`62`	`50`	`{`
`63`	`51`	`get`
`@@ -73,6 +61,9 @@ public readonly ref Anchor Anchor`
`73`	`61`	`}`
`74`	`62`	`}`
`75`	`63`
	`64`	`+ /// <summary>`
	`65`	`+ /// The pivot of this entity relative to the parent entity.`
	`66`	`+ /// </summary>`
`76`	`67`	`public readonly ref Pivot Pivot`
`77`	`68`	`{`
`78`	`69`	`get`
Original file line number	Diff line number	Diff line change
`@@ -158,17 +158,5 @@ public void LocalPositionFromWorld()`
`158`	`158`	`Assert.That(desiredLocalPosition.Y, Is.EqualTo(-0.6666f).Within(0.1f));`
`159`	`159`	`Assert.That(desiredLocalPosition.Z, Is.EqualTo(-1f).Within(0.1f));`
`160`	`160`	`}`
`161`		`-`
`162`		`- [Test]`
`163`		`- public void ConvertEulerToRotation()`
`164`		`- {`
`165`		`- EulerAngles euler = EulerAngles.CreateFromDegrees(0f, 90f, 0f);`
`166`		`- Quaternion a = Quaternion.CreateFromYawPitchRoll(euler.value.Y, euler.value.X, euler.value.Z);`
`167`		`- Quaternion b = euler.AsQuaternion();`
`168`		`- Assert.That(a.X, Is.EqualTo(b.X).Within(0.001f));`
`169`		`- Assert.That(a.Y, Is.EqualTo(b.Y).Within(0.001f));`
`170`		`- Assert.That(a.Z, Is.EqualTo(b.Z).Within(0.001f));`
`171`		`- Assert.That(a.W, Is.EqualTo(b.W).Within(0.001f));`
`172`		`- }`
`173`	`161`	`}`
`174`	`162`	`}`