bevy_collider_gen 0.1.0

a library for generating colliders, for bevy apps, from images with transparency
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::{
    multi_image_edge_translated, multi_image_edges_raw, single_image_edge_raw,
    single_image_edge_translated,
};
use bevy::prelude::{Image, Vec2};
use bevy_rapier2d::prelude::{Collider, Real};

/// Generate a single bevy_rapier2d polyline collider from the image,
/// coordinates translated to either side of (0, 0)
pub fn single_polyline_collider_translated(image: &Image) -> Collider {
    Collider::polyline(single_image_edge_translated(image), None)
}

/// Generate a single bevy_rapier2d polyline collider from the image,
/// coordinates left alone and all in positive x and y
pub fn single_polyline_collider_raw(image: &Image) -> Collider {
    Collider::polyline(single_image_edge_raw(image), None)
}

/// Generate a single bevy_rapier2d convex_polyline collider from the image,
/// coordinates translated to either side of (0, 0)
pub fn single_convex_polyline_collider_translated(image: &Image) -> Option<Collider> {
    Collider::convex_polyline(single_image_edge_translated(image))
}

/// Generate a single bevy_rapier2d convex_polyline collider from the image,
/// coordinates left alone and all in positive x and y
pub fn single_convex_polyline_collider_raw(image: &Image) -> Option<Collider> {
    Collider::convex_polyline(single_image_edge_raw(image))
}

/// Generate a single bevy_rapier2d convex_hull collider from the image,
/// coordinates translated to either side of (0, 0)
pub fn single_convex_hull_collider_translated(image: &Image) -> Option<Collider> {
    let points = single_image_edge_translated(image);
    Collider::convex_hull(&points)
}

/// Generate a single bevy_rapier2d convex_hull collider from the image,
/// coordinates left alone and all in positive x and y
pub fn single_convex_hull_collider_raw(image: &Image) -> Option<Collider> {
    let points = single_image_edge_translated(image);
    Collider::convex_hull(&points)
}

/// Generate a single bevy_rapier2d heightfield collider from the image,
/// coordinates translated to either side of (0, 0)
pub fn single_heightfield_collider_translated(image: &Image) -> Collider {
    heightfield_collider_from_points(&single_image_edge_translated(image))
}

/// Generate a single bevy_rapier2d heightfield collider from the image,
/// coordinates left alone and all in positive x and y
pub fn single_heightfield_collider_raw(image: &Image) -> Collider {
    heightfield_collider_from_points(&single_image_edge_raw(image))
}

/// Generate as many bevy_rapier2d polyline colliders as it can find in the image,
/// coordinates translated to either side of (0, 0)
pub fn multi_polyline_collider_translated(image: &Image) -> Vec<Collider> {
    multi_image_edge_translated(image)
        .into_iter()
        .map(|e| Collider::polyline(e, None))
        .collect()
}

/// Generate as many bevy_rapier2d polyline colliders as it can find in the image,
/// coordinates left alone and all in positive x and y
pub fn multi_polyline_collider_raw(image: &Image) -> Vec<Collider> {
    multi_image_edges_raw(image)
        .into_iter()
        .map(|e| Collider::polyline(e, None))
        .collect()
}

/// Generate as many bevy_rapier2d convex_polyline colliders as it can find in the image,
/// coordinates translated to either side of (0, 0)
pub fn multi_convex_polyline_collider_translated(image: &Image) -> Vec<Option<Collider>> {
    multi_image_edge_translated(image)
        .into_iter()
        .map(Collider::convex_polyline)
        .collect()
}

/// Generate as many bevy_rapier2d convex_polyline colliders as it can find in the image,
/// coordinates left alone and all in positive x and y
pub fn multi_convex_polyline_collider_raw(image: &Image) -> Vec<Option<Collider>> {
    multi_image_edges_raw(image)
        .into_iter()
        .map(Collider::convex_polyline)
        .collect()
}

/// Generate as many bevy_rapier2d heightfield colliders as it can find in the image,
/// coordinates translated to either side of (0, 0)
pub fn multi_heightfield_collider_translated(image: &Image) -> Vec<Collider> {
    multi_image_edge_translated(image)
        .into_iter()
        .map(|e| heightfield_collider_from_points(&e))
        .collect()
}

/// Generate as many bevy_rapier2d heightfield colliders as it can find in the image,
/// coordinates left alone and all in positive x and y
pub fn multi_heightfield_collider_raw(image: &Image) -> Vec<Collider> {
    multi_image_edges_raw(image)
        .into_iter()
        .map(|e| heightfield_collider_from_points(&e))
        .collect()
}

/// Generate as many bevy_rapier2d convex_hull colliders as it can find in the image,
/// coordinates translated to either side of (0, 0)
pub fn multi_convex_hull_collider_translated(image: &Image) -> Vec<Option<Collider>> {
    multi_image_edge_translated(image)
        .into_iter()
        .map(|e| Collider::convex_hull(&e))
        .collect()
}

/// Generate as many bevy_rapier2d convex_hull colliders as it can find in the image,
/// coordinates left alone and all in positive x and y
pub fn multi_convex_hull_collider_raw(image: &Image) -> Vec<Option<Collider>> {
    multi_image_edges_raw(image)
        .into_iter()
        .map(|e| Collider::convex_hull(&e))
        .collect()
}

/// parses x,y points into y values at the top of the image (smallest y) and creates a
/// bevy_rapier2d heightfield collider
fn heightfield_collider_from_points(v: &[Vec2]) -> Collider {
    let hf = heights_from_points(v);
    let x_scale = hf.len() as f32 - 1.0;
    Collider::heightfield(hf, Vec2::new(x_scale, 1.0))
}

/// takes x,y points collects the y values at the top of the image (smallest y)
fn heights_from_points(points: &[Vec2]) -> Vec<Real> {
    let mut heights: Vec<Vec2> = vec![];

    for p in points {
        let elem = heights.iter().enumerate().find(|(_, e)| e.x == p.x);
        if let Some((i, e)) = elem {
            if e.y < p.y {
                heights.remove(i);
                heights.insert(i, *p);
            }
        } else {
            heights.push(*p);
        }
    }

    heights.iter().map(|e| e.y).collect::<Vec<Real>>()
}