static public VectorF2 GetTowards(this VectorF2 item, VectorF2 target, float amount)
{
return(item.GetTowards(
target,
item.GetDirection(target) * amount
));
}
static public VectorF2 GetTowards(this VectorF2 item, VectorF2 target, VectorF2 amount)
{
return(new VectorF2(
item.x.GetTowards(target.x, amount.x),
item.y.GetTowards(target.y, amount.y)
));
}
static public IEnumerable <VectorF2> Ray(VectorF2 start, VectorF2 step, int divisions)
{
for (int i = 0; i < divisions; i++)
{
yield return(start + i * step);
}
}
static public VectorF2 GetAtPrecision(this VectorF2 item, int exponent)
{
return(new VectorF2(
item.x.GetAtPrecision(exponent),
item.y.GetAtPrecision(exponent)
));
}
static public VectorF2 ConvertFromPercentToRange(this VectorF2 item, FloatRange x_range, FloatRange y_range)
{
return(new VectorF2(
item.x.ConvertFromPercentToRange(x_range),
item.y.ConvertFromPercentToRange(y_range)
));
}
public VectorF2 GetBetween(VectorF2 a, VectorF2 b)
{
return(new VectorF2(
source.GetBetween(a.x, b.x),
source.GetBetween(a.y, b.y)
));
}
static public RectF2 CreateStrictMinMaxRectF2(VectorF2 min, VectorF2 max)
{
RectF2 rect;
TryCreateStrictMinMaxRectF2(min, max, out rect);
return(rect);
}
public VectorF2 GetVariance(VectorF2 center, VectorF2 radius)
{
return(new VectorF2(
source.GetVariance(center.x, radius.x),
source.GetVariance(center.y, radius.y)
));
}
public VectorF2 GetOffset(VectorF2 radius)
{
return(new VectorF2(
source.GetOffset(radius.x),
source.GetOffset(radius.y)
));
}
public VectorF2 GetMagnitude(VectorF2 m)
{
return(new VectorF2(
source.GetMagnitude(m.x),
source.GetMagnitude(m.y)
));
}
static public int GetPowerFillByMultiplier(this VectorF2 item, VectorF2 target, float multiplier)
{
int x_power = item.x.GetPowerFillByMultiplier(target.x, multiplier);
int y_power = item.y.GetPowerFillByMultiplier(target.y, multiplier);
return(x_power.Min(y_power));
}
static public float GetMultiplierFillByMultiplier(this VectorF2 item, VectorF2 target, float multiplier)
{
float x_multiplier = item.x.GetMultiplierFillByMultiplier(target.x, multiplier);
float y_multiplier = item.y.GetMultiplierFillByMultiplier(target.y, multiplier);
return(x_multiplier.Min(y_multiplier));
}
static public bool GetMoveTowards(this VectorF2 item, VectorF2 target, float amount, out VectorF2 output)
{
return(item.GetMoveTowards(
target,
item.GetDirection(target) * amount,
out output
));
}
static public bool IsBoundAbove(this VectorF2 item, VectorF2 value)
{
if (item.x >= value.x && item.y >= value.y)
{
return(true);
}
return(false);
}
static public bool IsTerminus(this LineSegmentF2 item, VectorF2 point)
{
if (item.p1 == point || item.p2 == point)
{
return(true);
}
return(false);
}
static public IGrid <T> Circle <T>(int radius, Operation <T, float> operation)
{
int diameter = radius * 2;
VectorF2 center = new VectorF2(radius, radius);
return(Operation <T>(diameter, diameter,
(x, y) => operation(center.GetDistanceTo(new VectorF2(x, y)) / radius)
));
}
static public bool IsOutsideDistance(this VectorF2 item, VectorF2 point, float distance)
{
if (item.IsWithinDistance(point, distance) == false)
{
return(true);
}
return(false);
}
static public bool IsOutsideSquaredDistance(this VectorF2 item, VectorF2 point, float squared_distance)
{
if (item.IsWithinSquaredDistance(point, squared_distance) == false)
{
return(true);
}
return(false);
}
static public bool IsBoundBelow(this VectorF2 item, VectorF2 value)
{
if (item.x <= value.x && item.y <= value.y)
{
return(true);
}
return(false);
}
static public bool IsZero(this VectorF2 item)
{
if (item.x == 0.0f && item.y == 0.0f)
{
return(true);
}
return(false);
}
static public bool IsWithinSquaredDistance(this VectorF2 item, VectorF2 point, float squared_distance)
{
if (item.GetSquaredDistanceTo(point) <= squared_distance)
{
return(true);
}
return(false);
}
static public float GetMagnitudeMinComponent(this VectorF2 item)
{
if (item.x.GetAbs() < item.y.GetAbs())
{
return(item.x);
}
return(item.y);
}
static public bool IsNonZero(this VectorF2 item)
{
if (item.IsZero() == false)
{
return(true);
}
return(false);
}
static public bool IsOpposingDirection(this VectorF2 item, VectorF2 direction)
{
if (item.GetDot(direction) < 0.0f)
{
return(true);
}
return(false);
}
static public bool TryCreateStrictMinMaxRectF2(VectorF2 min, VectorF2 max, out RectF2 rect)
{
if (min.IsBoundBelow(max))
{
rect = new RectF2(min, max);
return(true);
}
rect = RectF2.ZERO;
return(false);
}
static public bool GetMoveTowards(this VectorF2 item, VectorF2 target, VectorF2 amount, out VectorF2 output)
{
float x_output;
float y_output;
bool x_result = item.x.GetMoveTowards(target.x, amount.x, out x_output);
bool y_result = item.y.GetMoveTowards(target.y, amount.y, out y_output);
output = new VectorF2(x_output, y_output);
return(x_result && y_result);
}
static public VectorF2 GetProjectedPointOntoLineSegment(this VectorF2 item, VectorF2 target, VectorF2 point)
{
VectorF2 direction = item.GetDirection(target);
float point_projection = direction.GetDot(point - item);
float item_projection = 0.0f;
float target_projection = direction.GetDot(target - item);
return(direction * point_projection.BindBetween(item_projection, target_projection) + item);
}
static public VectorF2 GetNormalized(this VectorF2 item, out float magnitude)
{
magnitude = item.GetMagnitude();
if (magnitude != 0.0f)
{
return(item / magnitude);
}
return(VectorF2.ZERO);
}
static public bool Contains(this RectF2 item, VectorF2 point)
{
if (point.IsBoundAbove(item.min))
{
if (point.IsBoundBelow(item.max))
{
return(true);
}
}
return(false);
}
static public VectorF2 BindAround(this VectorF2 item, float radius)
{
float distance;
VectorF2 direction = item.GetNormalized(out distance);
if (distance > radius)
{
return(direction * radius);
}
return(item);
}
