feat: add overlap logic

Signed-off-by: Michael Pollind <mpollind@gmail.com>

Author: pollend

src/geometry/geom.zig src/geometry.zigsrc/geometry/geom.zig renamed to src/geometry.zig

@@ -1,9 +1,23 @@
 const std = @import("std");
-const vec = @import("../vector.zig");
+const vec = @import("vector.zig");
+
+pub const AABB = @import("geometry/aabb.zig").AABB;
+pub const Plane = @import("geometry/plane.zig").Plane;
+pub const Sphere = @import("geometry/sphere.zig").Sphere;
+pub const OrientedBox = @import("geometry/oriented_box.zig").OrientedBox;
+pub const overlap = @import("geometry/overlap.zig");
+
+test {
+    @import("std").testing.refAllDeclsRecursive(@This());
+}
+
+pub const Primative = enum {
+    AABB,
+    Plane,
+    Sphere,
+    OrientedBox,
+};
 
-pub const AABB = @import("aabb.zig").AABB;
-pub const Plane = @import("plane.zig").Plane;
-pub const Sphere = @import("sphere.zig").Sphere;
 
 pub fn get_vector_from_buffer(comptime T: type, vertex_index: usize, buffer: []align(4) const u8, byte_offset: usize, byte_stride: usize) T {
     const vector_len = switch(@typeInfo(T)) {
@@ -22,11 +36,6 @@ pub fn get_vector_from_buffer(comptime T: type, vertex_index: usize, buffer: []a
     return arr;
 }
 
-test {
-    @import("std").testing.refAllDeclsRecursive(@This());
-}
-
-
 test "vector_from_buffer - basic 2D f32 vector extraction" {
     // Create a buffer with 2D f32 vectors: [1.0, 2.0], [3.0, 4.0], [5.0, 6.0]
     const data = [_]f32{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };
@@ -202,3 +211,4 @@ test "vector_from_buffer - mixed data types with padding" {
     try std.testing.expectEqual(@as(f32, 0.5), norm2[1]);
     try std.testing.expectEqual(@as(f32, 0.6), norm2[2]);
 }
+

src/geometry/aabb.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 const vec = @import("../vector.zig");
-const math = std.math;
 
 pub fn AABB(comptime T: type) type {
     return struct {
@@ -36,8 +35,8 @@ pub fn AABB(comptime T: type) type {
         }
 
         pub fn ray_intersection_with_inverse(self: Self, origin: @Vector(3, T), inv_direction: InvDirection) T {
-            const flt_min: @Vector(3, T) = @as(@Vector(3, T), @splat(-math.floatMax(T)));
-            const flt_max: @Vector(3, T) = @as(@Vector(3, T), @splat(math.floatMax(T)));
+            const flt_min: @Vector(3, T) = @as(@Vector(3, T), @splat(-std.math.floatMax(T)));
+            const flt_max: @Vector(3, T) = @as(@Vector(3, T), @splat(std.math.floatMax(T)));
 
             // test against all three axes simultaneously
             const t1 = (self.min - origin) * inv_direction.inv_direction;

src/geometry/buffer_view.zig

@@ -0,0 +1,16 @@
+const std = @import("std");
+
+pub fn BufferView(comptime T: type) type {
+    return struct {
+        pub const inner_type = switch (@typeInfo(T)) { 
+            .vector => |v| [v.len]std.meta.Child(T),
+            .array => |a| [a.len]std.meta.Child(T),
+            else => @compileError("Expected a vector or array type, got: " ++ @typeName(T)),
+        };
+        pub const num_elements = switch (@typeInfo(T)) {
+            .vector => |v| v.len,
+            .array => |a| a.len,
+            else => @compileError("Expected a vector or array type, got: " ++ @typeName(T)),
+        };
+    };
+}

src/geometry/oriented_box.zig

@@ -0,0 +1,11 @@
+const Mat = @import("../matrix.zig").Mat; 
+const geometry = @import("../geometry.zig");
+
+pub fn OrientedBox(comptime T: type) type {
+    return struct {
+        pub const primative_type = geometry.Primative.OrientedBox; 
+        orientation: Mat(4,4, T),
+        half_extent: @Vector(3, T),
+    };
+}
+

src/geometry/overlap.zig

@@ -0,0 +1,32 @@
+const std = @import("std");
+const Mat = @import("../matrix.zig").Mat;
+const geometry = @import("../geometry.zig");
+const Sphere = @import("sphere.zig").Sphere;
+const vector = @import("../vector.zig");
+
+pub fn overlap_sphere_sphere(a: anytype, b: anytype) bool {
+    if (@TypeOf(a).primative_type != .Sphere) @compileError("Expected Sphere" ++ @typeName(@TypeOf(a)));
+    if (@TypeOf(b).primative_type != .Sphere) @compileError("Expected Sphere" ++ @typeName(@TypeOf(b)));
+    if (@TypeOf(a).inner_type != @TypeOf(b).inner_type) @compileError("Expected same type: " ++ @typeName(@TypeOf(a).inner_type) ++ " " ++ @typeName(@TypeOf(b).inner_type));
+    return vector.norm_sqr(a.center - b.center) <= (a.radius + b.radius) * (a.radius + b.radius);
+}
+
+pub inline fn overlap(a: anytype, b: anytype) bool {
+    const a_primative: geometry.Primative = @TypeOf(a).primative_type;
+    const b_primative: geometry.Primative = @TypeOf(b).primative_type;
+    if (a_primative == .Sphere and b_primative == .Sphere) {
+        return overlap_sphere_sphere(a, b);
+    }
+    @compileError("Unsupported primative overlap: " ++ @typeName(a_primative) ++ " " ++ @typeName(b_primative));
+}
+
+test overlap_sphere_sphere {
+    const s1: Sphere(f32) = .from_center_radius(.{ 0, 0, 0 }, 1);
+    const s2: Sphere(f32) = .from_center_radius(.{ 0, 0, 1.5 }, 1);
+    const s3: Sphere(f32) = .from_center_radius(.{ 0, 0, 3 }, 1);
+    try std.testing.expect(overlap_sphere_sphere(s1, s2));
+    try std.testing.expect(!overlap_sphere_sphere(s1, s3));
+    // Symmetric
+    try std.testing.expect(overlap(s1, s2));
+    try std.testing.expect(overlap(s2, s1));
+}

src/geometry/plane.zig

@@ -6,7 +6,7 @@ pub fn Plane(comptime T: type) type {
     return struct {
         normal: @Vector(3, T), // normal vector
         c: T, // constant
-
+        
         const Self = @This();
 
         pub fn normal_and_constant(self: Self) @Vector(4, T) {

src/geometry/sphere.zig

@@ -1,14 +1,16 @@
-const std = @import("std");
-const vector = @import("../vector.zig");
 const meta = @import("../meta.zig");
-
+const zla = @import("../root.zig");
+const geometry = zla.geom;
 
 pub fn Sphere(comptime T: type) type {
     return struct {
+        pub const inner_type: type = T;
+        pub const primative_type: geometry.Primative = .Sphere;
+
         center: @Vector(3, T),
         radius: T,
 
-        pub fn from_center_radius(center: anytype, radius: T) Sphere(T) {
+        pub fn from_center_radius(center: @Vector(3, T), radius: T) Sphere(T) {
             return .{
                 .center = meta.map_to_vector(center),
                 .radius = radius,

src/geometry/buffer.zig src/geometry/test.zigsrc/geometry/buffer.zig renamed to src/geometry/test.zig

@@ -13,7 +13,7 @@ const Vec2f64 = vec.Vec2f64;
 const Quat4f32 = quat.Quat4f32;
 const Quat4f64 = quat.Quat4f64;
 
-pub const geom = @import("geometry/geom.zig");
+pub const geom = @import("geometry.zig");
 
 test {
     @import("std").testing.refAllDeclsRecursive(@This());