1009 lines
48 KiB
C#
1009 lines
48 KiB
C#
using Nerd_STF.Mathematics.Interfaces;
|
|
using System;
|
|
|
|
namespace Nerd_STF.Mathematics
|
|
{
|
|
[Serializable]
|
|
public struct Angle : IMathFunctions<Angle>, INegatives<Angle>
|
|
{
|
|
public float value;
|
|
|
|
public Angle Clamped
|
|
{
|
|
get
|
|
{
|
|
Angle returned = this;
|
|
while (returned.value >= 360) returned.value -= 360;
|
|
while (returned.value < 0) returned.value += 360;
|
|
return returned;
|
|
}
|
|
}
|
|
public Angle Absolute
|
|
{
|
|
get
|
|
{
|
|
Angle returned = new(value);
|
|
if (value < 0) returned *= -1;
|
|
return returned;
|
|
}
|
|
}
|
|
public bool IsAcute => Clamped.value > 0 && Clamped.value < 90;
|
|
public bool IsClamped => value < 360 && value >= 0;
|
|
public bool IsNegative => value < 0;
|
|
public bool IsObtuse => Clamped.value > 90 && Clamped.value < 180;
|
|
public bool IsReflex => Clamped.value > 180 && Clamped.value < 360;
|
|
public bool IsRight => Clamped.value == 90;
|
|
public bool IsStraight => Clamped.value == 180;
|
|
public bool IsZero => Clamped.value == 0;
|
|
public Angle Negative
|
|
{
|
|
get
|
|
{
|
|
Angle returned = new(value);
|
|
if (value > 0) returned *= -1;
|
|
return returned;
|
|
}
|
|
}
|
|
public Angle Positive => Absolute;
|
|
public AngleType Type
|
|
{
|
|
get
|
|
{
|
|
if (IsAcute) return AngleType.Acute;
|
|
else if (IsObtuse) return AngleType.Obtuse;
|
|
else if (IsReflex) return AngleType.Reflex;
|
|
else if (IsRight) return AngleType.Right;
|
|
else if (IsStraight) return AngleType.Straight;
|
|
else if (IsZero) return AngleType.Zero;
|
|
else throw new ArithmeticException();
|
|
}
|
|
}
|
|
|
|
public Angle(float degree) => value = degree;
|
|
|
|
public static Angle Acute => new(45);
|
|
public static Angle Obtuse => new(135);
|
|
public static Angle Reflex => new(270);
|
|
public static Angle Right => new(90);
|
|
public static Angle Straight => new(180);
|
|
public static Angle Zero => new(0);
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Angle other) => value == other.value;
|
|
public bool Equals(float other) => value == other;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => value.ToString() + "°";
|
|
public string ToString(string format) => value.ToString(format) + "°";
|
|
|
|
public Angle Average(params Angle[] objs)
|
|
{
|
|
float[] average = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++) average[i] = objs[i].value;
|
|
average[objs.Length] = value;
|
|
return new(Math.Average(average));
|
|
}
|
|
public Angle Max(params Angle[] objs)
|
|
{
|
|
float[] max = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++) max[i] = objs[i].value;
|
|
max[objs.Length] = value;
|
|
return new(Math.Max(max));
|
|
}
|
|
public Angle Min(params Angle[] objs)
|
|
{
|
|
float[] min = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++) min[i] = objs[i].value;
|
|
min[objs.Length] = value;
|
|
return new(Math.Min(min));
|
|
}
|
|
|
|
public static Angle operator +(Angle a, Angle b) => new(a.value + b.value);
|
|
public static Angle operator +(Angle a, float b) => new(a.value + b);
|
|
public static Angle operator +(float a, Angle b) => new(a + b.value);
|
|
public static Angle operator -(Angle a, Angle b) => new(a.value - b.value);
|
|
public static Angle operator -(Angle a, float b) => new(a.value - b);
|
|
public static Angle operator -(float a, Angle b) => new(a - b.value);
|
|
public static Angle operator *(Angle a, Angle b) => new(a.value * b.value);
|
|
public static Angle operator *(Angle a, float b) => new(a.value * b);
|
|
public static Angle operator *(float a, Angle b) => new(a * b.value);
|
|
public static Angle operator /(Angle a, Angle b) => new(a.value / b.value);
|
|
public static Angle operator /(Angle a, float b) => new(a.value / b);
|
|
public static Angle operator /(float a, Angle b) => new(a / b.value);
|
|
public static bool operator ==(Angle a, Angle b) => a.Equals(b);
|
|
public static bool operator ==(Angle a, float b) => a.Equals(b);
|
|
public static bool operator ==(float a, Angle b) => b.Equals(a);
|
|
public static bool operator !=(Angle a, Angle b) => !a.Equals(b);
|
|
public static bool operator !=(Angle a, float b) => !a.Equals(b);
|
|
public static bool operator !=(float a, Angle b) => !b.Equals(a);
|
|
public static bool operator >(Angle a, Angle b) => a.value > b.value;
|
|
public static bool operator >(Angle a, float b) => a.value > b;
|
|
public static bool operator >(float a, Angle b) => a > b.value;
|
|
public static bool operator <(Angle a, Angle b) => a.value < b.value;
|
|
public static bool operator <(Angle a, float b) => a.value < b;
|
|
public static bool operator <(float a, Angle b) => a < b.value;
|
|
public static bool operator >=(Angle a, Angle b) => a.value > b.value || a.Equals(b);
|
|
public static bool operator >=(Angle a, float b) => a.value > b || a.Equals(b);
|
|
public static bool operator >=(float a, Angle b) => a > b.value || b.Equals(a);
|
|
public static bool operator <=(Angle a, Angle b) => a.value < b.value || a.Equals(b);
|
|
public static bool operator <=(Angle a, float b) => a.value < b || a.Equals(b);
|
|
public static bool operator <=(float a, Angle b) => a < b.value || b.Equals(a);
|
|
|
|
public static explicit operator float(Angle input) => input.value;
|
|
public static explicit operator Angle(float input) => new(input);
|
|
|
|
public enum AngleType
|
|
{
|
|
Acute,
|
|
Obtuse,
|
|
Reflex,
|
|
Right,
|
|
Straight,
|
|
Zero,
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public struct Color : IMathFunctions<Color>
|
|
{
|
|
public float r, g, b, a;
|
|
|
|
public bool IsBlue => b != 0;
|
|
public bool IsClear => a == 0;
|
|
public bool IsGreen => g != 0;
|
|
public bool IsRed => a != 0;
|
|
public bool IsTransparent => a > 0 && a < 1;
|
|
public bool IsBroken
|
|
{
|
|
get
|
|
{
|
|
bool returned = false;
|
|
returned |= r < 0 || r > 1;
|
|
returned |= g < 0 || g > 1;
|
|
returned |= b < 0 || b > 1;
|
|
returned |= a < 0 || a > 1;
|
|
return returned;
|
|
}
|
|
}
|
|
|
|
public static Color Black => new(0, 0, 0);
|
|
public static Color Blue => new(0, 0, 1);
|
|
public static Color Clear => new(0, 0, 0, 0);
|
|
public static Color Cyan => new(0, 1, 1);
|
|
public static Color Gray => new(0.5f, 0.5f, 0.5f);
|
|
public static Color Green => new(0, 1, 0);
|
|
public static Color Magenta => new(1, 0, 1);
|
|
public static Color Orange => new(1, 0.5f, 0);
|
|
public static Color Purple => new(0.5f, 0, 1);
|
|
public static Color Red => new(1, 0, 0);
|
|
public static Color White => new(1, 1, 1);
|
|
public static Color Yellow => new(1, 1, 0);
|
|
|
|
public Color(float r, float g, float b)
|
|
{
|
|
this = new(r, g, b, 1);
|
|
}
|
|
public Color(float r, float g, float b, float a)
|
|
{
|
|
r = Math.Clamp(r, 0, 1);
|
|
g = Math.Clamp(g, 0, 1);
|
|
b = Math.Clamp(b, 0, 1);
|
|
a = Math.Clamp(a, 0, 1);
|
|
|
|
this.r = r;
|
|
this.g = g;
|
|
this.b = b;
|
|
this.a = a;
|
|
}
|
|
|
|
public void Check()
|
|
{
|
|
r = Math.Clamp(r, 0, 1);
|
|
g = Math.Clamp(g, 0, 1);
|
|
b = Math.Clamp(b, 0, 1);
|
|
a = Math.Clamp(a, 0, 1);
|
|
}
|
|
|
|
public Color Average(params Color[] objs)
|
|
{
|
|
float[] averageR = new float[objs.Length + 1];
|
|
float[] averageG = new float[objs.Length + 1];
|
|
float[] averageB = new float[objs.Length + 1];
|
|
float[] averageA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageR[i] = objs[i].r;
|
|
averageG[i] = objs[i].g;
|
|
averageB[i] = objs[i].b;
|
|
averageA[i] = objs[i].a;
|
|
}
|
|
averageR[objs.Length] = r;
|
|
averageG[objs.Length] = g;
|
|
averageB[objs.Length] = b;
|
|
averageA[objs.Length] = a;
|
|
return new(Math.Average(averageR), Math.Average(averageG), Math.Average(averageB), Math.Average(averageA));
|
|
}
|
|
public Color Max(params Color[] objs)
|
|
{
|
|
float[] maxR = new float[objs.Length + 1];
|
|
float[] maxG = new float[objs.Length + 1];
|
|
float[] maxB = new float[objs.Length + 1];
|
|
float[] maxA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxR[i] = objs[i].r;
|
|
maxG[i] = objs[i].g;
|
|
maxB[i] = objs[i].b;
|
|
maxA[i] = objs[i].a;
|
|
}
|
|
maxR[objs.Length] = r;
|
|
maxG[objs.Length] = g;
|
|
maxB[objs.Length] = b;
|
|
maxA[objs.Length] = a;
|
|
return new(Math.Max(maxR), Math.Max(maxG), Math.Max(maxB), Math.Max(maxA));
|
|
}
|
|
public Color Min(params Color[] objs)
|
|
{
|
|
float[] minR = new float[objs.Length + 1];
|
|
float[] minG = new float[objs.Length + 1];
|
|
float[] minB = new float[objs.Length + 1];
|
|
float[] minA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minR[i] = objs[i].r;
|
|
minG[i] = objs[i].g;
|
|
minB[i] = objs[i].b;
|
|
minA[i] = objs[i].a;
|
|
}
|
|
minR[objs.Length] = r;
|
|
minG[objs.Length] = g;
|
|
minB[objs.Length] = b;
|
|
minA[objs.Length] = a;
|
|
return new(Math.Min(minR), Math.Min(minG), Math.Min(minB), Math.Min(minA));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Color other) => r == other.r && g == other.g && b == other.b && a == other.a;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString();
|
|
public string ToString(string format) => "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format);
|
|
|
|
public static Color operator +(Color a, Color b) => new(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a);
|
|
public static Color operator +(Color a, float b) => new(a.r + b, a.g + b, a.b + b, a.a + b);
|
|
public static Color operator +(float a, Color b) => new(a + b.r, a + b.g, a + b.b, a + b.a);
|
|
public static Color operator -(Color a, Color b) => new(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a);
|
|
public static Color operator -(Color a, float b) => new(a.r - b, a.g - b, a.b - b, a.a - b);
|
|
public static Color operator -(float a, Color b) => new(a - b.r, a - b.g, a - b.b, a - b.a);
|
|
public static Color operator *(Color a, Color b) => new(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a);
|
|
public static Color operator *(Color a, float b) => new(a.r * b, a.g * b, a.b * b, a.a * b);
|
|
public static Color operator *(float a, Color b) => new(a * b.r, a * b.g, a * b.b, a * b.a);
|
|
public static Color operator /(Color a, Color b) => new(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a);
|
|
public static Color operator /(Color a, float b) => new(a.r / b, a.g / b, a.b / b, a.a / b);
|
|
public static Color operator /(float a, Color b) => new(a / b.r, a / b.g, a / b.b, a / b.a);
|
|
public static bool operator ==(Color a, Color b) => a.Equals(b);
|
|
public static bool operator !=(Color a, Color b) => !a.Equals(b);
|
|
|
|
public static implicit operator Color(ColorByte input) => new(input.r / 255, input.g / 255, input.b / 255, input.a / 255);
|
|
public static explicit operator Color(Vector3 input) => new(input.x, input.y, input.z, 1);
|
|
public static explicit operator Color(Vector4 input) => new(input.x, input.y, input.z, input.w);
|
|
}
|
|
[Serializable]
|
|
public struct ColorByte : IMathFunctions<ColorByte>
|
|
{
|
|
public byte r, g, b, a;
|
|
|
|
public bool IsBlue => b != byte.MinValue;
|
|
public bool IsClear => a == byte.MinValue;
|
|
public bool IsGreen => g != byte.MinValue;
|
|
public bool IsRed => a != byte.MinValue;
|
|
public bool IsTransparent => a > byte.MinValue && a < byte.MaxValue;
|
|
|
|
public static ColorByte Black => new(0, 0, 0);
|
|
public static ColorByte Blue => new(0, 0, 255);
|
|
public static ColorByte Clear => new(0, 0, 0, 0);
|
|
public static ColorByte Cyan => new(0, 255, 255);
|
|
public static ColorByte Gray => new(128, 128, 128);
|
|
public static ColorByte Green => new(0, 255, 0);
|
|
public static ColorByte Magenta => new(255, 0, 255);
|
|
public static ColorByte Orange => new(1, 128, 0);
|
|
public static ColorByte Purple => new(128, 0, 1);
|
|
public static ColorByte Red => new(255, 0, 0);
|
|
public static ColorByte White => new(255, 255, 255);
|
|
public static ColorByte Yellow => new(255, 255, 0);
|
|
|
|
public ColorByte(byte r, byte g, byte b) => this = new(r, g, b, byte.MaxValue);
|
|
public ColorByte(byte r, byte g, byte b, byte a)
|
|
{
|
|
this.r = r;
|
|
this.g = g;
|
|
this.b = b;
|
|
this.a = a;
|
|
}
|
|
public ColorByte(int r, int g, int b) => this = new(r, g, b, byte.MaxValue);
|
|
public ColorByte(int r, int g, int b, int a)
|
|
{
|
|
this.r = (byte)r;
|
|
this.g = (byte)g;
|
|
this.b = (byte)b;
|
|
this.a = (byte)a;
|
|
}
|
|
|
|
public ColorByte Average(params ColorByte[] objs)
|
|
{
|
|
float[] averageR = new float[objs.Length + 1];
|
|
float[] averageG = new float[objs.Length + 1];
|
|
float[] averageB = new float[objs.Length + 1];
|
|
float[] averageA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageR[i] = objs[i].r;
|
|
averageG[i] = objs[i].g;
|
|
averageB[i] = objs[i].b;
|
|
averageA[i] = objs[i].a;
|
|
}
|
|
averageR[objs.Length] = r;
|
|
averageG[objs.Length] = g;
|
|
averageB[objs.Length] = b;
|
|
averageA[objs.Length] = a;
|
|
return new(Math.RoundToInt(Math.Average(averageR)), Math.RoundToInt(Math.Average(averageG)), Math.RoundToInt(Math.Average(averageB)), Math.RoundToInt(Math.Average(averageA)));
|
|
}
|
|
public ColorByte Max(params ColorByte[] objs)
|
|
{
|
|
float[] maxR = new float[objs.Length + 1];
|
|
float[] maxG = new float[objs.Length + 1];
|
|
float[] maxB = new float[objs.Length + 1];
|
|
float[] maxA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxR[i] = objs[i].r;
|
|
maxG[i] = objs[i].g;
|
|
maxB[i] = objs[i].b;
|
|
maxA[i] = objs[i].a;
|
|
}
|
|
maxR[objs.Length] = r;
|
|
maxG[objs.Length] = g;
|
|
maxB[objs.Length] = b;
|
|
maxA[objs.Length] = a;
|
|
return new(Math.RoundToInt(Math.Max(maxR)), Math.RoundToInt(Math.Max(maxG)), Math.RoundToInt(Math.Max(maxB)), Math.RoundToInt(Math.Max(maxA)));
|
|
}
|
|
public ColorByte Min(params ColorByte[] objs)
|
|
{
|
|
float[] minR = new float[objs.Length + 1];
|
|
float[] minG = new float[objs.Length + 1];
|
|
float[] minB = new float[objs.Length + 1];
|
|
float[] minA = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minR[i] = objs[i].r;
|
|
minG[i] = objs[i].g;
|
|
minB[i] = objs[i].b;
|
|
minA[i] = objs[i].a;
|
|
}
|
|
minR[objs.Length] = r;
|
|
minG[objs.Length] = g;
|
|
minB[objs.Length] = b;
|
|
minA[objs.Length] = a;
|
|
return new(Math.RoundToInt(Math.Min(minR)), Math.RoundToInt(Math.Min(minG)), Math.RoundToInt(Math.Min(minB)), Math.RoundToInt(Math.Min(minA)));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(ColorByte other) => r == other.r && g == other.g && b == other.b && a == other.a;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "R: " + r.ToString() + " | G: " + g.ToString() + " | B: " + b.ToString() + " | A: " + a.ToString();
|
|
public string ToString(string format) => "R: " + r.ToString(format) + " | G: " + g.ToString(format) + " | B: " + b.ToString(format) + " | A: " + a.ToString(format);
|
|
|
|
public static ColorByte operator +(ColorByte a, ColorByte b) => new(a.r + b.r, a.g + b.g, a.b + b.b, a.a + b.a);
|
|
public static ColorByte operator +(ColorByte a, byte b) => new(a.r + b, a.g + b, a.b + b, a.a + b);
|
|
public static ColorByte operator +(byte a, ColorByte b) => new(a + b.r, a + b.g, a + b.b, a + b.a);
|
|
public static ColorByte operator -(ColorByte a, ColorByte b) => new(a.r - b.r, a.g - b.g, a.b - b.b, a.a - b.a);
|
|
public static ColorByte operator -(ColorByte a, byte b) => new(a.r - b, a.g - b, a.b - b, a.a - b);
|
|
public static ColorByte operator -(byte a, ColorByte b) => new(a - b.r, a - b.g, a - b.b, a - b.a);
|
|
public static ColorByte operator *(ColorByte a, ColorByte b) => new(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a);
|
|
public static ColorByte operator *(ColorByte a, byte b) => new(a.r * b, a.g * b, a.b * b, a.a * b);
|
|
public static ColorByte operator *(byte a, ColorByte b) => new(a * b.r, a * b.g, a * b.b, a * b.a);
|
|
public static ColorByte operator /(ColorByte a, ColorByte b) => new(a.r / b.r, a.g / b.g, a.b / b.b, a.a / b.a);
|
|
public static ColorByte operator /(ColorByte a, byte b) => new(a.r / b, a.g / b, a.b / b, a.a / b);
|
|
public static ColorByte operator /(byte a, ColorByte b) => new(a / b.r, a / b.g, a / b.b, a / b.a);
|
|
public static bool operator ==(ColorByte a, ColorByte b) => a.Equals(b);
|
|
public static bool operator !=(ColorByte a, ColorByte b) => !a.Equals(b);
|
|
|
|
public static explicit operator ColorByte(Color input) => new((byte)(input.r * 255), (byte)(input.g * 255), (byte)(input.b * 255), (byte)(input.a * 255));
|
|
}
|
|
|
|
public static class Math
|
|
{
|
|
public const float E = 2.7182818284590451f;
|
|
public const float Pi = 3.1415926535897931f;
|
|
public const float Tau = 6.2831853071795862f;
|
|
|
|
public static float Absolute(float input)
|
|
{
|
|
if (input < 0) input *= -1;
|
|
return input;
|
|
}
|
|
|
|
public static float Add(params float[] input)
|
|
{
|
|
float returned = 0;
|
|
foreach (float f in input) returned += f;
|
|
return returned;
|
|
}
|
|
|
|
public static float Average(params float[] input)
|
|
{
|
|
float returned = 0;
|
|
foreach (float f in input) returned += f;
|
|
returned /= input.Length;
|
|
return returned;
|
|
}
|
|
|
|
public static float Clamp(float input, float min, float max)
|
|
{
|
|
if (min > max) throw new ArgumentException("Minimun cannot be greater than maximum.");
|
|
|
|
if (input > max) input = max;
|
|
else if (input < min) input = min;
|
|
|
|
return input;
|
|
}
|
|
|
|
public static int Clamp(float input, int min, int max)
|
|
{
|
|
if (min > max) throw new ArgumentException("Minimun cannot be greater than maximum.");
|
|
|
|
if (input > max) input = max;
|
|
else if (input < min) input = min;
|
|
|
|
return (int)input;
|
|
}
|
|
|
|
public static float Divide(params float[] input)
|
|
{
|
|
float returned = input[0];
|
|
for (uint i = 1; i < input.Length; i++) returned /= input[i];
|
|
return returned;
|
|
}
|
|
|
|
public static float Max(params float[] input)
|
|
{
|
|
float returned = input[0];
|
|
for (uint i = 0; i < input.Length; i++) if (input[i] > returned) returned = input[i];
|
|
return returned;
|
|
}
|
|
|
|
public static float Min(params float[] input)
|
|
{
|
|
float returned = input[0];
|
|
for (uint i = 0; i < input.Length; i++) if (input[i] < returned) returned = input[0];
|
|
return returned;
|
|
}
|
|
|
|
public static float Multiply(params float[] input)
|
|
{
|
|
float returned = 1;
|
|
foreach (float f in input) returned *= f;
|
|
return returned;
|
|
}
|
|
|
|
public static float Power(float input, int power)
|
|
{
|
|
float returned = 1;
|
|
for (uint i = 0; i < Absolute(power); i++) returned *= input;
|
|
if (power < 0) returned = 1 / returned;
|
|
return returned;
|
|
}
|
|
|
|
public static float Round(float value)
|
|
{
|
|
if (value % 1 >= 0.5f) value += 1 - (value % 1);
|
|
else value -= value % 1;
|
|
|
|
return value;
|
|
}
|
|
public static float Round(float value, float dividend) => Round(value / dividend) * dividend;
|
|
public static int RoundToInt(float value) => (int)Round(value);
|
|
|
|
public static float Subtract(params float[] input)
|
|
{
|
|
float returned = input[0];
|
|
for (uint i = 1; i < input.Length; i++) returned -= input[i];
|
|
return returned;
|
|
}
|
|
|
|
public static class Formulas
|
|
{
|
|
public static float CircleArea(float radius) => Pi * radius * radius;
|
|
public static float CircleCircum(float radius) => 2 * radius * Pi;
|
|
public static float CircleDiam(float radius) => radius * 2;
|
|
public static float CircleRadius(float circumference) => circumference / Pi / 2;
|
|
|
|
public static float Perimeter(params float[] sideLengths) => Add(sideLengths);
|
|
|
|
public static float RectangleArea(float length, float width) => length * width;
|
|
|
|
public static float SquareArea(float length) => RectangleArea(length, length);
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public struct Percent : IMathFunctions<Percent>, INegatives<Percent>
|
|
{
|
|
public float value;
|
|
|
|
public Percent Absolute
|
|
{
|
|
get
|
|
{
|
|
Percent returned = new(value);
|
|
if (returned < 0) returned *= -1;
|
|
return returned;
|
|
}
|
|
}
|
|
public bool IsFull { get => value == 100; }
|
|
public bool IsNegative { get => value < 0; }
|
|
public bool IsOverflow { get => value > 100; }
|
|
public bool IsZero { get => value == 0; }
|
|
public Percent Negative
|
|
{
|
|
get
|
|
{
|
|
Percent returned = new(value);
|
|
if (returned > 0) returned *= -1;
|
|
return returned;
|
|
}
|
|
}
|
|
public Percent Positive { get => Absolute; }
|
|
|
|
public static Percent Full { get => new(100); }
|
|
public static Percent One { get => new(1); }
|
|
public static Percent Zero { get => new(0); }
|
|
|
|
public Percent(float value) => this = new(value, 0, 100);
|
|
public Percent(float value, float maxValue) => this = new(value, 0, maxValue);
|
|
public Percent(float value, float minValue, float maxValue) => this.value = value / (maxValue - minValue);
|
|
|
|
public Percent Average(params Percent[] objs)
|
|
{
|
|
float[] average = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++) average[i] = objs[i].value;
|
|
average[objs.Length] = value;
|
|
return new(Math.Average(average));
|
|
}
|
|
public Percent Max(params Percent[] objs)
|
|
{
|
|
float[] max = new float[objs.Length];
|
|
for (int i = 0; i < objs.Length; i++) max[i] = objs[i].value;
|
|
max[objs.Length] = value;
|
|
return new(Math.Max(max));
|
|
}
|
|
public Percent Min(params Percent[] objs)
|
|
{
|
|
float[] min = new float[objs.Length];
|
|
for (int i = 0; i < objs.Length; i++) min[i] = objs[i].value;
|
|
min[objs.Length] = value;
|
|
return new(Math.Min(min));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(float other) => value == other || value == (other / 100);
|
|
public bool Equals(Percent other) => value == other.value;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => value.ToString() + "%";
|
|
public string ToString(string format) => value.ToString(format) + "%";
|
|
|
|
public static Percent operator +(Percent a, Percent b) => new() { value = a.value + b.value };
|
|
public static Percent operator +(Percent a, float b) => new() { value = a.value + (b / 100) };
|
|
public static Percent operator +(float a, Percent b) => new() { value = (a / 100) + b.value };
|
|
public static Percent operator -(Percent a, Percent b) => new() { value = a.value - b.value };
|
|
public static Percent operator -(Percent a, float b) => new() { value = a.value - (b / 100) };
|
|
public static Percent operator -(float a, Percent b) => new() { value = (a / 100) + b.value };
|
|
public static Percent operator *(Percent a, Percent b) => new() { value = a.value * b.value };
|
|
public static Percent operator *(Percent a, float b) => new() { value = a.value * (b / 100) };
|
|
public static Percent operator *(float a, Percent b) => new() { value = (a / 100) + b.value };
|
|
public static Percent operator /(Percent a, Percent b) => new() { value = a.value / b.value };
|
|
public static Percent operator /(Percent a, float b) => new() { value = a.value / b / 100 };
|
|
public static Percent operator /(float a, Percent b) => new() { value = (a / 100) + b.value };
|
|
public static bool operator ==(Percent a, Percent b) => a.Equals(b);
|
|
public static bool operator ==(Percent a, float b) => a.Equals(b);
|
|
public static bool operator ==(float a, Percent b) => b.Equals(a);
|
|
public static bool operator !=(Percent a, Percent b) => !a.Equals(b);
|
|
public static bool operator !=(Percent a, float b) => !a.Equals(b);
|
|
public static bool operator !=(float a, Percent b) => !b.Equals(a);
|
|
public static bool operator >(Percent a, Percent b) => a.value > b.value;
|
|
public static bool operator >(Percent a, float b) => a.value > b;
|
|
public static bool operator >(float a, Percent b) => a > b.value;
|
|
public static bool operator <(Percent a, Percent b) => a.value < b.value;
|
|
public static bool operator <(Percent a, float b) => a.value < b;
|
|
public static bool operator <(float a, Percent b) => a < b.value;
|
|
public static bool operator >=(Percent a, Percent b) => a.value > b.value || a.Equals(b);
|
|
public static bool operator >=(Percent a, float b) => a.value > b || a.Equals(b);
|
|
public static bool operator >=(float a, Percent b) => a > b.value || b.Equals(a);
|
|
public static bool operator <=(Percent a, Percent b) => a.value < b.value || a.Equals(b);
|
|
public static bool operator <=(Percent a, float b) => a.value < b || a.Equals(b);
|
|
public static bool operator <=(float a, Percent b) => a < b.value || b.Equals(a);
|
|
|
|
public static explicit operator float(Percent input) => input.value;
|
|
public static explicit operator Percent(float input) => new(input);
|
|
}
|
|
|
|
[Serializable]
|
|
public struct Vector : IMathFunctions<Vector>
|
|
{
|
|
public Angle direction;
|
|
public float strength;
|
|
|
|
public Vector Inverse { get => new(direction.value - 180, -strength); }
|
|
public Vector Reflected { get => new(360 - direction, strength); }
|
|
|
|
public static Vector Zero { get => new(0, 0); }
|
|
|
|
public Vector(Angle direction, float strength, bool clampDir = true)
|
|
{
|
|
if (clampDir) direction = direction.Clamped;
|
|
this.direction = direction;
|
|
this.strength = strength;
|
|
}
|
|
public Vector(float direction, float strength, bool clampDir = true) => this = new Vector(new Angle(direction), strength, clampDir);
|
|
|
|
public Vector Average(params Vector[] objs)
|
|
{
|
|
float[] averageD = new float[objs.Length + 1];
|
|
float[] averageS = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageD[i] = objs[i].direction.Clamped.value;
|
|
averageS[i] = objs[i].strength;
|
|
}
|
|
averageD[objs.Length] = direction.Clamped.value;
|
|
averageS[objs.Length] = strength;
|
|
return new(Math.Average(averageD), Math.Average(averageS));
|
|
}
|
|
public Vector Max(params Vector[] objs)
|
|
{
|
|
float[] maxD = new float[objs.Length + 1];
|
|
float[] maxS = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxD[i] = objs[i].direction.Clamped.value;
|
|
maxS[i] = objs[i].strength;
|
|
}
|
|
maxD[objs.Length] = direction.Clamped.value;
|
|
maxS[objs.Length] = strength;
|
|
return new(Math.Max(maxD), Math.Max(maxS));
|
|
}
|
|
public Vector Min(params Vector[] objs)
|
|
{
|
|
float[] minD = new float[objs.Length + 1];
|
|
float[] minS = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minD[i] = objs[i].direction.Clamped.value;
|
|
minS[i] = objs[i].strength;
|
|
}
|
|
minD[objs.Length] = direction.Clamped.value;
|
|
minS[objs.Length] = strength;
|
|
return new(Math.Min(minD), Math.Min(minS));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Vector other) => direction == other.direction && strength == other.strength;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "D: " + direction.ToString() + " | S: " + strength.ToString();
|
|
public string ToString(string format) => "D: " + direction.ToString(format) + " | S: " + strength.ToString(format);
|
|
|
|
public static Vector operator +(Vector a, Vector b) => new(a.direction + b.direction, a.strength + b.strength, false);
|
|
public static Vector operator -(Vector a, Vector b) => new(a.direction - b.direction, a.strength - b.strength, false);
|
|
public static Vector operator *(Vector a, Vector b) => new(a.direction * b.direction, a.strength * b.strength, false);
|
|
public static Vector operator /(Vector a, Vector b) => new(a.direction / b.direction, a.strength / b.strength, false);
|
|
public static bool operator ==(Vector a, Vector b) => a.Equals(b);
|
|
public static bool operator !=(Vector a, Vector b) => !a.Equals(b);
|
|
}
|
|
|
|
[Serializable]
|
|
public struct Vector2 : IMathFunctions<Vector2>
|
|
{
|
|
public float x, y;
|
|
|
|
public static Vector2 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity); }
|
|
public static Vector2 One { get => new(1, 1); }
|
|
public static Vector2 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity); }
|
|
public static Vector2 Zero { get => new(0, 0); }
|
|
|
|
public Vector2(float x) => this = new Vector2(x, 0);
|
|
public Vector2(float x, float y)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
|
|
public Vector2 Average(params Vector2[] objs)
|
|
{
|
|
float[] averageX = new float[objs.Length + 1];
|
|
float[] averageY = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageX[i] = objs[i].x;
|
|
averageY[i] = objs[i].y;
|
|
}
|
|
averageX[objs.Length] = x;
|
|
averageY[objs.Length] = y;
|
|
return new(Math.Average(averageX), Math.Average(averageY));
|
|
}
|
|
public Vector2 Max(params Vector2[] objs)
|
|
{
|
|
float[] maxX = new float[objs.Length + 1];
|
|
float[] maxY = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxX[i] = objs[i].x;
|
|
maxY[i] = objs[i].y;
|
|
}
|
|
maxX[objs.Length] = x;
|
|
maxY[objs.Length] = y;
|
|
return new(Math.Max(maxX), Math.Max(maxY));
|
|
}
|
|
public Vector2 Min(params Vector2[] objs)
|
|
{
|
|
float[] minX = new float[objs.Length + 1];
|
|
float[] minY = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minX[i] = objs[i].x;
|
|
minY[i] = objs[i].y;
|
|
}
|
|
minX[objs.Length] = x;
|
|
minY[objs.Length] = y;
|
|
return new(Math.Min(minX), Math.Min(minY));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Vector2 other) => x == other.x && y == other.y;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString();
|
|
public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format);
|
|
|
|
public static Vector2 operator +(Vector2 a, Vector2 b) => new(a.x + b.x, a.y + b.y);
|
|
public static Vector2 operator +(Vector2 a, float b) => new(a.x + b, a.y + b);
|
|
public static Vector2 operator +(float a, Vector2 b) => new(a + b.x, a + b.y);
|
|
public static Vector2 operator -(Vector2 a, Vector2 b) => new(a.x - b.x, a.y - b.y);
|
|
public static Vector2 operator -(Vector2 a, float b) => new(a.x - b, a.y - b);
|
|
public static Vector2 operator -(float a, Vector2 b) => new(a - b.x, a - b.y);
|
|
public static Vector2 operator *(Vector2 a, Vector2 b) => new(a.x * b.x, a.y * b.y);
|
|
public static Vector2 operator *(Vector2 a, float b) => new(a.x * b, a.y * b);
|
|
public static Vector2 operator *(float a, Vector2 b) => new(a * b.x, a * b.y);
|
|
public static Vector2 operator /(Vector2 a, Vector2 b) => new(a.x / b.x, a.y / b.y);
|
|
public static Vector2 operator /(Vector2 a, float b) => new(a.x / b, a.y / b);
|
|
public static Vector2 operator /(float a, Vector2 b) => new(a / b.x, a / b.y);
|
|
public static bool operator ==(Vector2 a, Vector2 b) => a.Equals(b);
|
|
public static bool operator !=(Vector2 a, Vector2 b) => !a.Equals(b);
|
|
public static bool operator >(Vector2 a, Vector2 b) => a.x > b.x && a.y > b.y;
|
|
public static bool operator <(Vector2 a, Vector2 b) => a.x < b.x && a.y < b.y;
|
|
public static bool operator >=(Vector2 a, Vector2 b) => (a.x > b.x && a.y > b.y) || a.Equals(b);
|
|
public static bool operator <=(Vector2 a, Vector2 b) => (a.x < b.x && a.y < b.y) || a.Equals(b);
|
|
|
|
public static explicit operator Vector2(Vector3 input) => new(input.x, input.y);
|
|
public static explicit operator Vector2(Vector4 input) => new(input.x, input.y);
|
|
}
|
|
[Serializable]
|
|
public struct Vector3 : IMathFunctions<Vector3>
|
|
{
|
|
public float x, y, z;
|
|
|
|
public static Vector3 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); }
|
|
public static Vector3 One { get => new(1, 1, 1); }
|
|
public static Vector3 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); }
|
|
public static Vector3 Zero { get => new(0, 0, 0); }
|
|
|
|
public Vector3(float x) => this = new(x, 0, 0);
|
|
public Vector3(float x, float y) => this = new(x, y, 0);
|
|
public Vector3(float x, float y, float z)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
}
|
|
|
|
public Vector3 Average(params Vector3[] objs)
|
|
{
|
|
float[] averageX = new float[objs.Length + 1];
|
|
float[] averageY = new float[objs.Length + 1];
|
|
float[] averageZ = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageX[i] = objs[i].x;
|
|
averageY[i] = objs[i].y;
|
|
averageZ[i] = objs[i].z;
|
|
}
|
|
averageX[objs.Length] = x;
|
|
averageY[objs.Length] = y;
|
|
averageZ[objs.Length] = z;
|
|
return new(Math.Average(averageX), Math.Average(averageY), Math.Average(averageZ));
|
|
}
|
|
public Vector3 Max(params Vector3[] objs)
|
|
{
|
|
float[] maxX = new float[objs.Length + 1];
|
|
float[] maxY = new float[objs.Length + 1];
|
|
float[] maxZ = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxX[i] = objs[i].x;
|
|
maxY[i] = objs[i].y;
|
|
maxZ[i] = objs[i].z;
|
|
}
|
|
maxX[objs.Length] = x;
|
|
maxY[objs.Length] = y;
|
|
maxZ[objs.Length] = z;
|
|
return new(Math.Max(maxX), Math.Max(maxY), Math.Max(maxZ));
|
|
}
|
|
public Vector3 Min(params Vector3[] objs)
|
|
{
|
|
float[] minX = new float[objs.Length + 1];
|
|
float[] minY = new float[objs.Length + 1];
|
|
float[] minZ = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minX[i] = objs[i].x;
|
|
minY[i] = objs[i].y;
|
|
minZ[i] = objs[i].z;
|
|
}
|
|
minX[objs.Length] = x;
|
|
minY[objs.Length] = y;
|
|
minZ[objs.Length] = z;
|
|
return new(Math.Min(minX), Math.Min(minY), Math.Min(minZ));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Vector3 other) => x == other.x && y == other.y && z == other.z;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z:" + z.ToString();
|
|
public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z:" + z.ToString(format);
|
|
|
|
public static Vector3 operator +(Vector3 a, Vector3 b) => new(a.x + b.x, a.y + b.y, a.z + b.z);
|
|
public static Vector3 operator +(Vector3 a, float b) => new(a.x + b, a.y + b, a.z + b);
|
|
public static Vector3 operator +(float a, Vector3 b) => new(a + b.x, a + b.y, a + b.z);
|
|
public static Vector3 operator -(Vector3 a, Vector3 b) => new(a.x - b.x, a.y - b.y, a.z - b.z);
|
|
public static Vector3 operator -(Vector3 a, float b) => new(a.x - b, a.y - b, a.z - b);
|
|
public static Vector3 operator -(float a, Vector3 b) => new(a - b.x, a - b.y, a - b.z);
|
|
public static Vector3 operator *(Vector3 a, Vector3 b) => new(a.x * b.x, a.y * b.y, a.z * b.z);
|
|
public static Vector3 operator *(Vector3 a, float b) => new(a.x * b, a.y * b, a.z * b);
|
|
public static Vector3 operator *(float a, Vector3 b) => new(a * b.x, a * b.y, a * b.z);
|
|
public static Vector3 operator /(Vector3 a, Vector3 b) => new(a.x / b.x, a.y / b.y, a.z / b.z);
|
|
public static Vector3 operator /(Vector3 a, float b) => new(a.x / b, a.y / b, a.z / b);
|
|
public static Vector3 operator /(float a, Vector3 b) => new(a / b.x, a / b.y, a / b.z);
|
|
public static bool operator ==(Vector3 a, Vector3 b) => a.Equals(b);
|
|
public static bool operator !=(Vector3 a, Vector3 b) => !a.Equals(b);
|
|
public static bool operator >(Vector3 a, Vector3 b) => a.x > b.x && a.y > b.y && a.z > b.z;
|
|
public static bool operator <(Vector3 a, Vector3 b) => a.x < b.x && a.y < b.y && a.z < b.z;
|
|
public static bool operator >=(Vector3 a, Vector3 b) => (a.x > b.x && a.y > b.y && a.z > b.z) || a.Equals(b);
|
|
public static bool operator <=(Vector3 a, Vector3 b) => (a.x < b.x && a.y < b.y && a.z < b.z) || a.Equals(b);
|
|
|
|
public static implicit operator Vector3(Color input) => new(input.r, input.g, input.b);
|
|
public static implicit operator Vector3(Vector2 input) => new(input.x, input.y);
|
|
public static explicit operator Vector3(Vector4 input) => new(input.x, input.y, input.z);
|
|
}
|
|
[Serializable]
|
|
public struct Vector4 : IMathFunctions<Vector4>
|
|
{
|
|
public float x, y, z, w;
|
|
|
|
public static Vector4 NegativeInfinity { get => new(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity); }
|
|
public static Vector4 One { get => new(1, 1, 1, 1); }
|
|
public static Vector4 PositiveInfinity { get => new(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity); }
|
|
public static Vector4 Zero { get => new(0, 0, 0, 0); }
|
|
|
|
public Vector4(float x) => this = new(x, 0, 0, 0);
|
|
public Vector4(float x, float y) => this = new(x, y, 0, 0);
|
|
public Vector4(float x, float y, float z) => this = new(x, y, z, 0);
|
|
public Vector4(float x, float y, float z, float w)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
this.z = z;
|
|
this.w = w;
|
|
}
|
|
|
|
public Vector4 Average(params Vector4[] objs)
|
|
{
|
|
float[] averageX = new float[objs.Length + 1];
|
|
float[] averageY = new float[objs.Length + 1];
|
|
float[] averageZ = new float[objs.Length + 1];
|
|
float[] averageW = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
averageX[i] = objs[i].x;
|
|
averageY[i] = objs[i].y;
|
|
averageZ[i] = objs[i].z;
|
|
averageW[i] = objs[i].w;
|
|
}
|
|
averageX[objs.Length] = x;
|
|
averageY[objs.Length] = y;
|
|
averageZ[objs.Length] = z;
|
|
averageW[objs.Length] = w;
|
|
return new(Math.Average(averageX), Math.Average(averageY), Math.Average(averageZ), Math.Average(averageW));
|
|
}
|
|
public Vector4 Max(params Vector4[] objs)
|
|
{
|
|
float[] maxX = new float[objs.Length + 1];
|
|
float[] maxY = new float[objs.Length + 1];
|
|
float[] maxZ = new float[objs.Length + 1];
|
|
float[] maxW = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
maxX[i] = objs[i].x;
|
|
maxY[i] = objs[i].y;
|
|
maxZ[i] = objs[i].z;
|
|
maxW[i] = objs[i].w;
|
|
}
|
|
maxX[objs.Length] = x;
|
|
maxY[objs.Length] = y;
|
|
maxZ[objs.Length] = z;
|
|
maxW[objs.Length] = w;
|
|
return new(Math.Max(maxX), Math.Max(maxY), Math.Max(maxZ), Math.Max(maxW));
|
|
}
|
|
public Vector4 Min(params Vector4[] objs)
|
|
{
|
|
float[] minX = new float[objs.Length + 1];
|
|
float[] minY = new float[objs.Length + 1];
|
|
float[] minZ = new float[objs.Length + 1];
|
|
float[] minW = new float[objs.Length + 1];
|
|
for (int i = 0; i < objs.Length; i++)
|
|
{
|
|
minX[i] = objs[i].x;
|
|
minY[i] = objs[i].y;
|
|
minZ[i] = objs[i].z;
|
|
minW[i] = objs[i].w;
|
|
}
|
|
minX[objs.Length] = x;
|
|
minY[objs.Length] = y;
|
|
minZ[objs.Length] = z;
|
|
minW[objs.Length] = w;
|
|
return new(Math.Min(minX), Math.Min(minY), Math.Min(minZ), Math.Min(minW));
|
|
}
|
|
|
|
public override bool Equals(object obj) => base.Equals(obj);
|
|
public bool Equals(Vector4 other) => x == other.x && y == other.y && z == other.z && w == other.w;
|
|
public override int GetHashCode() => base.GetHashCode();
|
|
public override string ToString() => "X: " + x.ToString() + " | Y: " + y.ToString() + " | Z: " + z.ToString() + " | W: " + w.ToString();
|
|
public string ToString(string format) => "X: " + x.ToString(format) + " | Y: " + y.ToString(format) + " | Z: " + z.ToString(format) + " | W: " + w.ToString(format);
|
|
|
|
public static Vector4 operator +(Vector4 a, Vector4 b) => new(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
|
|
public static Vector4 operator +(Vector4 a, float b) => new(a.x + b, a.y + b, a.z + b, a.w + b);
|
|
public static Vector4 operator +(float a, Vector4 b) => new(a + b.x, a + b.y, a + b.z, a + b.w);
|
|
public static Vector4 operator -(Vector4 a, Vector4 b) => new(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
|
|
public static Vector4 operator -(Vector4 a, float b) => new(a.x - b, a.y - b, a.z - b, a.w - b);
|
|
public static Vector4 operator -(float a, Vector4 b) => new(a - b.x, a - b.y, a - b.z, a - b.w);
|
|
public static Vector4 operator *(Vector4 a, Vector4 b) => new(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
|
|
public static Vector4 operator *(Vector4 a, float b) => new(a.x * b, a.y * b, a.z * b, a.w * b);
|
|
public static Vector4 operator *(float a, Vector4 b) => new(a * b.x, a * b.y, a * b.z, a * b.w);
|
|
public static Vector4 operator /(Vector4 a, Vector4 b) => new(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
|
|
public static Vector4 operator /(Vector4 a, float b) => new(a.x / b, a.y / b, a.z / b, a.w / b);
|
|
public static Vector4 operator /(float a, Vector4 b) => new(a / b.x, a / b.y, a / b.z, a / b.w);
|
|
public static bool operator ==(Vector4 a, Vector4 b) => a.Equals(b);
|
|
public static bool operator !=(Vector4 a, Vector4 b) => !a.Equals(b);
|
|
public static bool operator >(Vector4 a, Vector4 b) => a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w;
|
|
public static bool operator <(Vector4 a, Vector4 b) => a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w;
|
|
public static bool operator >=(Vector4 a, Vector4 b) => (a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w) || a.Equals(b);
|
|
public static bool operator <=(Vector4 a, Vector4 b) => (a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w) || a.Equals(b);
|
|
|
|
public static implicit operator Vector4(Color input) => new(input.r, input.g, input.b, input.a);
|
|
public static implicit operator Vector4(Vector2 input) => new(input.x, input.y);
|
|
public static implicit operator Vector4(Vector3 input) => new(input.x, input.y, input.z);
|
|
}
|
|
|
|
namespace Interfaces
|
|
{
|
|
public interface IMathFunctions<T>
|
|
{
|
|
public T Average(params T[] objs);
|
|
public T Max(params T[] objs);
|
|
public T Min(params T[] objs);
|
|
}
|
|
|
|
public interface INegatives<T>
|
|
{
|
|
public T Absolute { get; }
|
|
public bool IsNegative { get; }
|
|
public T Negative { get; }
|
|
public T Positive { get; }
|
|
}
|
|
}
|
|
} |