107P17 = new Vector3(1, 2, 3),

36 internal static Vector3 ExtractScale(this Matrix4x4 matrix) => new Vector3(matrix.M11, matrix.M22, matrix.M33);

146 Acceleration = new Vector3(x, y, z);

134 AngularVelocity = new Vector3(x, y, z);

138 MagneticField = new Vector3(x, y, z);

34public Vector3 P17 { get; set; }

34 internal static Vector3 ExtractPosition(this Matrix4x4 matrix) => matrix.Translation; 36 internal static Vector3 ExtractScale(this Matrix4x4 matrix) => new Vector3(matrix.M11, matrix.M22, matrix.M33);

151 public Vector3 Acceleration { get; } 158 /// Compares the underlying <see cref="Vector3"/> instances. 278 void ProcessShakeEvent(Vector3 acceleration)

139 public Vector3 AngularVelocity { get; }

143 public Vector3 MagneticField { get; }

1340[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector3))]

11[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector3))]

10[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector3))]

151public Vector3 Translation 233public static Matrix4x4 CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector) 242public static Matrix4x4 CreateBillboardLeftHanded(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector) 252public static Matrix4x4 CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, Vector3 cameraForwardVector, Vector3 objectForwardVector) 262public static Matrix4x4 CreateConstrainedBillboardLeftHanded(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, Vector3 cameraForwardVector, Vector3 objectForwardVector) 269public static Matrix4x4 CreateFromAxisAngle(Vector3 axis, float angle) 291public static Matrix4x4 CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector) 293Vector3 cameraDirection = cameraTarget - cameraPosition; 302public static Matrix4x4 CreateLookAtLeftHanded(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector) 304Vector3 cameraDirection = cameraTarget - cameraPosition; 313public static Matrix4x4 CreateLookTo(Vector3 cameraPosition, Vector3 cameraDirection, Vector3 cameraUpVector) 321public static Matrix4x4 CreateLookToLeftHanded(Vector3 cameraPosition, Vector3 cameraDirection, Vector3 cameraUpVector) 476public static Matrix4x4 CreateRotationX(float radians, Vector3 centerPoint) 489public static Matrix4x4 CreateRotationY(float radians, Vector3 centerPoint) 502public static Matrix4x4 CreateRotationZ(float radians, Vector3 centerPoint) 519public static Matrix4x4 CreateScale(float xScale, float yScale, float zScale, Vector3 centerPoint) 525public static Matrix4x4 CreateScale(Vector3 scales) 532public static Matrix4x4 CreateScale(Vector3 scales, Vector3 centerPoint) 545public static Matrix4x4 CreateScale(float scale, Vector3 centerPoint) 552public static Matrix4x4 CreateShadow(Vector3 lightDirection, Plane plane) 558public static Matrix4x4 CreateTranslation(Vector3 position) 611public static Matrix4x4 CreateWorld(Vector3 position, Vector3 forward, Vector3 up) 620public static bool Decompose(Matrix4x4 matrix, out Vector3 scale, out Quaternion rotation, out Vector3 translation)

