< Summary

Class:GDX.Mathematics.Byte2
Assembly:GDX
File(s):./Packages/com.dotbunny.gdx/GDX/Mathematics/Byte2.cs
Covered lines:120
Uncovered lines:140
Coverable lines:260
Total lines:1062
Line coverage:46.1% (120 of 260)
Covered branches:0
Total branches:0
Covered methods:35
Total methods:78
Method coverage:44.8% (35 of 78)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
Byte2(...)0%110100%
Byte2(...)0%110100%
Byte2(...)0%110100%
Byte2(...)0%110100%
Byte2(...)0%550100%
Byte2(...)0%110100%
Byte2(...)0%110100%
Byte2(...)0%550100%
Byte2(...)0%110100%
Byte2(...)0%110100%
Equals(...)0%220100%
ToString(...)0%110100%
Equals(...)0%220100%
implicit operator GDX.Mathematics.Byte2(...)0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
operator*(...)0%110100%
operator*(...)0%110100%
operator*(...)0%110100%
operator+(...)0%110100%
operator+(...)0%110100%
operator+(...)0%110100%
operator-(...)0%2100%
operator-(...)0%2100%
operator-(...)0%2100%
operator/(...)0%2100%
operator/(...)0%2100%
operator/(...)0%2100%
operator%(...)0%2100%
operator%(...)0%2100%
operator%(...)0%2100%
operator++(...)0%2100%
operator--(...)0%2100%
operator-(...)0%2100%
operator+(...)0%2100%
operator~(...)0%2100%
operator&(...)0%2100%
operator&(...)0%2100%
operator&(...)0%2100%
operator|(...)0%2100%
operator|(...)0%2100%
operator|(...)0%2100%
operator^(...)0%2100%
operator^(...)0%2100%
operator^(...)0%2100%
GetHashCode()0%2100%
ToString()0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
explicit operator GDX.Mathematics.Byte2(...)0%110100%
operator<(...)0%2100%
operator<(...)0%2100%
operator<(...)0%2100%
operator<=(...)0%2100%
operator<=(...)0%2100%
operator<=(...)0%2100%
operator>(...)0%2100%
operator>(...)0%2100%
operator>(...)0%2100%
operator>=(...)0%2100%
operator>=(...)0%2100%
operator>=(...)0%2100%
operator==(...)0%2100%
operator==(...)0%2100%
operator==(...)0%2100%
operator!=(...)0%2100%
operator!=(...)0%2100%
operator!=(...)0%2100%
DebuggerProxy(...)0%2100%

File(s)

./Packages/com.dotbunny.gdx/GDX/Mathematics/Byte2.cs

