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]
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;
namespace GlitchyEngine.Math
{
//[SwizzleVector(3, "Vector")]
public struct Vector3
{
public const Vector3 Zero = .(0f, 0f, 0f);
public const Vector3 UnitX = .(1f, 0f, 0f);
public const Vector3 UnitY = .(0f, 1f, 0f);
public const Vector3 UnitZ = .(0f, 0f, 1f);
public const Vector3 One = .(1f, 1f, 1f);
public const Vector3 Forward = .(0f, 0f, 1f);
public const Vector3 Backward = .(0f, 0f, -1f);
public const Vector3 Left = .(-1f, 0f, 0f);
public const Vector3 Right = .(1f, 0f, 0f);
public const Vector3 Up = .(0f, 1f, 0f);
public const Vector3 Down = .(0f, -1f, 0f);
public float X, Y, Z;
public this() => this = default;
public this(float value)
{
X = value;
Y = value;
Z = value;
}
public this(Vector2 value, float z)
{
X = value.X;
Y = value.Y;
Z = z;
}
public this(float x, float y, float z)
{
X = x;
Y = y;
Z = z;
}
public ref float this[int index]
{
[Checked]
get
{
if(index < 0 || index > 2)
Internal.ThrowIndexOutOfRange();
#unwarn
return ref (&X)[index];
}
[Inline]
#unwarn
get => ref (&X)[index];
}
/**
* Calculates the magnitude (length) of this vector.
* @remarks MagnitudeSquared might be used if only the relative length is relevant.
*/
public float Magnitude()
{
return Math.Sqrt(X * X + Y * Y + Z * Z);
}
/**
* Calculates the squared magnitude (length) of this vector.
*/
public float MagnitudeSquared()
{
return X * X + Y * Y + Z * Z;
}
/**
* Normalizes this vector.
*/
[Checked]
public void Normalize() mut
{
if(this == .Zero)
return;
this /= Magnitude();
}
/**
* Normalizes this vector.
*/
public void Normalize() mut
{
this /= Magnitude();
}
/**
* Returns a copy of this Vector with a magnitude of 1.
*/
[Checked]
public Vector3 Normalized()
{
if(this == .Zero)
return .Zero;
return this / Magnitude();
}
/**
* Returns a copy of this Vector with a magnitude of 1.
*/
public Vector3 Normalized()
{
return this / Magnitude();
}
public static Vector3 Normalize(Vector3 v)
{
return v / v.Magnitude();
}
public static float Dot(Vector3 l, Vector3 r)
{
return l.X * r.X + l.Y * r.Y + l.Z * r.Z;
}
public static Vector3 Cross(Vector3 l, Vector3 r)
{
return .(l.Y * r.Z - l.Z * r.Y,
l.Z * r.X - l.X * r.Z,
l.X * r.Y - l.Y * r.X);
}
/**
* Calculates the projection of a onto b
*/
public static Vector3 Project(Vector3 a, Vector3 b)
{
return (b * (Dot(a, b) / Dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static Vector3 Reject(Vector3 a, Vector3 b)
{
return (a - b * (Dot(a, b) / Dot(b, b)));
}
public static Vector3 Floor(Vector3 value)
{
return .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
}
//
// Assignment operators
//
// Addition
public void operator +=(Vector3 value) mut
{
X += value.X;
Y += value.Y;
Z += value.Z;
}
public void operator +=(float scalar) mut
{
X += scalar;
Y += scalar;
Z += scalar;
}
// Subtraction
public void operator -=(Vector3 value) mut
{
X -= value.X;
Y -= value.Y;
Z -= value.Z;
}
public void operator -=(float scalar) mut
{
X -= scalar;
Y -= scalar;
Z -= scalar;
}
// Multiplication
public void operator *=(Vector3 value) mut
{
X *= value.X;
Y *= value.Y;
Z *= value.Z;
}
public void operator *=(float scalar) mut
{
X *= scalar;
Y *= scalar;
Z *= scalar;
}
// Division
public void operator /=(Vector3 value) mut
{
X /= value.X;
Y /= value.Y;
Z /= value.Z;
}
public void operator /=(float scalar) mut
{
float inv = 1.0f / scalar;
X *= inv;
Y *= inv;
Z *= inv;
}
//
// operators
//
// 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 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 +(Vector3 value) => value;
// 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 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 -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
// 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 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);
// 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 value, float scalar)
{
float inv = 1.0f / scalar;
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);
// 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 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);
// 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 override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z);
// Todo: move to extension
[Inline]
public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value;
[Inline]
public static implicit operator Self(in DirectX.Math.Vector3 value) => *(Self*)&value;
}
}
using System;
namespace GlitchyEngine.Math
{
//[SwizzleVector(3, "Vector")]
public struct Vector3
{
public const Vector3 Zero = .(0f, 0f, 0f);
public const Vector3 UnitX = .(1f, 0f, 0f);
public const Vector3 UnitY = .(0f, 1f, 0f);
public const Vector3 UnitZ = .(0f, 0f, 1f);
public const Vector3 One = .(1f, 1f, 1f);
public const Vector3 Forward = .(0f, 0f, 1f);
public const Vector3 Backward = .(0f, 0f, -1f);
public const Vector3 Left = .(-1f, 0f, 0f);
public const Vector3 Right = .(1f, 0f, 0f);
public const Vector3 Up = .(0f, 1f, 0f);
public const Vector3 Down = .(0f, -1f, 0f);
public float X, Y, Z;
public this() => this = default;
public this(float value)
{
X = value;
Y = value;
Z = value;
}
public this(Vector2 value, float z)
{
X = value.X;
Y = value.Y;
Z = z;
}
public this(float x, float y, float z)
{
X = x;
Y = y;
Z = z;
}
public ref float this[int index]
{
[Checked]
get
{
if(index < 0 || index > 2)
Internal.ThrowIndexOutOfRange();
#unwarn
return ref (&X)[index];
}
[Inline]
#unwarn
get => ref (&X)[index];
}
/**
* Calculates the magnitude (length) of this vector.
* @remarks MagnitudeSquared might be used if only the relative length is relevant.
*/
public float Magnitude()
{
return Math.Sqrt(X * X + Y * Y + Z * Z);
}
/**
* Calculates the squared magnitude (length) of this vector.
*/
public float MagnitudeSquared()
{
return X * X + Y * Y + Z * Z;
}
/**
* Normalizes this vector.
*/
[Checked]
public void Normalize() mut
{
if(this == .Zero)
return;
this /= Magnitude();
}
/**
* Normalizes this vector.
*/
public void Normalize() mut
{
this /= Magnitude();
}
/**
* Returns a copy of this Vector with a magnitude of 1.
*/
[Checked]
public Vector3 Normalized()
{
if(this == .Zero)
return .Zero;
return this / Magnitude();
}
/**
* Returns a copy of this Vector with a magnitude of 1.
*/
public Vector3 Normalized()
{
return this / Magnitude();
}
public static Vector3 Normalize(Vector3 v)
{
return v / v.Magnitude();
}
public static float Dot(Vector3 l, Vector3 r)
{
return l.X * r.X + l.Y * r.Y + l.Z * r.Z;
}
public static Vector3 Cross(Vector3 l, Vector3 r)
{
return .(l.Y * r.Z - l.Z * r.Y,
l.Z * r.X - l.X * r.Z,
l.X * r.Y - l.Y * r.X);
}
/**
* Calculates the projection of a onto b
*/
public static Vector3 Project(Vector3 a, Vector3 b)
{
return (b * (Dot(a, b) / Dot(b, b)));
}
/**
* Calculates the rejection of a from b
*/
public static Vector3 Reject(Vector3 a, Vector3 b)
{
return (a - b * (Dot(a, b) / Dot(b, b)));
}
public static Vector3 Floor(Vector3 value)
{
return .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
}
//
// Assignment operators
//
// Addition
public void operator +=(Vector3 value) mut
{
X += value.X;
Y += value.Y;
Z += value.Z;
}
public void operator +=(float scalar) mut
{
X += scalar;
Y += scalar;
Z += scalar;
}
// Subtraction
public void operator -=(Vector3 value) mut
{
X -= value.X;
Y -= value.Y;
Z -= value.Z;
}
public void operator -=(float scalar) mut
{
X -= scalar;
Y -= scalar;
Z -= scalar;
}
// Multiplication
public void operator *=(Vector3 value) mut
{
X *= value.X;
Y *= value.Y;
Z *= value.Z;
}
public void operator *=(float scalar) mut
{
X *= scalar;
Y *= scalar;
Z *= scalar;
}
// Division
public void operator /=(Vector3 value) mut
{
X /= value.X;
Y /= value.Y;
Z /= value.Z;
}
public void operator /=(float scalar) mut
{
float inv = 1.0f / scalar;
X *= inv;
Y *= inv;
Z *= inv;
}
//
// operators
//
// 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 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 +(Vector3 value) => value;
// 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 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 -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
// 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 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);
// 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 value, float scalar)
{
float inv = 1.0f / scalar;
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);
// 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 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);
// 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 override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z);
// Todo: move to extension
[Inline]
public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value;
[Inline]
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]
public static implicit operator Self(in DirectX.Math.Vector4 value) => *(Self*)&value;
[Inline]
public static explicit operator Self(float value) => Self(value);
}
}