< Summary

Class:GDX.Mathematics.Byte2
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Mathematics/Byte2.cs
Covered lines:120
Uncovered lines:140
Coverable lines:260
Total lines:1061
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%
DebuggerProxy(...)0%2100%
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%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Mathematics/Byte2.cs

#LineLine coverage
 1// Copyright (c) 2020-2022 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
 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
 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>
 589        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 590        public static Byte2 operator ~(Byte2 val)
 0591        {
 0592            return new Byte2(~val.X, ~val.Y);
 0593        }
 594
 595        /// <summary>
 596        ///     Bitwise AND two <see cref="Byte2" /> values.
 597        /// </summary>
 598        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 599        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 600        /// <returns>Returns the result of a bitwise AND operation on two <see cref="Byte2" />.</returns>
 601        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 602        public static Byte2 operator &(Byte2 lhs, Byte2 rhs)
 0603        {
 0604            return new Byte2(lhs.X & rhs.X, lhs.Y & rhs.Y);
 0605        }
 606
 607        /// <summary>
 608        ///     Bitwise AND a <see cref="Byte2" /> and a <see cref="byte" />.
 609        /// </summary>
 610        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 611        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 612        /// <returns>
 613        ///     Returns the result of a bitwise AND operation on a <see cref="Byte2" /> and a <see cref="byte" />
 614        ///     value.
 615        /// </returns>
 616        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 617        public static Byte2 operator &(Byte2 lhs, byte rhs)
 0618        {
 0619            return new Byte2(lhs.X & rhs, lhs.Y & rhs);
 0620        }
 621
 622        /// <summary>
 623        ///     Bitwise AND a <see cref="byte" /> and a <see cref="Byte2" />.
 624        /// </summary>
 625        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 626        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 627        /// <returns>
 628        ///     Returns the result of a bitwise AND operation on a <see cref="byte" /> and a <see cref="Byte2" />
 629        ///     value.
 630        /// </returns>
 631        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 632        public static Byte2 operator &(byte lhs, Byte2 rhs)
 0633        {
 0634            return new Byte2(lhs & rhs.X, lhs & rhs.Y);
 0635        }
 636
 637        /// <summary>
 638        ///     Bitwise OR two <see cref="Byte2" /> values.
 639        /// </summary>
 640        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 641        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 642        /// <returns>Returns the result of a bitwise OR operation on two <see cref="Byte2" />.</returns>
 643        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 644        public static Byte2 operator |(Byte2 lhs, Byte2 rhs)
 0645        {
 0646            return new Byte2(lhs.X | rhs.X, lhs.Y | rhs.Y);
 0647        }
 648
 649        /// <summary>
 650        ///     Bitwise OR a <see cref="Byte2" /> and a <see cref="byte" />.
 651        /// </summary>
 652        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 653        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 654        /// <returns>
 655        ///     Returns the result of a bitwise OR operation on a <see cref="Byte2" /> and a <see cref="byte" />
 656        ///     value.
 657        /// </returns>
 658        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 659        public static Byte2 operator |(Byte2 lhs, byte rhs)
 0660        {
 0661            return new Byte2(lhs.X | rhs, lhs.Y | rhs);
 0662        }
 663
 664        /// <summary>
 665        ///     Bitwise OR a <see cref="byte" /> and a <see cref="Byte2" />.
 666        /// </summary>
 667        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 668        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 669        /// <returns>
 670        ///     Returns the result of a bitwise OR operation on a <see cref="byte" /> and a <see cref="Byte2" />
 671        ///     value.
 672        /// </returns>
 673        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 674        public static Byte2 operator |(byte lhs, Byte2 rhs)
 0675        {
 0676            return new Byte2(lhs | rhs.X, lhs | rhs.Y);
 0677        }
 678
 679        /// <summary>
 680        ///     Bitwise XOR two <see cref="Byte2" /> values.
 681        /// </summary>
 682        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 683        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 684        /// <returns>Returns the result of a bitwise EXCLUSIVE OR operation on two <see cref="Byte2" />.</returns>
 685        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 686        public static Byte2 operator ^(Byte2 lhs, Byte2 rhs)
 0687        {
 0688            return new Byte2(lhs.X ^ rhs.X, lhs.Y ^ rhs.Y);
 0689        }
 690
 691        /// <summary>
 692        ///     Bitwise XOR a <see cref="Byte2" /> and a <see cref="byte" />.
 693        /// </summary>
 694        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 695        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 696        /// <returns>
 697        ///     Returns the result of a bitwise XOR operation on a <see cref="Byte2" /> and a <see cref="byte" />
 698        ///     value.
 699        /// </returns>
 700        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 701        public static Byte2 operator ^(Byte2 lhs, byte rhs)
 0702        {
 0703            return new Byte2(lhs.X ^ rhs, lhs.Y ^ rhs);
 0704        }
 705
 706        /// <summary>
 707        ///     Bitwise XOR a <see cref="byte" /> and a <see cref="Byte2" />.
 708        /// </summary>
 709        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 710        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 711        /// <returns>
 712        ///     Returns the result of a bitwise XOR operation on a <see cref="byte" /> and a <see cref="Byte2" />
 713        ///     value.
 714        /// </returns>
 715        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 716        public static Byte2 operator ^(byte lhs, Byte2 rhs)
 0717        {
 0718            return new Byte2(lhs ^ rhs.X, lhs ^ rhs.Y);
 0719        }
 720
 721        /// <summary>
 722        ///     Get a hash code from the <see cref="Byte2" />.
 723        /// </summary>
 724        /// <remarks>
 725        ///     This loosely based on the Fowler–Noll–Vo (FNV) hash function.
 726        /// </remarks>
 727        /// <returns>A <see cref="int" /> value.</returns>
 728        public override int GetHashCode()
 0729        {
 730            unchecked
 0731            {
 732                const int k_P = 16777619;
 0733                int hash = (int)2166136261;
 734
 0735                hash = (hash ^ X) * k_P;
 0736                hash = (hash ^ Y) * k_P;
 737
 0738                hash += hash << 13;
 0739                hash ^= hash >> 7;
 0740                hash += hash << 3;
 0741                hash ^= hash >> 17;
 0742                hash += hash << 5;
 743
 0744                return hash;
 745            }
 0746        }
 747
 748        /// <summary>
 749        ///     Returns a <see cref="string" /> representation of the <see cref="Byte2" />.
 750        /// </summary>
 751        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 752        public override string ToString()
 1753        {
 1754            return $"Byte2({X.ToString()},{Y.ToString()})";
 1755        }
 756
 757        /// <summary>
 758        ///     Debug object used by IDEs for visibility of a <see cref="Byte2" />.
 759        /// </summary>
 760        internal sealed class DebuggerProxy
 761        {
 0762            public DebuggerProxy(Byte2 v)
 0763            {
 0764                X = v.X;
 0765                Y = v.Y;
 0766            }
 767            /// <summary>
 768            ///     X <see cref="byte" />.
 769            /// </summary>
 770            public byte X;
 771
 772            /// <summary>
 773            ///     Y <see cref="byte" />.
 774            /// </summary>
 775            public byte Y;
 776        }
 777
 778        /// <summary>
 779        ///     Explicitly converts a <see cref="Unity.Mathematics.bool2" /> to a <see cref="Byte2" /> by conversion.
 780        /// </summary>
 781        /// <param name="v">The value to transcribe.</param>
 782        /// <returns>A new <see cref="Byte2" /> created from <paramref name="v" />.</returns>
 783        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 784        public static explicit operator Byte2(bool2 v)
 1785        {
 1786            return new Byte2(v);
 1787        }
 788
 789        /// <summary>
 790        ///     Explicitly converts a <see cref="Unity.Mathematics.bool2" /> to a <see cref="Byte2" /> by conversion.
 791        /// </summary>
 792        /// <param name="v">The value to transcribe.</param>
 793        /// <returns>A new <see cref="Byte2" /> created from <paramref name="v" />.</returns>
 794        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 795        public static explicit operator Byte2(float2 v)
 1796        {
 1797            return new Byte2(v);
 1798        }
 799
 800        /// <summary>
 801        ///     Explicitly converts a <see cref="Unity.Mathematics.double2" /> to a <see cref="Byte2" /> by
 802        ///     conversion.
 803        /// </summary>
 804        /// <param name="v">The value to transcribe.</param>
 805        /// <returns>A new <see cref="Byte2" /> created from <paramref name="v" />.</returns>
 806        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 807        public static explicit operator Byte2(double2 v)
 1808        {
 1809            return new Byte2(v);
 1810        }
 811
 812        /// <summary>
 813        ///     Determine if one <see cref="Byte2" /> is less than another <see cref="Byte2" />.
 814        /// </summary>
 815        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 816        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 817        /// <returns>Returns the result of a LESS THAN operation on two <see cref="Byte2" />.</returns>
 818        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 819        public static bool2 operator <(Byte2 lhs, Byte2 rhs)
 0820        {
 0821            return new bool2(lhs.X < rhs.X, lhs.Y < rhs.Y);
 0822        }
 823
 824        /// <summary>
 825        ///     Determine if <see cref="Byte2" /> is less than a <see cref="byte" />.
 826        /// </summary>
 827        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 828        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 829        /// <returns>
 830        ///     Returns the result of a LESS THAN operation on a <see cref="Byte2" /> and a <see cref="byte" />
 831        ///     value.
 832        /// </returns>
 833        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 834        public static bool2 operator <(Byte2 lhs, byte rhs)
 0835        {
 0836            return new bool2(lhs.X < rhs, lhs.Y < rhs);
 0837        }
 838
 839        /// <summary>
 840        ///     Determine if <see cref="byte" /> is less than a <see cref="Byte2" />.
 841        /// </summary>
 842        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 843        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 844        /// <returns>
 845        ///     Returns the result of a LESS THAN operation on a <see cref="byte" /> and a <see cref="Byte2" />
 846        ///     value.
 847        /// </returns>
 848        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 849        public static bool2 operator <(byte lhs, Byte2 rhs)
 0850        {
 0851            return new bool2(lhs < rhs.X, lhs < rhs.Y);
 0852        }
 853
 854        /// <summary>
 855        ///     Determine if one <see cref="Byte2" /> is less than or equal to another <see cref="Byte2" />.
 856        /// </summary>
 857        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 858        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 859        /// <returns>Returns the result of a LESS THAN OR EQUAL operation on two <see cref="Byte2" />.</returns>
 860        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 861        public static bool2 operator <=(Byte2 lhs, Byte2 rhs)
 0862        {
 0863            return new bool2(lhs.X <= rhs.X, lhs.Y <= rhs.Y);
 0864        }
 865
 866        /// <summary>
 867        ///     Determine if <see cref="Byte2 " /> is less than or equal a <see cref="byte" />.
 868        /// </summary>
 869        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 870        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 871        /// <returns>
 872        ///     Returns the result of a LESS THAN OR EQUAL operation on a <see cref="Byte2" /> and a
 873        ///     <see cref="byte" />
 874        ///     value.
 875        /// </returns>
 876        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 877        public static bool2 operator <=(Byte2 lhs, byte rhs)
 0878        {
 0879            return new bool2(lhs.X <= rhs, lhs.Y <= rhs);
 0880        }
 881
 882        /// <summary>
 883        ///     Determine if <see cref="byte" /> is less than or equal a <see cref="Byte2" />.
 884        /// </summary>
 885        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 886        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 887        /// <returns>
 888        ///     Returns the result of a LESS THAN OR EQUAL operation on a <see cref="byte" /> and a
 889        ///     <see cref="Byte2" />
 890        ///     value.
 891        /// </returns>
 892        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 893        public static bool2 operator <=(byte lhs, Byte2 rhs)
 0894        {
 0895            return new bool2(lhs <= rhs.X, lhs <= rhs.Y);
 0896        }
 897
 898        /// <summary>
 899        ///     Determine if one <see cref="Byte2" /> is less than another <see cref="Byte2" />.
 900        /// </summary>
 901        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 902        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 903        /// <returns>Returns the result of a LESS THAN operation on two <see cref="Byte2" />.</returns>
 904        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 905        public static bool2 operator >(Byte2 lhs, Byte2 rhs)
 0906        {
 0907            return new bool2(lhs.X > rhs.X, lhs.Y > rhs.Y);
 0908        }
 909
 910        /// <summary>
 911        ///     Determine if <see cref="Byte2 " /> is greater than a <see cref="byte" />.
 912        /// </summary>
 913        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 914        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 915        /// <returns>
 916        ///     Returns the result of a GREATER THAN operation on a <see cref="Byte2" /> and a <see cref="byte" />
 917        ///     value.
 918        /// </returns>
 919        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 920        public static bool2 operator >(Byte2 lhs, byte rhs)
 0921        {
 0922            return new bool2(lhs.X > rhs, lhs.Y > rhs);
 0923        }
 924
 925        /// <summary>
 926        ///     Determine if <see cref="byte" /> is greater than a <see cref="Byte2" />.
 927        /// </summary>
 928        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 929        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 930        /// <returns>
 931        ///     Returns the result of a GREATER THAN operation on a <see cref="byte" /> and a <see cref="Byte2" />
 932        ///     value.
 933        /// </returns>
 934        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 935        public static bool2 operator >(byte lhs, Byte2 rhs)
 0936        {
 0937            return new bool2(lhs > rhs.X, lhs > rhs.Y);
 0938        }
 939
 940
 941        /// <summary>
 942        ///     Determine if <see cref="Byte2 " /> is greater than or equal a <see cref="Byte2" />.
 943        /// </summary>
 944        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 945        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 946        /// <returns>
 947        ///     Returns the result of a GREATER THAN OR EQUAL operation on a <see cref="Byte2" /> and a
 948        ///     <see cref="Byte2" />
 949        ///     value.
 950        /// </returns>
 951        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 952        public static bool2 operator >=(Byte2 lhs, Byte2 rhs)
 0953        {
 0954            return new bool2(lhs.X >= rhs.X, lhs.Y >= rhs.Y);
 0955        }
 956
 957        /// <summary>
 958        ///     Determine if <see cref="Byte2 " /> is greater than or equal a <see cref="byte" />.
 959        /// </summary>
 960        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 961        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 962        /// <returns>
 963        ///     Returns the result of a GREATER THAN OR EQUAL operation on a <see cref="Byte2" /> and a
 964        ///     <see cref="byte" />
 965        ///     value.
 966        /// </returns>
 967        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 968        public static bool2 operator >=(Byte2 lhs, byte rhs)
 0969        {
 0970            return new bool2(lhs.X >= rhs, lhs.Y >= rhs);
 0971        }
 972
 973        /// <summary>
 974        ///     Determine if <see cref="byte " /> is greater than or equal a <see cref="Byte2" />.
 975        /// </summary>
 976        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 977        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 978        /// <returns>
 979        ///     Returns the result of a GREATER THAN OR EQUAL operation on a <see cref="byte" /> and a
 980        ///     <see cref="Byte2" />
 981        ///     value.
 982        /// </returns>
 983        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 984        public static bool2 operator >=(byte lhs, Byte2 rhs)
 0985        {
 0986            return new bool2(lhs >= rhs.X, lhs >= rhs.Y);
 0987        }
 988
 989        /// <summary>
 990        ///     Determine if one <see cref="Byte2" /> is equal to another <see cref="Byte2" />.
 991        /// </summary>
 992        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 993        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 994        /// <returns>Returns the result of an EQUALITY operation on two <see cref="Byte2" />.</returns>
 995        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 996        public static bool2 operator ==(Byte2 lhs, Byte2 rhs)
 0997        {
 0998            return new bool2(lhs.X == rhs.X, lhs.Y == rhs.Y);
 0999        }
 1000
 1001        /// <summary>
 1002        ///     Determine if both components of a <see cref="Byte2" /> are equal to a <see cref="byte" />.
 1003        /// </summary>
 1004        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 1005        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 1006        /// <returns>Returns the result of an EQUALITY operation on a <see cref="Byte2" /> and a <see cref="byte" />.</r
 1007        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1008        public static bool2 operator ==(Byte2 lhs, byte rhs)
 01009        {
 01010            return new bool2(lhs.X == rhs, lhs.Y == rhs);
 01011        }
 1012
 1013        /// <summary>
 1014        ///     Determine if both components of a <see cref="Byte2" /> are equal to a <see cref="byte" />.
 1015        /// </summary>
 1016        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 1017        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 1018        /// <returns>Returns the result of an EQUALITY operation on a <see cref="byte" /> and a <see cref="Byte2" />.</r
 1019        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1020        public static bool2 operator ==(byte lhs, Byte2 rhs)
 01021        {
 01022            return new bool2(lhs == rhs.X, lhs == rhs.Y);
 01023        }
 1024
 1025        /// <summary>
 1026        ///     Determine if one <see cref="Byte2" /> is not equal to another <see cref="Byte2" />.
 1027        /// </summary>
 1028        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 1029        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 1030        /// <returns>Returns the result of a NOT EQUAL operation on two <see cref="Byte2" />.</returns>
 1031        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1032        public static bool2 operator !=(Byte2 lhs, Byte2 rhs)
 01033        {
 01034            return new bool2(lhs.X != rhs.X, lhs.Y != rhs.Y);
 01035        }
 1036
 1037        /// <summary>
 1038        ///     Determine if both components of a <see cref="Byte2" /> are not equal to a <see cref="byte" />.
 1039        /// </summary>
 1040        /// <param name="lhs">Left-hand side <see cref="Byte2" />.</param>
 1041        /// <param name="rhs">Right-hand side <see cref="byte" />.</param>
 1042        /// <returns>Returns the result of a NOT EQUAL operation on a <see cref="Byte2" /> and a <see cref="byte" />.</r
 1043        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1044        public static bool2 operator !=(Byte2 lhs, byte rhs)
 01045        {
 01046            return new bool2(lhs.X != rhs, lhs.Y != rhs);
 01047        }
 1048
 1049        /// <summary>
 1050        ///     Determine if both components of a <see cref="Byte2" /> are not equal to a <see cref="byte" />.
 1051        /// </summary>
 1052        /// <param name="lhs">Left-hand side <see cref="byte" />.</param>
 1053        /// <param name="rhs">Right-hand side <see cref="Byte2" />.</param>
 1054        /// <returns>Returns the result of a NOT EQUAL operation on a <see cref="byte" /> and a <see cref="Byte2" />.</r
 1055        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 1056        public static bool2 operator !=(byte lhs, Byte2 rhs)
 01057        {
 01058            return new bool2(lhs != rhs.X, lhs != rhs.Y);
 01059        }
 1060    }
 1061}

Methods/Properties

Byte2(System.Int32, System.Int32)
Byte2(System.Byte, System.Byte)
Byte2(GDX.Mathematics.Byte2)
Byte2(System.Byte)
Byte2(System.Boolean)
Byte2(System.Single)
Byte2(System.Double)
Byte2(Unity.Mathematics.bool2)
Byte2(Unity.Mathematics.float2)
Byte2(Unity.Mathematics.double2)
XX()
XY()
XY(GDX.Mathematics.Byte2)
YX()
YX(GDX.Mathematics.Byte2)
YY()
Item(System.Int32)
Item(System.Int32, System.Byte)
Equals(GDX.Mathematics.Byte2)
ToString(System.String, System.IFormatProvider)
Equals(System.Object)
implicit operator GDX.Mathematics.Byte2(System.Byte)
explicit operator GDX.Mathematics.Byte2(System.Boolean)
explicit operator GDX.Mathematics.Byte2(System.Single)
explicit operator GDX.Mathematics.Byte2(System.Double)
operator*(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator*(GDX.Mathematics.Byte2, System.Byte)
operator*(System.Byte, GDX.Mathematics.Byte2)
operator+(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator+(GDX.Mathematics.Byte2, System.Byte)
operator+(System.Byte, GDX.Mathematics.Byte2)
operator-(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator-(GDX.Mathematics.Byte2, System.Byte)
operator-(System.Byte, GDX.Mathematics.Byte2)
operator/(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator/(GDX.Mathematics.Byte2, System.Byte)
operator/(System.Byte, GDX.Mathematics.Byte2)
operator%(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator%(GDX.Mathematics.Byte2, System.Byte)
operator%(System.Byte, GDX.Mathematics.Byte2)
operator++(GDX.Mathematics.Byte2)
operator--(GDX.Mathematics.Byte2)
operator-(GDX.Mathematics.Byte2)
operator+(GDX.Mathematics.Byte2)
operator~(GDX.Mathematics.Byte2)
operator&(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator&(GDX.Mathematics.Byte2, System.Byte)
operator&(System.Byte, GDX.Mathematics.Byte2)
operator|(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator|(GDX.Mathematics.Byte2, System.Byte)
operator|(System.Byte, GDX.Mathematics.Byte2)
operator^(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator^(GDX.Mathematics.Byte2, System.Byte)
operator^(System.Byte, GDX.Mathematics.Byte2)
GetHashCode()
ToString()
DebuggerProxy(GDX.Mathematics.Byte2)
explicit operator GDX.Mathematics.Byte2(Unity.Mathematics.bool2)
explicit operator GDX.Mathematics.Byte2(Unity.Mathematics.float2)
explicit operator GDX.Mathematics.Byte2(Unity.Mathematics.double2)
operator<(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator<(GDX.Mathematics.Byte2, System.Byte)
operator<(System.Byte, GDX.Mathematics.Byte2)
operator<=(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator<=(GDX.Mathematics.Byte2, System.Byte)
operator<=(System.Byte, GDX.Mathematics.Byte2)
operator>(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator>(GDX.Mathematics.Byte2, System.Byte)
operator>(System.Byte, GDX.Mathematics.Byte2)
operator>=(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator>=(GDX.Mathematics.Byte2, System.Byte)
operator>=(System.Byte, GDX.Mathematics.Byte2)
operator==(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator==(GDX.Mathematics.Byte2, System.Byte)
operator==(System.Byte, GDX.Mathematics.Byte2)
operator!=(GDX.Mathematics.Byte2, GDX.Mathematics.Byte2)
operator!=(GDX.Mathematics.Byte2, System.Byte)
operator!=(System.Byte, GDX.Mathematics.Byte2)