/// <param name="x">Denominator</param>
/// <param name="y">Numerator</param>
public static fp Atan2(fp y, fp x)
{
var absX = Abs(x);
var absY = Abs(y);
var t3 = absX;
var t1 = absY;
var t0 = Max(t3, t1);
t1 = Min(t3, t1);
t3 = fp._1 / t0;
t3 = t1 * t3;
var t4 = t3 * t3;
t0 = _atan2Number1;
t0 = t0 * t4 + _atan2Number2;
t0 = t0 * t4 - _atan2Number3;
t0 = t0 * t4 + _atan2Number4;
t0 = t0 * t4 - _atan2Number5;
t0 = t0 * t4 + _atan2Number6;
t3 = t0 * t3;
t3 = absY > absX ? _atan2Number7 - t3 : t3;
t3 = x < fp._0 ? _atan2Number8 - t3 : t3;
t3 = y < fp._0 ? -t3 : t3;
return(t3);
}
public static fp RadiansSkipNormalize(fp2 a, fp2 b)
{
fp2 a1 = a;
fp2 b1 = b;
var x = ((a1.x.value * b1.x.value) >> fixlut.PRECISION);
var z = ((a1.y.value * b1.y.value) >> fixlut.PRECISION);
fp r;
r.value = x + z;
var dot = r;
fp min = -fp._1;
fp max = +fp._1;
fp ret;
if (dot.value < min.value)
{
ret = min;
}
else
{
if (dot.value > max.value)
{
ret = max;
}
else
{
ret = dot;
}
}
return(new fp(fixlut.acos(ret.value)));
}
public fp4(fp3 v, fp w)
{
x = v.x;
y = v.y;
z = v.z;
this.w = w;
}
public fp4(fp2 xy, fp2 zw)
{
x = xy.x;
y = xy.y;
z = zw.x;
w = zw.y;
}
public fp4(fp x, fp y, fp z, fp w)
{
this.x = x;
this.y = y;
this.z = z;
this.w = w;
}
/// <param name="num">Angle in radians</param>
public static void SinCos(fp num, out fp sin, out fp cos)
{
num.value %= fp.pi2.value;
num *= fp.one_div_pi2;
fixlut.sin_cos(num.value, out var sinVal, out var cosVal);
sin.value = sinVal;
cos.value = cosVal;
}
public static fp Max(fp a, fp b)
{
if (a.value > b.value)
{
return(a);
}
return(b);
}
public static fp Min(fp a, fp b)
{
if (a.value < b.value)
{
return(a);
}
return(b);
}
public static fp2 Y(fp y)
{
fp2 r;
r.x.value = 0;
r.y.value = y.value;
return(r);
}
public static void SinCosTan(fp num, out fp sin, out fp cos, out fp tan)
{
num.value %= fp.pi2.value;
num *= fp.one_div_pi2;
fixlut.sin_cos_tan(num.value, out var sinVal, out var cosVal, out var tanVal);
sin = new fp(sinVal);
cos = new fp(cosVal);
tan = new fp(tanVal);
}
public static fp2 X(fp x)
{
fp2 r;
r.x.value = x.value;
r.y.value = 0;
return(r);
}
public static fp2 ClampMagnitude(fp2 v, fp length)
{
fp2 value = v;
fp r;
r.value =
((value.x.value * value.x.value) >> fixlut.PRECISION) +
((value.y.value * value.y.value) >> fixlut.PRECISION);
if (r.value <= ((length.value * length.value) >> fixlut.PRECISION))
{
}
else
{
fp2 v1 = value;
fp m = default;
fp r2;
r2.value =
((v1.x.value * v1.x.value) >> fixlut.PRECISION) +
((v1.y.value * v1.y.value) >> fixlut.PRECISION);
fp r1;
if (r2.value == 0)
{
r1.value = 0;
}
else
{
var b = (r2.value >> 1) + 1L;
var c = (b + (r2.value / b)) >> 1;
while (c < b)
{
b = c;
c = (b + (r2.value / b)) >> 1;
}
r1.value = b << (fixlut.PRECISION >> 1);
}
m = r1;
if (m.value <= fp.epsilon.value)
{
v1 = default;
}
else
{
v1.x.value = ((v1.x.value << fixlut.PRECISION) / m.value);
v1.y.value = ((v1.y.value << fixlut.PRECISION) / m.value);
}
value = v1 * length;
}
return(value);
}
public static fp Clamp01(fp num)
{
if (num.value < 0)
{
return(fp._0);
}
return(num.value > fp._1.value ? fp._1 : num);
}
public static fp3 X(fp x)
{
fp3 r;
r.x.value = x.value;
r.y.value = 0;
r.z.value = 0;
return(r);
}
public static fp Sin(fp num)
{
num.value %= fp.pi2.value;
num *= fp.one_div_pi2;
var raw = fixlut.sin(num.value);
fp result;
result.value = raw;
return(result);
}
public static fp3 Y(fp y)
{
fp3 r;
r.x.value = 0;
r.y.value = y.value;
r.z.value = 0;
return(r);
}
public static fp3 Z(fp z)
{
fp3 r;
r.x.value = 0;
r.y.value = 0;
r.z.value = z.value;
return(r);
}
public static int RoundToInt(fp num)
{
var fraction = num.value & 0x000000000000FFFFL;
if (fraction >= fixlut.HALF)
{
return(num.AsInt + 1);
}
return(num.AsInt);
}
public static fp3 Normalize(fp3 v, out fp magnitude)
{
if (v == fp3.zero)
{
magnitude = fp._0;
return(fp3.zero);
}
magnitude = Magnitude(v);
return(v / magnitude);
}
public static fp2 Reflect(fp2 vector, fp2 normal)
{
fp dot = (vector.x * normal.x) + (vector.y * normal.y);
fp2 result;
result.x = vector.x - ((fp._2 * dot) * normal.x);
result.y = vector.y - ((fp._2 * dot) * normal.y);
return(result);
}
public static fp Cos(fp num)
{
var sign = fp.one;
if (num > fp.pi || num < -fp.pi)
{
sign = fp.minus_one;
}
return(new fp(fixlut.cos(num.value)) * sign);
}
public static int RoundToInt(fp num)
{
var fraction = new fp(num.value & 0x000000000000FFFFL);
if (fraction.value >= fp._0_50.value)
{
return(num.AsInt + 1);
}
return(num.AsInt);
}
public static fp SqrtAprox(fp num)
{
var sign = fp.one;
if (num < fp.zero)
{
sign = fp.minus_one;
num *= fp.minus_one;
}
return(new fp(fixlut.sqrt_aprox(num.AsLong)) * sign);
}
public static fp Ceil(fp num)
{
var fractions = num.value & 0x000000000000FFFFL;
if (fractions == 0)
{
return(num);
}
var full = new fp(num.value >> fixlut.PRECISION << fixlut.PRECISION);
return(full + fp._1);
}
public static fp Ceil(fp num)
{
var fractions = num.value & 0x000000000000FFFFL;
if (fractions == 0)
{
return(num);
}
num.value = num.value >> fixlut.PRECISION << fixlut.PRECISION;
num.value += fixlut.ONE;
return(num);
}
public static fp3 MoveTowards(fp3 current, fp3 target, fp maxDelta)
{
var v = target - current;
var sqrMagnitude = MagnitudeSqr(v);
if (v == fp3.zero || maxDelta >= fp._0 && sqrMagnitude <= maxDelta * maxDelta)
{
return(target);
}
var magnitude = Sqrt(sqrMagnitude);
return(current + v / magnitude * maxDelta);
}
public static fp Clamp(fp num, fp min, fp max)
{
if (num.value < min.value)
{
return(min);
}
if (num.value > max.value)
{
return(max);
}
return(num);
}
public static fp3 MagnitudeClamp(fp3 v, fp length)
{
var sqrMagnitude = MagnitudeSqr(v);
if (sqrMagnitude <= length * length)
{
return(v);
}
var magnitude = Sqrt(sqrMagnitude);
var normalized = v / magnitude;
return(normalized * length);
}
public static fp2 Rotate(fp2 vector, fp angle)
{
fp2 vector1 = vector;
var cs = Cos(angle);
var sn = Sin(angle);
var px = (vector1.x * cs) - (vector1.y * sn);
var pz = (vector1.x * sn) + (vector1.y * cs);
vector1.x = px;
vector1.y = pz;
return(vector1);
}
public static fp Lerp(fp from, fp to, fp t)
{
fp ret;
if (t.value < fp.zero.value)
{
ret = fp.zero;
}
else
{
ret = t.value > fp.one.value ? fp.one : t;
}
return(from + (to - from) * ret);
}
