/// <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); }