119public Vector3 Translation 215public static Impl CreateBillboard(in Vector3 objectPosition, in Vector3 cameraPosition, in Vector3 cameraUpVector, in Vector3 cameraForwardVector) 219Vector3 axisZ = objectPosition - cameraPosition; 229axisZ = Vector3.Normalize(axisZ); 232Vector3 axisX = Vector3.Normalize(Vector3.Cross(cameraUpVector, axisZ)); 233Vector3 axisY = Vector3.Cross(axisZ, axisX); 246public static Impl CreateBillboardLeftHanded(in Vector3 objectPosition, in Vector3 cameraPosition, in Vector3 cameraUpVector, in Vector3 cameraForwardVector) 250Vector3 axisZ = cameraPosition - objectPosition; 260axisZ = Vector3.Normalize(axisZ); 263Vector3 axisX = Vector3.Normalize(Vector3.Cross(cameraUpVector, axisZ)); 264Vector3 axisY = Vector3.Cross(axisZ, axisX); 277public static Impl CreateConstrainedBillboard(in Vector3 objectPosition, in Vector3 cameraPosition, in Vector3 rotateAxis, in Vector3 cameraForwardVector, in Vector3 objectForwardVector) 281Vector3 faceDir = objectPosition - cameraPosition; 291faceDir = Vector3.Normalize(faceDir); 294Vector3 axisY = rotateAxis; 296float dot = Vector3.Dot(axisY, faceDir); 312dot = Vector3.Dot(axisY, faceDir); 320faceDir = (float.Abs(axisY.Z) > BillboardMinAngle) ? Vector3.UnitX : Vector3.Create(0, 0, -1); 324Vector3 axisX = Vector3.Normalize(Vector3.Cross(axisY, faceDir)); 325Vector3 axisZ = Vector3.Normalize(Vector3.Cross(axisX, axisY)); 337public static Impl CreateConstrainedBillboardLeftHanded(in Vector3 objectPosition, in Vector3 cameraPosition, in Vector3 rotateAxis, in Vector3 cameraForwardVector, in Vector3 objectForwardVector) 341Vector3 faceDir = cameraPosition - objectPosition; 351faceDir = Vector3.Normalize(faceDir); 354Vector3 axisY = rotateAxis; 356float dot = Vector3.Dot(axisY, faceDir); 372dot = Vector3.Dot(axisY, faceDir); 380faceDir = (float.Abs(axisY.Z) > BillboardMinAngle) ? Vector3.Create(-1, 0, 0) : Vector3.Create(0, 0, -1); 384Vector3 axisX = Vector3.Normalize(Vector3.Cross(axisY, faceDir)); 385Vector3 axisZ = Vector3.Normalize(Vector3.Cross(axisX, axisY)); 398public static Impl CreateFromAxisAngle(in Vector3 axis, float angle) 451public static Impl CreateLookTo(in Vector3 cameraPosition, in Vector3 cameraDirection, in Vector3 cameraUpVector) 460public static Impl CreateLookToLeftHanded(in Vector3 cameraPosition, in Vector3 cameraDirection, in Vector3 cameraUpVector) 465Vector3 axisZ = Vector3.Normalize(cameraDirection); 466Vector3 axisX = Vector3.Normalize(Vector3.Cross(cameraUpVector, axisZ)); 467Vector3 axisY = Vector3.Cross(axisZ, axisX); 468Vector3 negativeCameraPosition = -cameraPosition; 472result.X = Vector4.Create(axisX, Vector3.Dot(axisX, negativeCameraPosition)); 473result.Y = Vector4.Create(axisY, Vector3.Dot(axisY, negativeCameraPosition)); 474result.Z = Vector4.Create(axisZ, Vector3.Dot(axisZ, negativeCameraPosition)); 766public static Impl CreateRotationX(float radians, in Vector3 centerPoint) 809public static Impl CreateRotationY(float radians, in Vector3 centerPoint) 852public static Impl CreateRotationZ(float radians, in Vector3 centerPoint) 888public static Impl CreateScale(float scaleX, float scaleY, float scaleZ, in Vector3 centerPoint) 895result.W = Vector4.Create(centerPoint * (Vector3.One - Vector3.Create(scaleX, scaleY, scaleZ)), 1); 901public static Impl CreateScale(in Vector3 scales) 914public static Impl CreateScale(in Vector3 scales, in Vector3 centerPoint) 921result.W = Vector4.Create(centerPoint * (Vector3.One - scales), 1); 940public static Impl CreateScale(float scale, in Vector3 centerPoint) 947result.W = Vector4.Create(centerPoint * (Vector3.One - Vector3.Create(scale)), 1); 953public static Impl CreateShadow(in Vector3 lightDirection, in Plane plane) 972public static Impl CreateTranslation(in Vector3 position) 1033public static Impl CreateWorld(in Vector3 position, in Vector3 forward, in Vector3 up) 1035Vector3 axisZ = Vector3.Normalize(-forward); 1036Vector3 axisX = Vector3.Normalize(Vector3.Cross(up, axisZ)); 1037Vector3 axisY = Vector3.Cross(axisZ, axisX); 1050public static unsafe bool Decompose(in Impl matrix, out Vector3 scale, out Quaternion rotation, out Vector3 translation) 1054Vector3* canonicalBasis = stackalloc Vector3[3] { 1055Vector3.UnitX, 1056Vector3.UnitY, 1057Vector3.UnitZ, 1062Vector3** vectorBasis = stackalloc Vector3*[3] { 1063(Vector3*)&matTemp.X, 1064(Vector3*)&matTemp.Y, 1065(Vector3*)&matTemp.Z, 1140*vectorBasis[a] = Vector3.Normalize(*vectorBasis[a]); 1190*vectorBasis[b] = Vector3.Cross(*vectorBasis[a], canonicalBasis[cc]); 1193*vectorBasis[b] = Vector3.Normalize(*vectorBasis[b]); 1197*vectorBasis[c] = Vector3.Cross(*vectorBasis[a], *vectorBasis[b]); 1200*vectorBasis[c] = Vector3.Normalize(*vectorBasis[c]); 1232scale = Unsafe.ReadUnaligned<Vector3>(scales);

18public Vector3 Normal; 38public Plane(Vector3 normal, float d) 65internal static Plane Create(Vector3 normal, float d) => Vector4.Create(normal, d).AsPlane(); 73public static Plane CreateFromVertices(Vector3 point1, Vector3 point2, Vector3 point3) 78Vector3 normal = Vector3.Normalize(Vector3.Cross(point2 - point1, point3 - point1)); 82-Vector3.Dot(normal, point1) 98public static float DotCoordinate(Plane plane, Vector3 value) 110public static float DotNormal(Plane plane, Vector3 value) 115return Vector3.Dot(plane.Normal, value);

45public Quaternion(Vector3 vectorPart, float scalarPart) 208internal static Quaternion Create(Vector3 vectorPart, float scalarPart) => Vector4.Create(vectorPart, scalarPart).AsQuaternion(); 216public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle) 222return (Vector4.Create(axis, 1) * Vector4.Create(Vector3.Create(s), c)).AsQuaternion(); 284(Vector3 sin, Vector3 cos) = Vector3.SinCos(Vector3.Create(roll, pitch, yaw) * 0.5f);

18public partial struct Vector3 : IEquatable<Vector3>, IFormattable 20/// <summary>Specifies the alignment of the vector as used by the <see cref="LoadAligned(float*)" /> and <see cref="Vector.StoreAligned(Vector3, float*)" /> APIs.</summary> 49/// <summary>Creates a new <see cref="Vector3" /> object whose three elements have the same value.</summary> 57/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and the specified value.</summary> 85public static Vector3 AllBitsSet 92public static Vector3 E 99public static Vector3 Epsilon 106public static Vector3 NaN 113public static Vector3 NegativeInfinity 120public static Vector3 NegativeZero 127public static Vector3 One 134public static Vector3 Pi 141public static Vector3 PositiveInfinity 148public static Vector3 Tau 156public static Vector3 UnitX 164public static Vector3 UnitY 172public static Vector3 UnitZ 179public static Vector3 Zero 205/// <remarks>The <see cref="op_Addition" /> method defines the addition operation for <see cref="Vector3" /> objects.</remarks> 208public static Vector3 operator +(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() + right.AsVector128Unsafe()).AsVector3(); 214/// <remarks>The <see cref="Vector3.op_Division" /> method defines the division operation for <see cref="Vector3" /> objects.</remarks> 217public static Vector3 operator /(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() / right.AsVector128Unsafe()).AsVector3(); 223/// <remarks>The <see cref="Vector3.op_Division" /> method defines the division operation for <see cref="Vector3" /> objects.</remarks> 226public static Vector3 operator /(Vector3 value1, float value2) => (value1.AsVector128Unsafe() / value2).AsVector3(); 232/// <remarks>Two <see cref="Vector3" /> objects are equal if each element in <paramref name="left" /> is equal to the corresponding element in <paramref name="right" />.</remarks> 235public static bool operator ==(Vector3 left, Vector3 right) => left.AsVector128() == right.AsVector128(); 242public static bool operator !=(Vector3 left, Vector3 right) => !(left == right); 248/// <remarks>The <see cref="Vector3.op_Multiply" /> method defines the multiplication operation for <see cref="Vector3" /> objects.</remarks> 251public static Vector3 operator *(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() * right.AsVector128Unsafe()).AsVector3(); 257/// <remarks>The <see cref="Vector3.op_Multiply" /> method defines the multiplication operation for <see cref="Vector3" /> objects.</remarks> 260public static Vector3 operator *(Vector3 left, float right) => (left.AsVector128Unsafe() * right).AsVector3(); 266/// <remarks>The <see cref="Vector3.op_Multiply" /> method defines the multiplication operation for <see cref="Vector3" /> objects.</remarks> 268public static Vector3 operator *(float left, Vector3 right) => right * left; 274/// <remarks>The <see cref="op_Subtraction" /> method defines the subtraction operation for <see cref="Vector3" /> objects.</remarks> 277public static Vector3 operator -(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() - right.AsVector128Unsafe()).AsVector3(); 282/// <remarks>The <see cref="op_UnaryNegation" /> method defines the unary negation operation for <see cref="Vector3" /> objects.</remarks> 285public static Vector3 operator -(Vector3 value) => (-value.AsVector128Unsafe()).AsVector3(); 290public static Vector3 operator &(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() & right.AsVector128Unsafe()).AsVector3(); 295public static Vector3 operator |(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() | right.AsVector128Unsafe()).AsVector3(); 300public static Vector3 operator ^(Vector3 left, Vector3 right) => (left.AsVector128Unsafe() ^ right.AsVector128Unsafe()).AsVector3(); 305public static Vector3 operator <<(Vector3 value, int shiftAmount) => (value.AsVector128Unsafe() << shiftAmount).AsVector3(); 310public static Vector3 operator ~(Vector3 value) => (~value.AsVector128Unsafe()).AsVector3(); 315public static Vector3 operator >>(Vector3 value, int shiftAmount) => (value.AsVector128Unsafe() >> shiftAmount).AsVector3(); 320public static Vector3 operator +(Vector3 value) => value; 325public static Vector3 operator >>>(Vector3 value, int shiftAmount) => (value.AsVector128Unsafe() >>> shiftAmount).AsVector3(); 332public static Vector3 Abs(Vector3 value) => Vector128.Abs(value.AsVector128Unsafe()).AsVector3(); 339public static Vector3 Add(Vector3 left, Vector3 right) => left + right; 344public static bool All(Vector3 vector, float value) => Vector128.All(vector, value); 349public static bool AllWhereAllBitsSet(Vector3 vector) => Vector128.AllWhereAllBitsSet(vector); 354public static Vector3 AndNot(Vector3 left, Vector3 right) => Vector128.AndNot(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 359public static bool Any(Vector3 vector, float value) => Vector128.Any(vector, value); 364public static bool AnyWhereAllBitsSet(Vector3 vector) => Vector128.AnyWhereAllBitsSet(vector); 368public static Vector3 BitwiseAnd(Vector3 left, Vector3 right) => left & right; 372public static Vector3 BitwiseOr(Vector3 left, Vector3 right) => left | right; 377public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max) => Vector128.Clamp(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector3(); 382public static Vector3 ClampNative(Vector3 value1, Vector3 min, Vector3 max) => Vector128.ClampNative(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector3(); 387public static Vector3 ConditionalSelect(Vector3 condition, Vector3 left, Vector3 right) => Vector128.ConditionalSelect(condition.AsVector128Unsafe(), left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 392public static Vector3 CopySign(Vector3 value, Vector3 sign) => Vector128.CopySign(value.AsVector128Unsafe(), sign.AsVector128Unsafe()).AsVector3(); 396public static Vector3 Cos(Vector3 vector) => Vector128.Cos(vector.AsVector128()).AsVector3(); 401public static int Count(Vector3 vector, float value) => Vector128.Count(vector, value); 406public static int CountWhereAllBitsSet(Vector3 vector) => Vector128.CountWhereAllBitsSet(vector); 408/// <summary>Creates a new <see cref="Vector3" /> object whose three elements have the same value.</summary> 410/// <returns>A new <see cref="Vector3" /> whose three elements have the same value.</returns> 412public static Vector3 Create(float value) => Vector128.Create(value).AsVector3(); 414/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 417/// <returns>A new <see cref="Vector3" /> from the specified <see cref="Vector2" /> object and a Z and a W component.</returns> 420public static Vector3 Create(Vector2 vector, float z) 431/// <returns>A new <see cref="Vector3" /> whose elements have the specified values.</returns> 433public static Vector3 Create(float x, float y, float z) => Vector128.Create(x, y, z, 0).AsVector3(); 437/// <returns>A new <see cref="Vector3" /> whose elements have the specified values.</returns> 440public static Vector3 Create(ReadOnlySpan<float> values) 446return Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 451/// <returns>A new <see cref="Vector3" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements initialized to zero.</returns> 453internal static Vector3 CreateScalar(float x) => Vector128.CreateScalar(x).AsVector3(); 457/// <returns>A new <see cref="Vector3" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements left uninitialized.</returns> 459internal static Vector3 CreateScalarUnsafe(float x) => Vector128.CreateScalarUnsafe(x).AsVector3(); 466public static Vector3 Cross(Vector3 vector1, Vector3 vector2) 486public static Vector3 DegreesToRadians(Vector3 degrees) => Vector128.DegreesToRadians(degrees.AsVector128Unsafe()).AsVector3(); 493public static float Distance(Vector3 value1, Vector3 value2) => float.Sqrt(DistanceSquared(value1, value2)); 500public static float DistanceSquared(Vector3 value1, Vector3 value2) => (value1 - value2).LengthSquared(); 507public static Vector3 Divide(Vector3 left, Vector3 right) => left / right; 514public static Vector3 Divide(Vector3 left, float divisor) => left / divisor; 522public static float Dot(Vector3 vector1, Vector3 vector2) => Vector128.Dot(vector1.AsVector128(), vector2.AsVector128()); 526public static Vector3 Exp(Vector3 vector) => Vector128.Exp(vector.AsVector128()).AsVector3(); 531public static Vector3 Equals(Vector3 left, Vector3 right) => Vector128.Equals(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 536public static bool EqualsAll(Vector3 left, Vector3 right) => Vector128.EqualsAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 541public static bool EqualsAny(Vector3 left, Vector3 right) => Vector128.EqualsAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 546public static Vector3 FusedMultiplyAdd(Vector3 left, Vector3 right, Vector3 addend) => Vector128.FusedMultiplyAdd(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector3(); 551public static Vector3 GreaterThan(Vector3 left, Vector3 right) => Vector128.GreaterThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 556public static bool GreaterThanAll(Vector3 left, Vector3 right) => Vector128.GreaterThanAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 561public static bool GreaterThanAny(Vector3 left, Vector3 right) => Vector128.GreaterThanAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 566public static Vector3 GreaterThanOrEqual(Vector3 left, Vector3 right) => Vector128.GreaterThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 571public static bool GreaterThanOrEqualAll(Vector3 left, Vector3 right) => Vector128.GreaterThanOrEqualAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 576public static bool GreaterThanOrEqualAny(Vector3 left, Vector3 right) => Vector128.GreaterThanOrEqualAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 581public static Vector3 Hypot(Vector3 x, Vector3 y) => Vector128.Hypot(x.AsVector128Unsafe(), y.AsVector128Unsafe()).AsVector3(); 586public static int IndexOf(Vector3 vector, float value) => Vector128.IndexOf(vector, value); 591public static int IndexOfWhereAllBitsSet(Vector3 vector) => Vector128.IndexOfWhereAllBitsSet(vector); 596public static Vector3 IsEvenInteger(Vector3 vector) => Vector128.IsEvenInteger(vector.AsVector128()).AsVector3(); 601public static Vector3 IsFinite(Vector3 vector) => Vector128.IsFinite(vector.AsVector128()).AsVector3(); 606public static Vector3 IsInfinity(Vector3 vector) => Vector128.IsInfinity(vector.AsVector128()).AsVector3(); 611public static Vector3 IsInteger(Vector3 vector) => Vector128.IsInteger(vector.AsVector128()).AsVector3(); 616public static Vector3 IsNaN(Vector3 vector) => Vector128.IsNaN(vector.AsVector128()).AsVector3(); 621public static Vector3 IsNegative(Vector3 vector) => Vector128.IsNegative(vector.AsVector128()).AsVector3(); 626public static Vector3 IsNegativeInfinity(Vector3 vector) => Vector128.IsNegativeInfinity(vector.AsVector128()).AsVector3(); 631public static Vector3 IsNormal(Vector3 vector) => Vector128.IsNormal(vector.AsVector128()).AsVector3(); 636public static Vector3 IsOddInteger(Vector3 vector) => Vector128.IsOddInteger(vector.AsVector128()).AsVector3(); 641public static Vector3 IsPositive(Vector3 vector) => Vector128.IsPositive(vector.AsVector128()).AsVector3(); 646public static Vector3 IsPositiveInfinity(Vector3 vector) => Vector128.IsPositiveInfinity(vector.AsVector128()).AsVector3(); 651public static Vector3 IsSubnormal(Vector3 vector) => Vector128.IsSubnormal(vector.AsVector128()).AsVector3(); 656public static Vector3 IsZero(Vector3 vector) => Vector128.IsZero(vector.AsVector128()).AsVector3(); 661public static int LastIndexOf(Vector3 vector, float value) => Vector128.LastIndexOf(vector, value); 666public static int LastIndexOfWhereAllBitsSet(Vector3 vector) => Vector128.LastIndexOfWhereAllBitsSet(vector); 671public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount) => Lerp(value1, value2, Create(amount)); 676public static Vector3 Lerp(Vector3 value1, Vector3 value2, Vector3 amount) => Vector128.Lerp(value1.AsVector128Unsafe(), value2.AsVector128Unsafe(), amount.AsVector128Unsafe()).AsVector3(); 681public static Vector3 LessThan(Vector3 left, Vector3 right) => Vector128.LessThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 686public static bool LessThanAll(Vector3 left, Vector3 right) => Vector128.LessThanAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 691public static bool LessThanAny(Vector3 left, Vector3 right) => Vector128.LessThanAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 696public static Vector3 LessThanOrEqual(Vector3 left, Vector3 right) => Vector128.LessThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector3(); 701public static bool LessThanOrEqualAll(Vector3 left, Vector3 right) => Vector128.LessThanOrEqualAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 706public static bool LessThanOrEqualAny(Vector3 left, Vector3 right) => Vector128.LessThanOrEqualAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 711public static unsafe Vector3 Load(float* source) => LoadUnsafe(in *source); 717public static unsafe Vector3 LoadAligned(float* source) 724return *(Vector3*)source; 730public static unsafe Vector3 LoadAlignedNonTemporal(float* source) => LoadAligned(source); 735public static Vector3 LoadUnsafe(ref readonly float source) 738return Unsafe.ReadUnaligned<Vector3>(in address); 745public static Vector3 LoadUnsafe(ref readonly float source, nuint elementOffset) 748return Unsafe.ReadUnaligned<Vector3>(in address); 753public static Vector3 Log(Vector3 vector) => Vector128.Log(Vector4.Create(vector, 1.0f).AsVector128()).AsVector3(); 757public static Vector3 Log2(Vector3 vector) => Vector128.Log2(Vector4.Create(vector, 1.0f).AsVector128()).AsVector3(); 762public static Vector3 Max(Vector3 value1, Vector3 value2) => Vector128.Max(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 767public static Vector3 MaxMagnitude(Vector3 value1, Vector3 value2) => Vector128.MaxMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 772public static Vector3 MaxMagnitudeNumber(Vector3 value1, Vector3 value2) => Vector128.MaxMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 777public static Vector3 MaxNative(Vector3 value1, Vector3 value2) => Vector128.MaxNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 782public static Vector3 MaxNumber(Vector3 value1, Vector3 value2) => Vector128.MaxNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 787public static Vector3 Min(Vector3 value1, Vector3 value2) => Vector128.Min(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 792public static Vector3 MinMagnitude(Vector3 value1, Vector3 value2) => Vector128.MinMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 797public static Vector3 MinMagnitudeNumber(Vector3 value1, Vector3 value2) => Vector128.MinMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 802public static Vector3 MinNative(Vector3 value1, Vector3 value2) => Vector128.MinNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 807public static Vector3 MinNumber(Vector3 value1, Vector3 value2) => Vector128.MinNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector3(); 814public static Vector3 Multiply(Vector3 left, Vector3 right) => left * right; 821public static Vector3 Multiply(Vector3 left, float right) => left * right; 828public static Vector3 Multiply(float left, Vector3 right) => left * right; 833public static Vector3 MultiplyAddEstimate(Vector3 left, Vector3 right, Vector3 addend) => Vector128.MultiplyAddEstimate(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector3(); 839public static Vector3 Negate(Vector3 value) => -value; 844public static bool None(Vector3 vector, float value) => Vector128.None(vector, value); 849public static bool NoneWhereAllBitsSet(Vector3 vector) => Vector128.NoneWhereAllBitsSet(vector); 855public static Vector3 Normalize(Vector3 value) => value / value.Length(); 859public static Vector3 OnesComplement(Vector3 value) => ~value; 864public static Vector3 RadiansToDegrees(Vector3 radians) => Vector128.RadiansToDegrees(radians.AsVector128Unsafe()).AsVector3(); 871public static Vector3 Reflect(Vector3 vector, Vector3 normal) 876Vector3 tmp = Create(Dot(vector, normal)); 883public static Vector3 Round(Vector3 vector) => Vector128.Round(vector.AsVector128Unsafe()).AsVector3(); 887public static Vector3 Round(Vector3 vector, MidpointRounding mode) => Vector128.Round(vector.AsVector128Unsafe(), mode).AsVector3(); 896public static Vector3 Shuffle(Vector3 vector, byte xIndex, byte yIndex, byte zIndex) 905public static Vector3 Sin(Vector3 vector) => Vector128.Sin(vector.AsVector128()).AsVector3(); 909public static (Vector3 Sin, Vector3 Cos) SinCos(Vector3 vector) 920public static Vector3 SquareRoot(Vector3 value) => Vector128.Sqrt(value.AsVector128Unsafe()).AsVector3(); 927public static Vector3 Subtract(Vector3 left, Vector3 right) => left - right; 932public static float Sum(Vector3 value) => Vector128.Sum(value.AsVector128()); 939public static Vector3 Transform(Vector3 position, Matrix4x4 matrix) => Vector4.Transform(position, in matrix.AsImpl()).AsVector128().AsVector3(); 946public static Vector3 Transform(Vector3 value, Quaternion rotation) => Vector4.Transform(value, rotation).AsVector3(); 953public static Vector3 TransformNormal(Vector3 normal, Matrix4x4 matrix) => TransformNormal(normal, in matrix.AsImpl()); 956internal static Vector3 TransformNormal(Vector3 normal, in Matrix4x4.Impl matrix) 968public static Vector3 Truncate(Vector3 vector) => Vector128.Truncate(vector.AsVector128Unsafe()).AsVector3(); 972public static Vector3 Xor(Vector3 left, Vector3 right) => left ^ right; 1053/// <remarks>The current instance and <paramref name="obj" /> are equal if <paramref name="obj" /> is a <see cref="Vector3" /> object and their corresponding elements are equal.</remarks> 1054public override readonly bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector3 other) && Equals(other); 1061public readonly bool Equals(Vector3 other) => this.AsVector128().Equals(other.AsVector128());

12/// <summary>Converts a <see cref="Vector3" /> to a new <see cref="Vector4" /> with the new elements zeroed.</summary> 15public static Vector4 AsVector4(this Vector3 value) => value.AsVector128().AsVector4(); 17/// <summary>Converts a <see cref="Vector3" /> to a new <see cref="Vector4" /> with the new elements undefined.</summary> 20public static Vector4 AsVector4Unsafe(this Vector3 value) => value.AsVector128Unsafe().AsVector4(); 25public static uint ExtractMostSignificantBits(this Vector3 vector) => vector.AsVector128().ExtractMostSignificantBits(); 29public static float GetElement(this Vector3 vector, int index) 31if ((uint)index >= Vector3.ElementCount) 42public static void Store(this Vector3 source, float* destination) => source.StoreUnsafe(ref *destination); 50public static void StoreAligned(this Vector3 source, float* destination) 52if (((nuint)destination % (uint)(Vector3.Alignment)) != 0) 57*(Vector3*)destination = source; 66public static void StoreAlignedNonTemporal(this Vector3 source, float* destination) => source.StoreAligned(destination); 72public static void StoreUnsafe(this Vector3 source, ref float destination) 84public static void StoreUnsafe(this Vector3 source, ref float destination, nuint elementOffset) 92public static float ToScalar(this Vector3 vector) => vector.AsVector128Unsafe().ToScalar(); 96public static Vector3 WithElement(this Vector3 vector, int index, float value) 98if ((uint)index >= Vector3.ElementCount)

69/// <summary>Constructs a new <see cref="Vector4" /> object from the specified <see cref="Vector3" /> object and a W component.</summary> 73public Vector4(Vector3 value, float w) 461/// <summary>Constructs a new <see cref="Vector4" /> object from the specified <see cref="Vector3" /> object and a W component.</summary> 464/// <returns>A new <see cref="Vector4" /> from the specified <see cref="Vector3" /> object and a W component.</returns> 467public static Vector4 Create(Vector3 vector, float w) 510/// <see cref="Vector3.Cross"/> with the addition of the fourth value which is 512/// the cross product for <see cref="Vector3"/> with values [x_1/w_1, y_1/w_1, z_1/w_1] 993public static Vector4 Transform(Vector3 position, Matrix4x4 matrix) => Transform(position, in matrix.AsImpl()); 996internal static Vector4 Transform(Vector3 position, in Matrix4x4.Impl matrix) 1012public static Vector4 Transform(Vector3 value, Quaternion rotation) => Transform(Create(value, 1.0f), rotation);

41/// <summary>Reinterprets a <see cref="Vector4" /> as a new <see cref="Vector3" />.</summary> 43/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector3" />.</returns> 44public static Vector3 AsVector3(this Vector4 value) => value.AsVector128().AsVector3();

20internal static bool All(Vector3 vector, float value) => vector.AsVector128() == Vector3.Create(value).AsVector128(); 30internal static bool AllWhereAllBitsSet(Vector3 vector) => vector.AsVector128().AsInt32() == Vector3.AllBitsSet.AsVector128().AsInt32(); 40internal static bool Any(Vector3 vector, float value) => EqualsAny(vector.AsVector128(), Create(value, value, value, -1)); 50internal static bool AnyWhereAllBitsSet(Vector3 vector) => EqualsAny(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet); 114public static Vector128<float> AsVector128(this Vector3 value) => Vector4.Create(value, 0).AsVector128(); 163public static Vector128<float> AsVector128Unsafe(this Vector3 value) 184/// <summary>Reinterprets a <see langword="Vector128&lt;Single&gt;" /> as a new <see cref="Vector3" />.</summary> 186/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector3" />.</returns> 189public static Vector3 AsVector3(this Vector128<float> value) 192return Unsafe.ReadUnaligned<Vector3>(ref address); 233internal static int Count(Vector3 vector, float value) => BitOperations.PopCount(Equals(vector.AsVector128(), Create(value, value, value, -1)).ExtractMostSignificantBits()); 243internal static int CountWhereAllBitsSet(Vector3 vector) => BitOperations.PopCount(Equals(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet).ExtractMostSignificantBits()); 257internal static int IndexOf(Vector3 vector, float value) 275internal static int IndexOfWhereAllBitsSet(Vector3 vector) 289internal static int LastIndexOf(Vector3 vector, float value) => 31 - BitOperations.LeadingZeroCount(Equals(vector.AsVector128(), Create(value, value, value, -1)).ExtractMostSignificantBits()); 299internal static int LastIndexOfWhereAllBitsSet(Vector3 vector) => 31 - BitOperations.LeadingZeroCount(Equals(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet).ExtractMostSignificantBits()); 309internal static bool None(Vector3 vector, float value) => !EqualsAny(vector.AsVector128(), Create(value, value, value, -1)); 319internal static bool NoneWhereAllBitsSet(Vector3 vector) => !EqualsAny(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet);