namespace Syntriax.Engine.Core;
///
/// Provides extension methods for type.
///
public static class Vector3DExtensions
{
///
/// Returns the representation of the .
///
/// The input .
/// The representation of the provided .
public static Vector2D As2D(this Vector3D vector) => new(vector.X, vector.Y);
///
/// Calculates the length of the .
///
/// The input .
/// The length of the .
public static float Length(this Vector3D vector) => Vector3D.Length(vector);
///
/// Calculates the squared length of the .
///
/// The input .
/// The squared length of the .
public static float LengthSquared(this Vector3D vector) => Vector3D.LengthSquared(vector);
///
/// Calculates the distance between two s.
///
/// The starting .
/// The ending .
/// The distance between the two s.
public static float Distance(this Vector3D from, Vector3D to) => Vector3D.Distance(from, to);
///
/// Returns the with its components inverted.
///
/// The input .
/// The inverted .
public static Vector3D Invert(this Vector3D vector) => Vector3D.Invert(vector);
///
/// Adds two s component-wise.
///
/// The first .
/// The vector to be added.
/// The result of the addition.
public static Vector3D Add(this Vector3D vector, Vector3D vectorToAdd) => Vector3D.Add(vector, vectorToAdd);
///
/// Subtracts one from another component-wise.
///
/// The first .
/// The to be subtracted.
/// The result of the subtraction.
public static Vector3D Subtract(this Vector3D vector, Vector3D vectorToSubtract) => Vector3D.Subtract(vector, vectorToSubtract);
///
/// Multiplies a by a scalar value.
///
/// The to multiply.
/// The scalar value to multiply with.
/// The result of the multiplication.
public static Vector3D Multiply(this Vector3D vector, float value) => Vector3D.Multiply(vector, value);
///
/// Divides a by a scalar value.
///
/// The to divide.
/// The scalar value to divide with.
/// The result of the division.
public static Vector3D Divide(this Vector3D vector, float value) => Vector3D.Divide(vector, value);
///
/// Returns a with the absolute values of each component.
///
/// The input .
/// The with absolute values.
public static Vector3D Abs(this Vector3D vector) => Vector3D.Abs(vector);
///
/// Reflects a off a surface with the specified normal.
///
/// The to reflect.
/// The normal of the reflecting surface.
/// The reflected .
public static Vector3D Reflect(this Vector3D vector, Vector3D normal) => Vector3D.Reflect(vector, normal);
///
/// Normalizes the (creates a with the same direction but with a length of 1).
///
/// The input .
/// The normalized .
public static Vector3D Normalize(this Vector3D vector) => Vector3D.Normalize(vector);
///
/// Creates a pointing from one point to another.
///
/// The starting point.
/// The ending point.
/// The pointing from to .
public static Vector3D FromTo(this Vector3D from, Vector3D to) => Vector3D.FromTo(from, to);
///
/// Scales a by another component-wise.
///
/// The to scale.
/// The containing the scaling factors for each component.
/// The scaled .
public static Vector3D Scale(this Vector3D vector, Vector3D scale) => Vector3D.Scale(vector, scale);
///
/// Rotates a by the specified angle (in radians).
///
/// The to rotate.
/// The to rotate around.
/// The angle to rotate by, in radians.
/// The rotated .
public static Vector3D Rotate(this Vector3D vector, Vector3D normal, float angleInRadian) => Vector3D.Rotate(vector, normal, angleInRadian);
///
/// Returns the component-wise minimum of two s.
///
/// The first .
/// The second .
/// The containing the minimum components from both input s.
public static Vector3D Min(this Vector3D left, Vector3D right) => Vector3D.Min(left, right);
///
/// Returns the component-wise maximum of two s.
///
/// The first .
/// The second .
/// The containing the maximum components from both input s.
public static Vector3D Max(this Vector3D left, Vector3D right) => Vector3D.Max(left, right);
///
/// Clamps each component of a between the corresponding component of two other s.
///
/// The to clamp.
/// The representing the minimum values for each component.
/// The representing the maximum values for each component.
/// The clamped .
public static Vector3D Clamp(this Vector3D vector, Vector3D min, Vector3D max) => Vector3D.Clamp(vector, min, max);
///
/// Linearly interpolates between two s.
///
/// The start .
/// The end .
/// The interpolation parameter (between 0 and 1).
/// The interpolated .
public static Vector3D Lerp(this Vector3D from, Vector3D to, float t) => Vector3D.Lerp(from, to, t);
///
/// Calculates the cross product of two s.
///
/// The first .
/// The second .
/// The cross product of the two s.
public static Vector3D Cross(this Vector3D left, Vector3D right) => Vector3D.Cross(left, right);
///
/// Calculates the angle in radians between two s.
///
/// The first .
/// The second .
/// The angle between the two s in radians.
public static float AngleBetween(this Vector3D left, Vector3D right) => Vector3D.Angle(left, right);
///
/// Calculates the dot product of two s.
///
/// The first .
/// The second .
/// The dot product of the two s.
public static float Dot(this Vector3D left, Vector3D right) => Vector3D.Dot(left, right);
///
/// Checks whether two s are approximately equal within a certain epsilon range.
///
/// The first .
/// The second .
/// The maximum difference allowed between components.
/// True if the s are approximately equal, false otherwise.
public static bool ApproximatelyEquals(this Vector3D left, Vector3D right, float epsilon = float.Epsilon) => Vector3D.ApproximatelyEquals(left, right, epsilon);
}