Gottfried/glitchy-engine-beef
1
0
Fork 0
mirror of https://github.com/aharabada/glitchy-engine-beef.git synced 2026-09-05 13:01:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added explicit conversion from float to Vector

Browse Source
This commit is contained in:
Simon Lübeß
2021-03-26 19:12:08 +01:00
parent 0f62637662
commit 5a6abc9b8b
3 changed files with 306 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
GlitchyEngine/src/Math/Vector2.bf
+3
View File
@@ -223,5 +223,8 @@ namespace GlitchyEngine.Math
[Inline] [Inline]
public static implicit operator Self(in DirectX.Math.Vector2 value) => *(Self*)&value; public static implicit operator Self(in DirectX.Math.Vector2 value) => *(Self*)&value;
[Inline]
public static explicit operator Self(float value) => Self(value);
} }
} }
GlitchyEngine/src/Math/Vector3.bf
+300 -297
View File
@@ -1,297 +1,300 @@
using System; using System;
namespace GlitchyEngine.Math namespace GlitchyEngine.Math
{ {
//[SwizzleVector(3, "Vector")] //[SwizzleVector(3, "Vector")]
public struct Vector3 public struct Vector3
{ {
public const Vector3 Zero = .(0f, 0f, 0f); public const Vector3 Zero = .(0f, 0f, 0f);
public const Vector3 UnitX = .(1f, 0f, 0f); public const Vector3 UnitX = .(1f, 0f, 0f);
public const Vector3 UnitY = .(0f, 1f, 0f); public const Vector3 UnitY = .(0f, 1f, 0f);
public const Vector3 UnitZ = .(0f, 0f, 1f); public const Vector3 UnitZ = .(0f, 0f, 1f);
public const Vector3 One = .(1f, 1f, 1f); public const Vector3 One = .(1f, 1f, 1f);
public const Vector3 Forward = .(0f, 0f, 1f); public const Vector3 Forward = .(0f, 0f, 1f);
public const Vector3 Backward = .(0f, 0f, -1f); public const Vector3 Backward = .(0f, 0f, -1f);
public const Vector3 Left = .(-1f, 0f, 0f); public const Vector3 Left = .(-1f, 0f, 0f);
public const Vector3 Right = .(1f, 0f, 0f); public const Vector3 Right = .(1f, 0f, 0f);
public const Vector3 Up = .(0f, 1f, 0f); public const Vector3 Up = .(0f, 1f, 0f);
public const Vector3 Down = .(0f, -1f, 0f); public const Vector3 Down = .(0f, -1f, 0f);
public float X, Y, Z; public float X, Y, Z;
public this() => this = default; public this() => this = default;
public this(float value) public this(float value)
{ {
X = value; X = value;
Y = value; Y = value;
Z = value; Z = value;
} }
public this(Vector2 value, float z) public this(Vector2 value, float z)
{ {
X = value.X; X = value.X;
Y = value.Y; Y = value.Y;
Z = z; Z = z;
} }
public this(float x, float y, float z) public this(float x, float y, float z)
{ {
X = x; X = x;
Y = y; Y = y;
Z = z; Z = z;
} }
public ref float this[int index] public ref float this[int index]
{ {
[Checked] [Checked]
get get
{ {
if(index < 0 || index > 2) if(index < 0 || index > 2)
Internal.ThrowIndexOutOfRange(); Internal.ThrowIndexOutOfRange();
#unwarn #unwarn
return ref (&X)[index]; return ref (&X)[index];
} }
[Inline] [Inline]
#unwarn #unwarn
get => ref (&X)[index]; get => ref (&X)[index];
} }
/** /**
* Calculates the magnitude (length) of this vector. * Calculates the magnitude (length) of this vector.
* @remarks MagnitudeSquared might be used if only the relative length is relevant. * @remarks MagnitudeSquared might be used if only the relative length is relevant.
*/ */
public float Magnitude() public float Magnitude()
{ {
return Math.Sqrt(X * X + Y * Y + Z * Z); return Math.Sqrt(X * X + Y * Y + Z * Z);
} }
/** /**
* Calculates the squared magnitude (length) of this vector. * Calculates the squared magnitude (length) of this vector.
*/ */
public float MagnitudeSquared() public float MagnitudeSquared()
{ {
return X * X + Y * Y + Z * Z; return X * X + Y * Y + Z * Z;
} }
/** /**
* Normalizes this vector. * Normalizes this vector.
*/ */
[Checked] [Checked]
public void Normalize() mut public void Normalize() mut
{ {
if(this == .Zero) if(this == .Zero)
return; return;
this /= Magnitude(); this /= Magnitude();
} }
/** /**
* Normalizes this vector. * Normalizes this vector.
*/ */
public void Normalize() mut public void Normalize() mut
{ {
this /= Magnitude(); this /= Magnitude();
} }
/** /**
* Returns a copy of this Vector with a magnitude of 1. * Returns a copy of this Vector with a magnitude of 1.
*/ */
[Checked] [Checked]
public Vector3 Normalized() public Vector3 Normalized()
{ {
if(this == .Zero) if(this == .Zero)
return .Zero; return .Zero;
return this / Magnitude(); return this / Magnitude();
} }
/** /**
* Returns a copy of this Vector with a magnitude of 1. * Returns a copy of this Vector with a magnitude of 1.
*/ */
public Vector3 Normalized() public Vector3 Normalized()
{ {
return this / Magnitude(); return this / Magnitude();
} }
public static Vector3 Normalize(Vector3 v) public static Vector3 Normalize(Vector3 v)
{ {
return v / v.Magnitude(); return v / v.Magnitude();
} }
public static float Dot(Vector3 l, Vector3 r) public static float Dot(Vector3 l, Vector3 r)
{ {
return l.X * r.X + l.Y * r.Y + l.Z * r.Z; return l.X * r.X + l.Y * r.Y + l.Z * r.Z;
} }
public static Vector3 Cross(Vector3 l, Vector3 r) public static Vector3 Cross(Vector3 l, Vector3 r)
{ {
return .(l.Y * r.Z - l.Z * r.Y, return .(l.Y * r.Z - l.Z * r.Y,
l.Z * r.X - l.X * r.Z, l.Z * r.X - l.X * r.Z,
l.X * r.Y - l.Y * r.X); l.X * r.Y - l.Y * r.X);
} }
/** /**
* Calculates the projection of a onto b * Calculates the projection of a onto b
*/ */
public static Vector3 Project(Vector3 a, Vector3 b) public static Vector3 Project(Vector3 a, Vector3 b)
{ {
return (b * (Dot(a, b) / Dot(b, b))); return (b * (Dot(a, b) / Dot(b, b)));
} }
/** /**
* Calculates the rejection of a from b * Calculates the rejection of a from b
*/ */
public static Vector3 Reject(Vector3 a, Vector3 b) public static Vector3 Reject(Vector3 a, Vector3 b)
{ {
return (a - b * (Dot(a, b) / Dot(b, b))); return (a - b * (Dot(a, b) / Dot(b, b)));
} }
public static Vector3 Floor(Vector3 value) public static Vector3 Floor(Vector3 value)
{ {
return .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z)); return .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
} }
// //
// Assignment operators // Assignment operators
// //
// Addition // Addition
public void operator +=(Vector3 value) mut public void operator +=(Vector3 value) mut
{ {
X += value.X; X += value.X;
Y += value.Y; Y += value.Y;
Z += value.Z; Z += value.Z;
} }
public void operator +=(float scalar) mut public void operator +=(float scalar) mut
{ {
X += scalar; X += scalar;
Y += scalar; Y += scalar;
Z += scalar; Z += scalar;
} }
// Subtraction // Subtraction
public void operator -=(Vector3 value) mut public void operator -=(Vector3 value) mut
{ {
X -= value.X; X -= value.X;
Y -= value.Y; Y -= value.Y;
Z -= value.Z; Z -= value.Z;
} }
public void operator -=(float scalar) mut public void operator -=(float scalar) mut
{ {
X -= scalar; X -= scalar;
Y -= scalar; Y -= scalar;
Z -= scalar; Z -= scalar;
} }
// Multiplication // Multiplication
public void operator *=(Vector3 value) mut public void operator *=(Vector3 value) mut
{ {
X *= value.X; X *= value.X;
Y *= value.Y; Y *= value.Y;
Z *= value.Z; Z *= value.Z;
} }
public void operator *=(float scalar) mut public void operator *=(float scalar) mut
{ {
X *= scalar; X *= scalar;
Y *= scalar; Y *= scalar;
Z *= scalar; Z *= scalar;
} }
// Division // Division
public void operator /=(Vector3 value) mut public void operator /=(Vector3 value) mut
{ {
X /= value.X; X /= value.X;
Y /= value.Y; Y /= value.Y;
Z /= value.Z; Z /= value.Z;
} }
public void operator /=(float scalar) mut public void operator /=(float scalar) mut
{ {
float inv = 1.0f / scalar; float inv = 1.0f / scalar;
X *= inv; X *= inv;
Y *= inv; Y *= inv;
Z *= inv; Z *= inv;
} }
// //
// operators // operators
// //
// Addition // Addition
public static Vector3 operator +(Vector3 left, Vector3 right) => Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z); public static Vector3 operator +(Vector3 left, Vector3 right) => Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
public static Vector3 operator +(Vector3 value, float scalar) => Vector3(value.X + scalar, value.Y + scalar, value.Z + scalar); public static Vector3 operator +(Vector3 value, float scalar) => Vector3(value.X + scalar, value.Y + scalar, value.Z + scalar);
public static Vector3 operator +(float scalar, Vector3 value) => Vector3(scalar + value.X, scalar + value.Y, scalar + value.Z); public static Vector3 operator +(float scalar, Vector3 value) => Vector3(scalar + value.X, scalar + value.Y, scalar + value.Z);
public static Vector3 operator +(Vector3 value) => value; public static Vector3 operator +(Vector3 value) => value;
// Subtraction // Subtraction
public static Vector3 operator -(Vector3 left, Vector3 right) => Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z); public static Vector3 operator -(Vector3 left, Vector3 right) => Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
public static Vector3 operator -(Vector3 value, float scalar) => Vector3(value.X - scalar, value.Y - scalar, value.Z - scalar); public static Vector3 operator -(Vector3 value, float scalar) => Vector3(value.X - scalar, value.Y - scalar, value.Z - scalar);
public static Vector3 operator -(float scalar, Vector3 value) => Vector3(scalar - value.X, scalar - value.Y, scalar - value.Z); public static Vector3 operator -(float scalar, Vector3 value) => Vector3(scalar - value.X, scalar - value.Y, scalar - value.Z);
public static Vector3 operator -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z); public static Vector3 operator -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
// Multiplication // Multiplication
public static Vector3 operator *(Vector3 left, Vector3 right) => Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z); public static Vector3 operator *(Vector3 left, Vector3 right) => Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
public static Vector3 operator *(Vector3 value, float scalar) => Vector3(value.X * scalar, value.Y * scalar, value.Z * scalar); public static Vector3 operator *(Vector3 value, float scalar) => Vector3(value.X * scalar, value.Y * scalar, value.Z * scalar);
public static Vector3 operator *(float scalar, Vector3 value) => Vector3(scalar * value.X, scalar * value.Y, scalar * value.Z); public static Vector3 operator *(float scalar, Vector3 value) => Vector3(scalar * value.X, scalar * value.Y, scalar * value.Z);
// Division // Division
public static Vector3 operator /(Vector3 left, Vector3 right) => Vector3(left.X / right.X, left.Y / right.Y, left.Z / right.Z); public static Vector3 operator /(Vector3 left, Vector3 right) => Vector3(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
public static Vector3 operator /(Vector3 value, float scalar) public static Vector3 operator /(Vector3 value, float scalar)
{ {
float inv = 1.0f / scalar; float inv = 1.0f / scalar;
return Vector3(value.X * inv, value.Y * inv, value.Z * inv); return Vector3(value.X * inv, value.Y * inv, value.Z * inv);
} }
public static Vector3 operator /(float scalar, Vector3 value) => Vector3(scalar / value.X, scalar / value.Y, scalar / value.Z); public static Vector3 operator /(float scalar, Vector3 value) => Vector3(scalar / value.X, scalar / value.Y, scalar / value.Z);
// Modulo // Modulo
public static Vector3 operator %(Vector3 left, Vector3 right) => Vector3(left.X % right.X, left.Y % right.Y, left.Z % right.Z); public static Vector3 operator %(Vector3 left, Vector3 right) => Vector3(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
public static Vector3 operator %(Vector3 value, float scalar) => Vector3(value.X % scalar, value.Y % scalar, value.Z % scalar); public static Vector3 operator %(Vector3 value, float scalar) => Vector3(value.X % scalar, value.Y % scalar, value.Z % scalar);
public static Vector3 operator %(float scalar, Vector3 value) => Vector3(scalar % value.X, scalar % value.Y, scalar % value.Z); public static Vector3 operator %(float scalar, Vector3 value) => Vector3(scalar % value.X, scalar % value.Y, scalar % value.Z);
// Equality // Equality
public static bool operator ==(Vector3 left, Vector3 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z; public static bool operator ==(Vector3 left, Vector3 right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
public static bool operator !=(Vector3 left, Vector3 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z; public static bool operator !=(Vector3 left, Vector3 right) => left.X != right.X || left.Y != right.Y || left.Z != right.Z;
public override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z); public override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z);
// Todo: move to extension // Todo: move to extension
[Inline] [Inline]
public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value; public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value;
[Inline] [Inline]
public static implicit operator Self(in DirectX.Math.Vector3 value) => *(Self*)&value; public static implicit operator Self(in DirectX.Math.Vector3 value) => *(Self*)&value;
}
} [Inline]
public static explicit operator Self(float value) => Self(value);
}
}
GlitchyEngine/src/Math/Vector4.bf
+3
View File
@@ -274,5 +274,8 @@ namespace GlitchyEngine.Math
[Inline] [Inline]
public static implicit operator Self(in DirectX.Math.Vector4 value) => *(Self*)&value; public static implicit operator Self(in DirectX.Math.Vector4 value) => *(Self*)&value;
[Inline]
public static explicit operator Self(float value) => Self(value);
} }
} }