#LineLine coverage
 1// Copyright (c) 2020-2024 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using System.ComponentModel;
 7using System.Diagnostics;
 8using System.Runtime.CompilerServices;
 9using Unity.Mathematics;
 10
 11namespace GDX.Mathematics
 12{
 13    /// <summary>
 14    ///     A <see cref="byte" /> vector.
 15    /// </summary>
 16    [DebuggerTypeProxy(typeof(DebuggerProxy))]
 17    [Serializable]
 18    public struct Byte2 : IEquatable<Byte2>, IFormattable
 19    {
 20        /// <summary>
 21        ///     X <see cref="byte" />.
 22        /// </summary>
 23        public byte X;
 24
 25        /// <summary>
 26        ///     Y <see cref="byte" />.
 27        /// </summary>
 28        public byte Y;
 29
 30        /// <summary>
 31        ///     Create a <see cref="Byte2" /> from two <see cref="int" /> values.
 32        /// </summary>
 33        /// <param name="x">X value.</param>
 34        /// <param name="y">Y value.</param>
 35        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 36        public Byte2(int x, int y)
 3437        {
 3438            X = (byte)x;
 3439            Y = (byte)y;
 3440        }
 41
 42        /// <summary>
 43        ///     Constructs a <see cref="Byte2" /> from two <see cref="byte" /> values.
 44        /// </summary>
 45        /// <param name="x">X value.</param>
 46        /// <param name="y">Y value.</param>
 47        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 48        public Byte2(byte x, byte y)
 549        {
 550            X = x;
 551            Y = y;
 552        }
 53
 54        /// <summary>
 55        ///     Constructs a <see cref="Byte2" /> from a <see cref="Byte2" /> value.
 56        /// </summary>
 57        /// <param name="xy">The value to copy.</param>
 58        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 59        public Byte2(Byte2 xy)
 160        {
 161            X = xy.X;
 162            Y = xy.Y;
 163        }
 64
 65        /// <summary>
 66        ///     Constructs a <see cref="Byte2" /> from a single <see cref="byte" /> value by assigning it to every compo
 67        /// </summary>
 68        /// <param name="v">The value to copy to <see cref="X" /> and <see cref="Y" />.</param>
 69        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 70        public Byte2(byte v)
 271        {
 272            X = v;
 273            Y = v;
 274        }
 75
 76        /// <summary>
 77        ///     Constructs a <see cref="Byte2" /> from a single <see cref="bool" /> value by converting it to <see cref=
 78        ///     and assigning it to every component.
 79        /// </summary>
 80        /// <param name="v">The <see cref="bool" /> value to transcribe.</param>
 81        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 82        public Byte2(bool v)
 283        {
 284            X = v ? (byte)255 : (byte)0;
 285            Y = v ? (byte)255 : (byte)0;
 286        }
 87
 88        /// <summary>
 89        ///     Constructs a <see cref="Byte2" /> from a single <see cref="float" /> value by converting it to <see cref
 90        ///     and assigning it to every component.
 91        /// </summary>
 92        /// <param name="v">The <see cref="float" /> value to transcribe.</param>
 93        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 94        public Byte2(float v)
 295        {
 296            X = (byte)v;
 297            Y = (byte)v;
 298        }
 99
 100        /// <summary>
 101        ///     Constructs a <see cref="Byte2" /> from a single <see cref="double" /> value by converting it to <see cre
 102        ///     and assigning it to every component.
 103        /// </summary>
 104        /// <param name="v">The <see cref="double" /> value to transcribe.</param>
 105        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 106        public Byte2(double v)
 2107        {
 2108            X = (byte)v;
 2109            Y = (byte)v;
 2110        }
 111
 112        /// <summary>
 113        ///     Constructs a <see cref="Byte2" /> from a <see cref="Unity.Mathematics.bool2" /> by conversion.
 114        /// </summary>
 115        /// <param name="v">The value to transcribe.</param>
 116        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 117        public Byte2(bool2 v)
 2118        {
 2119            X = v.x ? (byte)255 : (byte)0;
 2120            Y = v.y ? (byte)255 : (byte)0;
 2121        }
 122
 123        /// <summary>
 124        ///     Constructs a <see cref="Byte2" /> from a <see cref="Unity.Mathematics.float2" /> by conversion.
 125        /// </summary>
 126        /// <param name="v">The value to transcribe.</param>
 127        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 128        public Byte2(float2 v)
 2129        {
 2130            X = (byte)v.x;
 2131            Y = (byte)v.y;
 2132        }
 133
 134        /// <summary>
 135        ///     Constructs a <see cref="Byte2" /> from a <see cref="Unity.Mathematics.double2" /> by conversion.
 136        /// </summary>
 137        /// <param name="v">The value to transcribe.</param>
 138        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 139        public Byte2(double2 v)
 2140        {
 2141            X = (byte)v.x;
 2142            Y = (byte)v.y;
 2143        }
 144
 145        /// <summary>
 146        ///     Get a new <see cref="Byte2" /> created with <see cref="X" /> as both components.
 147        /// </summary>
 148        [EditorBrowsable(EditorBrowsableState.Never)]
 149#pragma warning disable IDE1006
 150        // ReSharper disable once InconsistentNaming
 151        public Byte2 XX
 152#pragma warning restore IDE1006
 153        {
 154            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1155            get => new Byte2(X, X);
 156        }
 157
 158        /// <summary>
 159        ///     Get a new <see cref="Byte2" /> created with identical components.
 160        /// </summary>
 161        [EditorBrowsable(EditorBrowsableState.Never)]
 162#pragma warning disable IDE1006
 163        // ReSharper disable once InconsistentNaming
 164        public Byte2 XY
 165#pragma warning restore IDE1006
 166        {
 167            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1168            get => new Byte2(X, Y);
 169            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 170            set
 1171            {
 1172                X = value.X;
 1173                Y = value.Y;
 1174            }
 175        }
 176
 177        /// <summary>
 178        ///     Get a new <see cref="Byte2" /> created with swapped components.
 179        /// </summary>
 180        [EditorBrowsable(EditorBrowsableState.Never)]
 181#pragma warning disable IDE1006
 182        // ReSharper disable once InconsistentNaming
 183        public Byte2 YX
 184#pragma warning restore IDE1006
 185        {
 186            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1187            get => new Byte2(Y, X);
 188            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 189            set
 1190            {
 1191                Y = value.X;
 1192                X = value.Y;
 1193            }
 194        }
 195
 196        /// <summary>
 197        ///     Get a new <see cref="Byte2" /> created with <see cref="Y" /> as both components.
 198        /// </summary>
 199        [EditorBrowsable(EditorBrowsableState.Never)]
 200#pragma warning disable IDE1006
 201        // ReSharper disable once InconsistentNaming
 202        public Byte2 YY
 203#pragma warning restore IDE1006
 204        {
 205            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1206            get => new Byte2(Y, Y);
 207        }
 208
 209        /// <summary>
 210        ///     Get the <see cref="byte" /> at the provided <paramref name="index" />.
 211        /// </summary>
 212        /// <param name="index">Returns the byte element at a specified index.</param>
 213        /// <exception cref="IndexOutOfRangeException">Out of range check.</exception>
 214        public unsafe byte this[int index]
 215        {
 216            get
 3217            {
 218#if ENABLE_UNITY_COLLECTIONS_CHECKS
 3219                if ((uint)index >= 2)
 1220                {
 1221                    throw new IndexOutOfRangeException("The index must be between[0...1]");
 222                }
 223#endif // ENABLE_UNITY_COLLECTIONS_CHECKS
 2224                fixed (Byte2* array = &this)
 2225                {
 2226                    return ((byte*)array)[index];
 227                }
 2228            }
 229            set
 2230            {
 231#if ENABLE_UNITY_COLLECTIONS_CHECKS
 2232                if ((uint)index >= 2)
 1233                {
 1234                    throw new IndexOutOfRangeException("The index must be between[0...1]");
 235                }
 236#endif // ENABLE_UNITY_COLLECTIONS_CHECKS
 1237                fixed (byte* array = &X)
 1238                {
 1239                    array[index] = value;
 1240                }
 1241            }
 242        }
 243
 244        /// <summary>
 245        ///     Does the <see cref="Byte2" /> equal another <see cref="Byte2" />.
 246        /// </summary>
 247        /// <param name="rhs">Target <see cref="Byte2" /> to compare with.</param>
 248        /// <returns>Returns true if the <see cref="Byte2" /> is equal to a given <see cref="Byte2" />, false otherwise.
 249        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 250        public bool Equals(Byte2 rhs)
 2251        {
 2252            return X == rhs.X && Y == rhs.Y;
 2253        }
 254
 255        /// <summary>
 256        ///     Convert the <see cref="Byte2" /> to a <see cref="string" /> using the provided <paramref name="format" /
 257        /// </summary>
 258        /// <param name="format">Specified format <see cref="string" />.</param>
 259        /// <param name="formatProvider">Culture-specific format information.</param>
 260        /// <returns>
 261        ///     Returns a string representation of the <see cref="Byte2" /> using a specified format and culture-specifi
 262        ///     format information.
 263        /// </returns>
 264        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 265        public string ToString(string format, IFormatProvider formatProvider)
 1266        {
 1267            return $"Byte2({X.ToString(format, formatProvider)},{Y.ToString(format, formatProvider)})";
 1268        }
 269
 270        /// <summary>
 271        ///     Does the <see cref="Byte2" /> equal another <see cref="object" /> (casted).
 272        /// </summary>
 273        /// <param name="o">Target <see cref="object" /> to compare with.</param>
 274        /// <returns>Returns true if the <see cref="Byte2" /> is equal to a given <see cref="Byte2" />, false otherwise.
 275        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 276        public override bool Equals(object o)
 1277        {
 1278            return o != null && Equals((Byte2)o);
 1279        }
 280
 281
 282        /// <summary>
 283        ///     Implicitly converts a single <see cref="byte" /> value to a <see cref="Byte2" /> by assigning it to ever
 284        ///     component.
 285        /// </summary>
 286        /// <param name="v">The <see cref="byte" /> value to transcribe.</param>
 287        /// <returns>A new <see cref="Byte2" />.</returns>
 288        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 289        public static implicit operator Byte2(byte v)
 1290        {
 1291            return new Byte2(v);
 1292        }
 293
 294        /// <summary>
 295        ///     Explicitly converts a single <see cref="bool" /> value to a <see cref="Byte2" /> by converting it to
 296        ///     <see cref="byte" /> and assigning it to every component.
 297        /// </summary>
 298        /// <param name="v">The <see cref="bool" /> value to transcribe.</param>
 299        /// <returns>A new <see cref="Byte2" />.</returns>
 300        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 301        public static explicit operator Byte2(bool v)
 1302        {
 1303            return new Byte2(v);
 1304        }
 305
 306        /// <summary>
 307        ///     Explicitly converts a single <see cref="float" /> value to a <see cref="Byte2" /> by converting it to
 308        ///     <see cref="byte" /> and assigning it to every component.
 309        /// </summary>
 310        /// <param name="v">The <see cref="float" /> value to transcribe.</param>
 311        /// <returns>A new <see cref="Byte2" />.</returns>
 312        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 313        public static explicit operator Byte2(float v)
 1314        {
 1315            return new Byte2(v);
 1316        }
 317
 318        /// <summary>
 319        ///     Explicitly converts a single <see cref="double" /> value to a <see cref="Byte2" /> by converting it to
 320        ///     <see cref="byte" /> and assigning it to every component.
 321        /// </summary>
 322        /// <param name="v">The <see cref="double" /> value to transcribe.</param>
 323        /// <returns>A new <see cref="Byte2" />.</returns>
 324        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 325        public static explicit operator Byte2(double v)
 1326        {
 1327            return new Byte2(v);
 1328        }
 329
 330        /// <summary>
 331        ///     Multiply two <see cref="Byte2" />.
 332        /// </summary>
 333        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 334        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 335        /// <returns>Returns the result of a  multiplication operation on two <see cref="Byte2" />.</returns>
 336        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 337        public static Byte2 operator *(Byte2 lhs, Byte2 rhs)
 1338        {
 1339            return new Byte2(lhs.X * rhs.X, lhs.Y * rhs.Y);
 1340        }
 341
 342        /// <summary>
 343        ///     Multiply a <see cref="Byte2" /> by a <see cref="byte" />.
 344        /// </summary>
 345        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 346        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 347        /// <returns>
 348        ///     Returns the result of a multiplication operation on a <see cref="Byte2" /> and a
 349        ///     <see cref="byte" /> value.
 350        /// </returns>
 351        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 352        public static Byte2 operator *(Byte2 lhs, byte rhs)
 1353        {
 1354            return new Byte2(lhs.X * rhs, lhs.Y * rhs);
 1355        }
 356
 357        /// <summary>
 358        ///     Multiply a <see cref="byte" /> by a <see cref="Byte2" />.
 359        /// </summary>
 360        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 361        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 362        /// <returns>
 363        ///     Returns the result of a multiplication operation on a <see cref="byte" /> and a
 364        ///     <see cref="Byte2" /> value.
 365        /// </returns>
 366        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 367        public static Byte2 operator *(byte lhs, Byte2 rhs)
 1368        {
 1369            return new Byte2(lhs * rhs.X, lhs * rhs.Y);
 1370        }
 371
 372        /// <summary>
 373        ///     Add two <see cref="Byte2" />.
 374        /// </summary>
 375        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 376        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 377        /// <returns>Returns the result of an addition operation on two <see cref="Byte2" />.</returns>
 378        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 379        public static Byte2 operator +(Byte2 lhs, Byte2 rhs)
 1380        {
 1381            return new Byte2(lhs.X + rhs.X, lhs.Y + rhs.Y);
 1382        }
 383
 384        /// <summary>
 385        ///     Add a <see cref="byte" /> to both components of a <see cref="Byte2" />.
 386        /// </summary>
 387        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 388        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 389        /// <returns>
 390        ///     Returns the result of an addition operation on an <see cref="Byte2" /> and an <see cref="byte" />
 391        ///     value.
 392        /// </returns>
 393        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 394        public static Byte2 operator +(Byte2 lhs, byte rhs)
 1395        {
 1396            return new Byte2(lhs.X + rhs, lhs.Y + rhs);
 1397        }
 398
 399        /// <summary>
 400        ///     Add a <see cref="Byte2" /> to a <see cref="byte" />.
 401        /// </summary>
 402        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 403        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 404        /// <returns>
 405        ///     Returns the result of an addition operation on an <see cref="byte" /> value and an
 406        ///     <see cref="Byte2" />.
 407        /// </returns>
 408        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 409        public static Byte2 operator +(byte lhs, Byte2 rhs)
 1410        {
 1411            return new Byte2(lhs + rhs.X, lhs + rhs.Y);
 1412        }
 413
 414        /// <summary>
 415        ///     Subtract a <see cref="Byte2" /> from another <see cref="Byte2" />.
 416        /// </summary>
 417        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 418        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 419        /// <returns>Returns the result of a subtraction operation on two <see cref="Byte2" />.</returns>
 420        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 421        public static Byte2 operator -(Byte2 lhs, Byte2 rhs)
 0422        {
 0423            return new Byte2(lhs.X - rhs.X, lhs.Y - rhs.Y);
 0424        }
 425
 426        /// <summary>
 427        ///     Subtract a <see cref="byte" /> from both components of a <see cref="Byte2" />.
 428        /// </summary>
 429        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 430        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 431        /// <returns>
 432        ///     Returns the result of a subtraction operation on a <see cref="Byte2" /> and a <see cref="byte" />
 433        ///     value.
 434        /// </returns>
 435        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 436        public static Byte2 operator -(Byte2 lhs, byte rhs)
 0437        {
 0438            return new Byte2(lhs.X - rhs, lhs.Y - rhs);
 0439        }
 440
 441        /// <summary>
 442        ///     Subtract both components of a <see cref="Byte2" /> from a <see cref="byte" />.
 443        /// </summary>
 444        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 445        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 446        /// <returns>
 447        ///     Returns the result of a subtraction operation on an <see cref="byte" /> value and an
 448        ///     <see cref="Byte2" />.
 449        /// </returns>
 450        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 451        public static Byte2 operator -(byte lhs, Byte2 rhs)
 0452        {
 0453            return new Byte2(lhs - rhs.X, lhs - rhs.Y);
 0454        }
 455
 456        /// <summary>
 457        ///     Divide a <see cref="Byte2" /> by another <see cref="Byte2" />.
 458        /// </summary>
 459        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 460        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 461        /// <returns>Returns the result of a division operation on two <see cref="Byte2" />.</returns>
 462        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 463        public static Byte2 operator /(Byte2 lhs, Byte2 rhs)
 0464        {
 0465            return new Byte2(lhs.X / rhs.X, lhs.Y / rhs.Y);
 0466        }
 467
 468        /// <summary>
 469        ///     Divide a <see cref="Byte2" /> by a <see cref="byte" />.
 470        /// </summary>
 471        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 472        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 473        /// <returns>
 474        ///     Returns the result of a division operation on a <see cref="Byte2" /> and <see cref="byte" />
 475        ///     value.
 476        /// </returns>
 477        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 478        public static Byte2 operator /(Byte2 lhs, byte rhs)
 0479        {
 0480            return new Byte2(lhs.X / rhs, lhs.Y / rhs);
 0481        }
 482
 483        /// <summary>
 484        ///     Divide a <see cref="byte" /> by a <see cref="Byte2" />.
 485        /// </summary>
 486        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 487        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 488        /// <returns>
 489        ///     Returns the result of a division operation on a <see cref="byte" /> value and
 490        ///     <see cref="Byte2" />.
 491        /// </returns>
 492        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 493        public static Byte2 operator /(byte lhs, Byte2 rhs)
 0494        {
 0495            return new Byte2(lhs / rhs.X, lhs / rhs.Y);
 0496        }
 497
 498        /// <summary>
 499        ///     Modulus a <see cref="Byte2" /> by another <see cref="Byte2" />.
 500        /// </summary>
 501        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 502        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 503        /// <returns>Returns the result of a modulus operation on two <see cref="Byte2" />.</returns>
 504        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 505        public static Byte2 operator %(Byte2 lhs, Byte2 rhs)
 0506        {
 0507            return new Byte2(lhs.X % rhs.X, lhs.Y % rhs.Y);
 0508        }
 509
 510        /// <summary>
 511        ///     Modulus a <see cref="Byte2" /> by a <see cref="byte" />.
 512        /// </summary>
 513        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 514        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 515        /// <returns>
 516        ///     Returns the result of a modulus operation on a <see cref="Byte2" /> and <see cref="byte" />
 517        ///     value.
 518        /// </returns>
 519        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 520        public static Byte2 operator %(Byte2 lhs, byte rhs)
 0521        {
 0522            return new Byte2(lhs.X % rhs, lhs.Y % rhs);
 0523        }
 524
 525        /// <summary>
 526        ///     Modulus a <see cref="byte" /> by a <see cref="Byte2" />.
 527        /// </summary>
 528        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 529        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 530        /// <returns>
 531        ///     Returns the result of a modulus operation on a <see cref="byte" /> value and
 532        ///     <see cref="Byte2" />.
 533        /// </returns>
 534        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 535        public static Byte2 operator %(byte lhs, Byte2 rhs)
 0536        {
 0537            return new Byte2(lhs % rhs.X, lhs % rhs.Y);
 0538        }
 539
 540        /// <summary>
 541        ///     Increment <see cref="Byte2" /> values.
 542        /// </summary>
 543        /// <param name="val">Target <see cref="Byte2" />.</param>
 544        /// <returns>Returns the result of an increment operation on a <see cref="Byte2" />.</returns>
 545        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 546        public static Byte2 operator ++(Byte2 val)
 0547        {
 0548            return new Byte2(++val.X, ++val.Y);
 0549        }
 550
 551        /// <summary>
 552        ///     Decrement <see cref="Byte2" /> values.
 553        /// </summary>
 554        /// <param name="val">Target <see cref="Byte2" />.</param>
 555        /// <returns>Returns the result of a decrement operation on a <see cref="Byte2" />.</returns>
 556        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 557        public static Byte2 operator --(Byte2 val)
 0558        {
 0559            return new Byte2(--val.X, --val.Y);
 0560        }
 561
 562        /// <summary>
 563        ///     Unary minus <see cref="Byte2" /> values.
 564        /// </summary>
 565        /// <param name="val">Target <see cref="Byte2" />.</param>
 566        /// <returns>Returns the result of an unary minus operation on a <see cref="Byte2" />.</returns>
 567        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 568        public static Byte2 operator -(Byte2 val)
 0569        {
 0570            return new Byte2(-val.X, -val.Y);
 0571        }
 572
 573        /// <summary>
 574        ///     Unary plus <see cref="Byte2" /> values.
 575        /// </summary>
 576        /// <param name="val">Target <see cref="Byte2" />.</param>
 577        /// <returns>Returns the result of an unary plus operation on a <see cref="Byte2" />.</returns>
 578        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 579        public static Byte2 operator +(Byte2 val)
 0580        {
 0581            return new Byte2(+val.X, +val.Y);
 0582        }
 583
 584        /// <summary>
 585        ///     Bitwise NOT <see cref="Byte2" /> values.
 586        /// </summary>
 587        /// <param name="val">Target <see cref="Byte2" />.</param>
 588        /// <returns>Returns the result of a bitwise NOT operation on a <see cref="Byte2" />.</returns>