114 lines
3.8 KiB
Zig
114 lines
3.8 KiB
Zig
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());
|
|
}
|