collide 0.3.0

Simple extensible collision management
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# Collide

[![crates.io](https://img.shields.io/crates/v/collide)](https://crates.io/crates/collide) 
[![docs.rs](https://img.shields.io/docsrs/collide)](https://docs.rs/collide)

A generic trait system for collision detection in Rust. Implement collision checking between arbitrary shapes while maintaining dimension and scalar-type flexibility.

## Features

- 🧩 Generic `Collider` trait for cross-library interoperability
- 📐 Dimension-agnostic through [`VectorSpace`](https://crates.io/crates/vector-space) trait
- 🚀 Supports 2D/3D/N-D collisions
- 🔄 Bidirectional collision data with automatic perspective flipping

## Basic Example

```rust
use collide::{Collider, CollisionInfo, VectorSpace};

struct Sphere<V: VectorSpace> {
    center: V,
    radius: V::Scalar,
}

impl<V: VectorSpace> Collider for Sphere<V> {
    type Vector = V;
    
    fn collision_info(&self, other: &Self) -> Option<CollisionInfo<V>> {
        let delta = other.center - self.center;
        let distance = delta.magnitude();
        let direction = delta / distance;
        let min_distance = self.radius + other.radius;
        
        if distance > min_distance {
            return None;
        }

        Some(CollisionInfo {
            self_contact: self.center + direction * self.radius,
            other_contact: other.center - direction * other.radius,
            vector: direction * (min_distance - distance),
        })
    }
}
```

## Advanced Usage

Handle multiple collider types with an enum dispatch:

```rust
enum GenericCollider<V: VectorSpace> {
    Sphere { center: V, radius: V::Scalar },
    Box { center: V, size: V },
}
```

## Design Goals

1. **Interoperability**: Enable different physics engines to share collider implementations
2. **Flexibility**: Support arbitrary dimensions (2D, 3D, ND) and scalar types (f32, f64)
3. **Extensibility**: Add new collider types without breaking existing implementations
```