const std = @import("std");

// --- COLORS ------------------------------------------------------------------

pub const Color = @import("colors/Color.zig").Color;

// --- MATRICES ----------------------------------------------------------------

pub const Matrix3x2 = @import("matrices/Matrix3x2.zig").Matrix3x2;
pub const Matrix3x2x8 = @import("matrices/Matrix3x2x8.zig").Matrix3x2x8;

pub const Matrix4x4 = @import("matrices/Matrix4x4.zig").Matrix4x4;
pub const Matrix4x4x8 = @import("matrices/Matrix4x4x8.zig").Matrix4x4x8;

// --- ROTORS ------------------------------------------------------------------

pub const Complex = @import("rotors/Complex.zig").Complex;
pub const Complex_x8 = @import("rotors/Complex_x8.zig").Complex_x8;

pub const Quaternion = @import("rotors/Quaternion.zig").Quaternion;
pub const Quaternion_x8 = @import("rotors/Quaternion_x8.zig").Quaternion_x8;

// --- VECTORS -----------------------------------------------------------------

pub const Vector2 = @import("vectors/Vector2.zig").Vector2;
pub const Vector2x8 = @import("vectors/Vector2x8.zig").Vector2x8;
pub const Vector2Int = @import("vectors/Vector2Int.zig").Vector2Int;
pub const Vector2Int_x8 = @import("vectors/Vector2Int_x8.zig").Vector2Int_x8;

pub const Vector3 = @import("vectors/Vector3.zig").Vector3;
pub const Vector3x8 = @import("vectors/Vector3x8.zig").Vector3x8;
pub const Vector3Int = @import("vectors/Vector3Int.zig").Vector3Int;
pub const Vector3Int_x8 = @import("vectors/Vector3Int_x8.zig").Vector3Int_x8;

pub const Vector4 = @import("vectors/Vector4.zig").Vector4;
pub const Vector4x8 = @import("vectors/Vector4x8.zig").Vector4x8;
pub const Vector4Int = @import("vectors/Vector4Int.zig").Vector4Int;
pub const Vector4Int_x8 = @import("vectors/Vector4Int_x8.zig").Vector4Int_x8;

// --- SIMD --------------------------------------------------------------------

const simd = @import("simd.zig");

pub const f32x8 = simd.f32x8;
pub const i32x8 = simd.i32x8;
pub const u32x8 = simd.u32x8;
pub const f64x4 = simd.f64x4;
pub const i64x4 = simd.i64x4;
pub const u64x4 = simd.u64x4;

pub const ps = simd.ps;
pub const epi32 = simd.epi32;
pub const epu32 = simd.epu32;
pub const pd = simd.pd;
pub const epi64 = simd.epi64;
pub const epu64 = simd.epu64;

// --- TRIGONOMETRY ------------------------------------------------------------

const trig = @import("trig.zig");

pub const rad_per_turn = trig.rad_per_turn;
pub const deg_per_turn = trig.deg_per_turn;
pub const turns_per_rad = trig.turns_per_rad;
pub const turns_per_deg = trig.turns_per_deg;

pub const turnsToRadians = trig.turnsToRadians;
pub const turnsToDegrees = trig.turnsToDegrees;
pub const radiansToTurns = trig.radiansToTurns;
pub const degreesToTurns = trig.degreesToTurns;

pub const cos = trig.cos;
pub const cos_x8 = trig.cos_x8;
pub const sin = trig.sin;
pub const sin_x8 = trig.sin_x8;
pub const cossin = trig.cossin;
pub const cossin_x8 = trig.cossin_x8;

// -----------------------------------------------------------------------------

pub inline fn lerp(a: f32, b: f32, t: f32) f32 {
    return @mulAdd(f32, t, b, @mulAdd(f32, -t, a, a));
}

pub inline fn lerpInt(a: i32, b: i32, t: f32) i32 {
    const ab = b - a;
    const ab_float: f32 = @floatFromInt(ab);
    const d: i32 = @intFromFloat(@round(t * ab_float));
    return a + d;
}

pub inline fn lerpInt64(a: i64, b: i64, t: f32) i64 {
    const ab = b - a;
    const ab_float: f32 = @floatFromInt(ab);
    const d: i64 = @intFromFloat(@round(t * ab_float));
    return a + d;
}

pub inline fn unlerp(a: f32, b: f32, x: f32) f32 {
    return (x - a) / (b - a);
}

pub inline fn unlerpInt(a: i32, b: i32, x: i32) f32 {
    return @as(f32, @floatFromInt(x - a)) / @as(f32, @floatFromInt(b - a));
}

pub inline fn unlerpInt64(a: i64, b: i64, x: i64) f32 {
    return @as(f32, @floatFromInt(x - a)) / @as(f32, @floatFromInt(b - a));
}

test "refAllDecls" {
    std.testing.refAllDeclsRecursive(@This());
}