Use castle for vecmath (doesn't work fully yet)

src/math.zig

@@ -1,41 +1,8 @@
 const std = @import("std");
+const vm = @import("vecmath");
 
 pub const Iterator2 = @import("math/Iterator2.zig").Iterator2;
 pub const Iterator3 = @import("math/Iterator3.zig").Iterator3;
-pub const Matrix4x4 = @import("math/Matrix4x4.zig").Matrix4x4;
-pub const Quaternion = @import("math/Quaternion.zig").Quaternion;
-pub const Vector2 = @import("math/Vector2.zig").Vector2;
-pub const Vector2Int = @import("math/Vector2Int.zig").Vector2Int;
-pub const Vector2x8 = @import("math/Vector2x8.zig").Vector2x8;
-pub const Vector3 = @import("math/Vector3.zig").Vector3;
-pub const Vector3Int = @import("math/Vector3Int.zig").Vector3Int;
-pub const Vector4 = @import("math/Vector4.zig").Vector4;
-
-pub const f32x8 = @Vector(8, f32);
-pub const i32x8 = @Vector(8, i32);
-pub const u32x8 = @Vector(8, u32);
-pub const u64x8 = @Vector(8, u64);
-
-pub inline fn ps(value: f32) f32x8 {
-    return @splat(value);
-}
-
-pub inline fn epi32(value: i32) i32x8 {
-    return @splat(value);
-}
-
-pub inline fn epu32(value: u32) u32x8 {
-    return @splat(value);
-}
-
-pub inline fn epu64x2(value: u64) u64x8 {
-    return @splat(value);
-}
-
-pub inline fn lerp(a: f32, b: f32, t: f32) f32 {
-    const s = 1.0 - t;
-    return a * s + b * t;
-}
 
 pub const noise2 = @import("math/noise.zig").noise2;
 pub const noise2x8 = @import("math/noise.zig").noise2x8;
@@ -46,18 +13,90 @@ pub inline fn asFloatFrac(frac: i32) f32 {
     return @floatCast(numerator / denominator);
 }
 
+pub inline fn asFloatFrac2(frac: vm.Vector2Int) vm.Vector2 {
+    return .init(
+        asFloatFrac(frac.x),
+        asFloatFrac(frac.y),
+    );
+}
+
+pub inline fn asFloatFrac3(frac: vm.Vector3Int) vm.Vector3 {
+    return .init(
+        asFloatFrac(frac.x),
+        asFloatFrac(frac.y),
+        asFloatFrac(frac.z),
+    );
+}
+
+pub inline fn asFloatFrac4(frac: vm.Vector4Int) vm.Vector4 {
+    return .init(
+        asFloatFrac(frac.x),
+        asFloatFrac(frac.y),
+        asFloatFrac(frac.z),
+        asFloatFrac(frac.w),
+    );
+}
+
 pub inline fn asIntFrac(frac: f32) i32 {
     const fraction: f64 = @floatCast(frac);
     const scale: f64 = std.math.maxInt(i32);
     return @intFromFloat(@round(fraction * scale));
 }
 
+pub inline fn asIntFrac2(frac: vm.Vector2) vm.Vector2Int {
+    return .init(
+        asIntFrac(frac.x),
+        asIntFrac(frac.y),
+    );
+}
+
+pub inline fn asIntFrac3(frac: vm.Vector3) vm.Vector3Int {
+    return .init(
+        asIntFrac(frac.x),
+        asIntFrac(frac.y),
+        asIntFrac(frac.z),
+    );
+}
+
+pub inline fn asIntFrac4(frac: vm.Vector4) vm.Vector4Int {
+    return .init(
+        asIntFrac(frac.x),
+        asIntFrac(frac.y),
+        asIntFrac(frac.z),
+        asIntFrac(frac.w),
+    );
+}
+
 pub inline fn mulIntFloat(int: i32, float: f32) i32 {
     const int_float: f64 = @floatFromInt(int);
     const float_wide: f64 = @floatCast(float);
     return @intFromFloat(@round(int_float * float_wide));
 }
 
+pub inline fn mulIntFloat2(int: vm.Vector2Int, float: f32) vm.Vector2Int {
+    return .init(
+        mulIntFloat(int.x, float),
+        mulIntFloat(int.y, float),
+    );
+}
+
+pub inline fn mulIntFloat3(int: vm.Vector3Int, float: f32) vm.Vector3Int {
+    return .init(
+        mulIntFloat(int.x, float),
+        mulIntFloat(int.y, float),
+        mulIntFloat(int.z, float),
+    );
+}
+
+pub inline fn mulIntFloat4(int: vm.Vector4Int, float: f32) vm.Vector4Int {
+    return .init(
+        mulIntFloat(int.x, float),
+        mulIntFloat(int.y, float),
+        mulIntFloat(int.z, float),
+        mulIntFloat(int.w, float),
+    );
+}
+
 pub inline fn mulFrac(a: i32, b: i32) i32 {
     const denominator: i64 = std.math.maxInt(i32);
     const rounding_bias: i64 = denominator >> 1;
@@ -66,6 +105,30 @@ pub inline fn mulFrac(a: i32, b: i32) i32 {
     return @intCast(@divFloor(a_wide * b_wide + rounding_bias, denominator));
 }
 
+pub inline fn mulFrac2(a: vm.Vector2Int, b: i32) vm.Vector2Int {
+    return .init(
+        mulFrac(a.x, b),
+        mulFrac(a.y, b),
+    );
+}
+
+pub inline fn mulFrac3(a: vm.Vector3Int, b: i32) vm.Vector3Int {
+    return .init(
+        mulFrac(a.x, b),
+        mulFrac(a.y, b),
+        mulFrac(a.z, b),
+    );
+}
+
+pub inline fn mulFrac4(a: vm.Vector4Int, b: i32) vm.Vector4Int {
+    return .init(
+        mulFrac(a.x, b),
+        mulFrac(a.y, b),
+        mulFrac(a.z, b),
+        mulFrac(a.w, b),
+    );
+}
+
 pub inline fn mulFracFrac(a: i32, b: i32) i32 {
     const denominator: i64 = std.math.maxInt(i32) * std.math.maxInt(i32);
     const rounding_bias: i64 = denominator >> 1;
@@ -74,6 +137,30 @@ pub inline fn mulFracFrac(a: i32, b: i32) i32 {
     return .{ .vector = @intCast(@divFloor(a_wide * b_wide + rounding_bias, denominator)) };
 }
 
+pub inline fn mulFracFrac2(a: vm.Vector2Int, b: i32) vm.Vector2Int {
+    return .init(
+        mulFracFrac(a.x, b),
+        mulFracFrac(a.y, b),
+    );
+}
+
+pub inline fn mulFracFrac3(a: vm.Vector3Int, b: i32) vm.Vector3Int {
+    return .init(
+        mulFracFrac(a.x, b),
+        mulFracFrac(a.y, b),
+        mulFracFrac(a.z, b),
+    );
+}
+
+pub inline fn mulFracFrac4(a: vm.Vector4Int, b: i32) vm.Vector4Int {
+    return .init(
+        mulFracFrac(a.x, b),
+        mulFracFrac(a.y, b),
+        mulFracFrac(a.z, b),
+        mulFracFrac(a.w, b),
+    );
+}
+
 pub inline fn wideMulDivFloor(a: i32, mul: i32, div: i32) i32 {
     return @intCast(@divFloor(@as(i64, a) * @as(i64, mul), div));
 }