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-04-09 19:34:44 +02:00
parent 92a3eaa426
commit 838bb7ec2e
3 changed files with 306 additions and 258 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 -258
View File
@@ -1,258 +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;
} }
[Checked] /**
public void Normalize() mut * Normalizes this vector.
{ */
if(this == .Zero) [Checked]
return; public void Normalize() mut
{
this /= Magnitude(); if(this == .Zero)
} return;
public void Normalize() mut this /= Magnitude();
{ }
this /= Magnitude();
} /**
* Normalizes this vector.
public static Vector3 Normalize(Vector3 v) */
{ public void Normalize() mut
return v / v.Magnitude(); {
} this /= Magnitude();
}
public static float Dot(Vector3 l, Vector3 r)
{ /**
return l.X * r.X + l.Y * r.Y + l.Z * r.Z; * Returns a copy of this Vector with a magnitude of 1.
} */
[Checked]
public static Vector3 Cross(Vector3 l, Vector3 r) public Vector3 Normalized()
{ {
return .(l.Y * r.Z - l.Z * r.Y, if(this == .Zero)
l.Z * r.X - l.X * r.Z, return .Zero;
l.X * r.Y - l.Y * r.X);
} return this / Magnitude();
}
/**
* Calculates the projection of a onto b /**
*/ * Returns a copy of this Vector with a magnitude of 1.
public static Vector3 Project(Vector3 a, Vector3 b) */
{ public Vector3 Normalized()
return (b * (Dot(a, b) / Dot(b, b))); {
} return this / Magnitude();
}
/** public static Vector3 Normalize(Vector3 v)
* Calculates the rejection of a from b {
*/ return v / v.Magnitude();
public static Vector3 Reject(Vector3 a, Vector3 b) }
{
return (a - b * (Dot(a, b) / Dot(b, b))); public static float Dot(Vector3 l, Vector3 r)
} {
return l.X * r.X + l.Y * r.Y + l.Z * r.Z;
// }
// Assignment operators
// public static Vector3 Cross(Vector3 l, Vector3 r)
{
// Addition return .(l.Y * r.Z - l.Z * r.Y,
l.Z * r.X - l.X * r.Z,
public void operator +=(Vector3 value) mut l.X * r.Y - l.Y * r.X);
{ }
X += value.X;
Y += value.Y; /**
Z += value.Z; * Calculates the projection of a onto b
} */
public static Vector3 Project(Vector3 a, Vector3 b)
public void operator +=(float scalar) mut {
{ return (b * (Dot(a, b) / Dot(b, b)));
X += scalar; }
Y += scalar;
Z += scalar;
} /**
* Calculates the rejection of a from b
// Subtraction */
public static Vector3 Reject(Vector3 a, Vector3 b)
{
public void operator -=(Vector3 value) mut return (a - b * (Dot(a, b) / Dot(b, b)));
{ }
X -= value.X;
Y -= value.Y; public static Vector3 Floor(Vector3 value)
Z -= value.Z; {
} return .(Math.Floor(value.X), Math.Floor(value.Y), Math.Floor(value.Z));
}
public void operator -=(float scalar) mut
{ //
X -= scalar; // Assignment operators
Y -= scalar; //
Z -= scalar;
} // Addition
// Multiplication public void operator +=(Vector3 value) mut
{
public void operator *=(Vector3 value) mut X += value.X;
{ Y += value.Y;
X *= value.X; Z += value.Z;
Y *= value.Y; }
Z *= value.Z;
} public void operator +=(float scalar) mut
{
public void operator *=(float scalar) mut X += scalar;
{ Y += scalar;
X *= scalar; Z += scalar;
Y *= scalar; }
Z *= scalar;
} // Subtraction
// 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 {
{ X -= scalar;
float inv = 1.0f / scalar; Y -= scalar;
X *= inv; Z -= scalar;
Y *= inv; }
Z *= inv;
} // Multiplication
// public void operator *=(Vector3 value) mut
// operators {
// X *= value.X;
Y *= value.Y;
// Addition Z *= value.Z;
}
public static Vector3 operator +(Vector3 left, Vector3 right) => Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
public void operator *=(float scalar) mut
public static Vector3 operator +(Vector3 value, float scalar) => Vector3(value.X + scalar, value.Y + scalar, value.Z + scalar); {
X *= scalar;
public static Vector3 operator +(float scalar, Vector3 value) => Vector3(scalar + value.X, scalar + value.Y, scalar + value.Z); Y *= scalar;
Z *= scalar;
public static Vector3 operator +(Vector3 value) => value; }
// Subtraction // Division
public static Vector3 operator -(Vector3 left, Vector3 right) => Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z); public void operator /=(Vector3 value) mut
{
public static Vector3 operator -(Vector3 value, float scalar) => Vector3(value.X - scalar, value.Y - scalar, value.Z - scalar); X /= value.X;
Y /= value.Y;
public static Vector3 operator -(float scalar, Vector3 value) => Vector3(scalar - value.X, scalar - value.Y, scalar - value.Z); Z /= value.Z;
}
public static Vector3 operator -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
public void operator /=(float scalar) mut
// Multiplication {
float inv = 1.0f / scalar;
public static Vector3 operator *(Vector3 left, Vector3 right) => Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z); X *= inv;
Y *= inv;
public static Vector3 operator *(Vector3 value, float scalar) => Vector3(value.X * scalar, value.Y * scalar, value.Z * scalar); Z *= inv;
}
public static Vector3 operator *(float scalar, Vector3 value) => Vector3(scalar * value.X, scalar * value.Y, scalar * value.Z);
//
// Division // operators
//
public static Vector3 operator /(Vector3 left, Vector3 right) => Vector3(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
// Addition
public static Vector3 operator /(Vector3 value, float scalar)
{ public static Vector3 operator +(Vector3 left, Vector3 right) => Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
float inv = 1.0f / scalar;
return Vector3(value.X * inv, value.Y * inv, value.Z * inv); 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;
// Equality
// Subtraction
public static bool operator ==(Vector3 left, Vector3 right) => 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 bool operator !=(Vector3 left, Vector3 right) => 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 override void ToString(String strBuffer) => strBuffer.AppendF("X:{0} Y:{1} Z:{2}", X, Y, Z);
public static Vector3 operator -(float scalar, Vector3 value) => Vector3(scalar - value.X, scalar - value.Y, scalar - value.Z);
// Todo: move to extension
public static Vector3 operator -(Vector3 value) => Vector3(-value.X, -value.Y, -value.Z);
[Inline]
public static implicit operator DirectX.Math.Vector3(in Self value) => *(DirectX.Math.Vector3*)&value; // Multiplication
[Inline] public static Vector3 operator *(Vector3 left, Vector3 right) => Vector3(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
public static implicit operator Self(in DirectX.Math.Vector3 value) => *(Self*)&value;
} 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] [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);
} }
} }