Merge branch 'juliancoffee/capsule_prism' into 'master'

New CapsulePrism collider

See merge request veloren/veloren!2843

assets/voxygen/shaders/debug-vert.glsl

@@ -9,6 +9,7 @@ layout (std140, set = 1, binding = 0)
 uniform u_locals {
     vec4 w_pos;
     vec4 w_color;
+    vec4 w_ori;
 };
 
 layout (location = 0)
@@ -16,5 +17,29 @@ out vec4 f_color;
 
 void main() {
     f_color = w_color;
-    gl_Position = all_mat * vec4((v_pos + w_pos.xyz) - focus_off.xyz, 1);
+
+    // Build rotation matrix
+    // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Rotation_matrices
+    mat3 rotation_matrix;
+    float q0 = w_ori[3];
+    float q1 = w_ori[0];
+    float q2 = w_ori[1];
+    float q3 = w_ori[2];
+
+    float r00 = 1 - 2 * (pow(q2, 2) + pow(q3, 2));
+    float r01 = 2 * (q1 * q2 - q0 * q3);
+    float r02 = 2 * (q0 * q2 + q1 * q3);
+    rotation_matrix[0] = vec3(r00, r01, r02);
+
+    float r10 = 2 * (q1 * q2 + q0 * q3);
+    float r11 = 1 - 2 * (pow(q1, 2) + pow(q3, 2));
+    float r12 = 2 * (q2 * q3 - q0 * q1);
+    rotation_matrix[1] = vec3(r10, r11, r12);
+
+    float r20 = 2 * (q1 * q3 - q0 * q2);
+    float r21 = 2 * (q0 * q1 + q2 * q3);
+    float r22 = 1 - 2 * (pow(q1, 2) + pow(q2, 2));
+    rotation_matrix[2] = vec3(r20, r21, r22);
+
+    gl_Position = all_mat * vec4((v_pos * rotation_matrix + w_pos.xyz) - focus_off.xyz, 1);
 }

common/src/comp/body.rs

@@ -147,6 +147,14 @@ impl<
     const EXTENSION: &'static str = "ron";
 }
 
+// Utility enum used to build Stadium points
+// Read doc for [Body::sausage] for more.
+//
+// Actually can be removed I guess?
+// We can just determine shape form dimensions.
+//
+// But I want Dachshund in Veloren at least somewhere XD
+
 impl Body {
     pub fn is_humanoid(&self) -> bool { matches!(self, Body::Humanoid(_)) }
 
@@ -292,11 +300,12 @@ impl Body {
     }
 
     /// The width (shoulder to shoulder), length (nose to tail) and height
-    /// respectively
+    /// respectively (in metres)
+    // Code reviewers: should we replace metres with 'block height'?
     pub fn dimensions(&self) -> Vec3<f32> {
         match self {
             Body::BipedLarge(body) => match body.species {
-                biped_large::Species::Cyclops => Vec3::new(4.6, 3.0, 6.5),
+                biped_large::Species::Cyclops => Vec3::new(5.6, 3.0, 6.5),
                 biped_large::Species::Dullahan => Vec3::new(4.6, 3.0, 5.5),
                 biped_large::Species::Mightysaurok => Vec3::new(4.0, 3.0, 3.4),
                 biped_large::Species::Mindflayer => Vec3::new(4.4, 3.0, 8.0),
@@ -350,6 +359,8 @@ impl Body {
                 quadruped_medium::Species::Ngoubou => Vec3::new(2.0, 3.2, 2.4),
                 quadruped_medium::Species::Llama => Vec3::new(2.0, 2.5, 2.6),
                 quadruped_medium::Species::Alpaca => Vec3::new(2.0, 2.0, 2.0),
+                quadruped_medium::Species::Camel => Vec3::new(2.0, 4.0, 3.5),
+                // FIXME: We really shouldn't be doing wildcards here
                 _ => Vec3::new(2.0, 3.0, 2.0),
             },
             Body::QuadrupedSmall(body) => match body.species {
@@ -389,9 +400,60 @@ impl Body {
     // Note: This is used for collisions, but it's not very accurate for shapes that
     // are very much not cylindrical. Eventually this ought to be replaced by more
     // accurate collision shapes.
-    pub fn radius(&self) -> f32 {
+    pub fn max_radius(&self) -> f32 {
         let dim = self.dimensions();
-        dim.x.max(dim.y) / 2.0
+        let (x, y) = (dim.x, dim.y);
+
+        x.max(y) / 2.0
+    }
+
+    pub fn min_radius(&self) -> f32 {
+        let (_p0, _p1, radius) = self.sausage();
+
+        radius
+    }
+
+    /// Base of our Capsule Prism used for collisions.
+    /// Returns line segment and radius. See [this wiki page][stadium_wiki].
+    ///
+    /// [stadium_wiki]: <https://en.wikipedia.org/wiki/Stadium_(geometry)>
+    pub fn sausage(&self) -> (Vec2<f32>, Vec2<f32>, f32) {
+        // Consider this ascii-art stadium with radius `r` and line segment `a`
+        //
+        //      xxxxxxxxxxxxxxxxx
+        //
+        //        _ ----------_
+        // y    -*      r      *-
+        // y   *        r        *
+        // y  * rrr aaaaaaaaa rrr *
+        // y  *         r         *
+        // y   *        r        *
+        //       *____________ ^
+        let dim = self.dimensions();
+        // The width (shoulder to shoulder) and length (nose to tail)
+        let (width, length) = (dim.x, dim.y);
+
+        if length > width {
+            // Dachshund-like
+            let radius = width / 2.0;
+
+            let a = length - 2.0 * radius;
+
+            let p0 = Vec2::new(0.0, -a / 2.0);
+            let p1 = Vec2::new(0.0, a / 2.0);
+
+            (p0, p1, radius)
+        } else {
+            // Cyclops-like
+            let radius = length / 2.0;
+
+            let a = width - 2.0 * radius;
+
+            let p0 = Vec2::new(-a / 2.0, 0.0);
+            let p1 = Vec2::new(a / 2.0, 0.0);
+
+            (p0, p1, radius)
+        }
     }
 
     // How far away other entities should try to be. Will be added uppon the other
@@ -399,7 +461,7 @@ impl Body {
     // lead to that both entities will try to keep 5.0 units away from each
     // other.
     pub fn spacing_radius(&self) -> f32 {
-        self.radius()
+        self.max_radius()
             + match self {
                 Body::QuadrupedSmall(body) => match body.species {
                     quadruped_small::Species::Rat => 0.0,
@@ -417,6 +479,7 @@ impl Body {
             }
     }
 
+    /// Height from the bottom to the top (in metres)
     pub fn height(&self) -> f32 { self.dimensions().z }
 
     pub fn base_energy(&self) -> u32 {

common/src/comp/phys.rs

@@ -54,7 +54,12 @@ pub struct PreviousPhysCache {
     /// Calculates a Sphere over the Entity for quick boundary checking
     pub collision_boundary: f32,
     pub scale: f32,
+    /// Approximate radius of cylinder of collider.
     pub scaled_radius: f32,
+    /// Radius of stadium of collider.
+    pub neighborhood_radius: f32,
+    /// relative p0 and p1 of collider's statium, None if cylinder.
+    pub origins: Option<(Vec2<f32>, Vec2<f32>)>,
     pub ori: Quaternion<f32>,
 }
 
@@ -99,18 +104,30 @@ impl Component for Density {
 // Collider
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum Collider {
-    // TODO: pass the map from ids -> voxel data to get_radius and get_z_limits to compute a
+    // TODO: pass the map from ids -> voxel data to get_radius
-    // bounding cylinder
+    // and get_z_limits to compute a bounding cylinder.
-    Voxel { id: String },
+    Voxel {
-    Box { radius: f32, z_min: f32, z_max: f32 },
+        id: String,
+    },
+    /// Capsule prism with line segment from p0 to p1
+    CapsulePrism {
+        p0: Vec2<f32>,
+        p1: Vec2<f32>,
+        radius: f32,
+        z_min: f32,
+        z_max: f32,
+    },
     Point,
 }
 
 impl Collider {
-    pub fn get_radius(&self) -> f32 {
+    pub fn bounding_radius(&self) -> f32 {
         match self {
             Collider::Voxel { .. } => 1.0,
-            Collider::Box { radius, .. } => *radius,
+            Collider::CapsulePrism { radius, p0, p1, .. } => {
+                let a = p0.distance(*p1);
+                a / 2.0 + *radius
+            },
             Collider::Point => 0.0,
         }
     }
@@ -123,7 +140,7 @@ impl Collider {
     pub fn get_z_limits(&self, modifier: f32) -> (f32, f32) {
         match self {
             Collider::Voxel { .. } => (0.0, 1.0),
-            Collider::Box { z_min, z_max, .. } => (*z_min * modifier, *z_max * modifier),
+            Collider::CapsulePrism { z_min, z_max, .. } => (*z_min * modifier, *z_max * modifier),
             Collider::Point => (0.0, 0.0),
         }
     }

common/src/states/basic_beam.rs

@@ -232,8 +232,9 @@ fn height_offset(body: &Body, look_dir: Dir) -> f32 {
 }
 
 pub fn beam_offsets(body: &Body, look_dir: Dir, ori: Vec3<f32>) -> Vec3<f32> {
-    let body_radius = body.radius();
+    let body_radius = body.min_radius();
     let body_offsets_z = height_offset(body, look_dir);
+
     Vec3::new(
         body_radius * ori.x * 1.1,
         body_radius * ori.y * 1.1,

common/src/states/charged_melee.rs

@@ -196,7 +196,7 @@ impl CharacterBehavior for Data {
                             Outcome::GroundSlam {
                                 pos: data.pos.0
                                     + *data.ori.look_dir()
-                                        * (data.body.radius() + self.static_data.range),
+                                        * (data.body.max_radius() + self.static_data.range),
                             },
                         ));
                     }

common/src/states/utils.rs

@@ -641,7 +641,7 @@ pub fn handle_manipulate_loadout(
             // MAX_PICKUP_RANGE and the radius of the body
             let sprite_range_check = |pos: Vec3<f32>| {
                 (sprite_pos_f32 - pos).magnitude_squared()
-                    < (MAX_PICKUP_RANGE + data.body.radius()).powi(2)
+                    < (MAX_PICKUP_RANGE + data.body.max_radius()).powi(2)
             };
 
             // Checks if player's feet or head is near to sprite

common/src/util/find_dist.rs

@@ -39,7 +39,7 @@ impl Cylinder {
         char_state: Option<&crate::comp::CharacterState>,
     ) -> Self {
         let scale = scale.map_or(1.0, |s| s.0);
-        let radius = collider.as_ref().map_or(0.5, |c| c.get_radius()) * scale;
+        let radius = collider.as_ref().map_or(0.5, |c| c.bounding_radius()) * scale;
         let z_limit_modifier = char_state
             .filter(|char_state| char_state.is_dodge())
             .map_or(1.0, |_| 0.5)

common/systems/src/beam.rs

@@ -82,10 +82,10 @@ impl<'a> System<'a> for Sys {
             &beam_segments,
         )
             .par_join()
-            .fold(|| (Vec::new(), Vec::new(), Vec::new()),
+            .fold(
+                || (Vec::new(), Vec::new(), Vec::new()),
                 |(mut server_events, mut add_hit_entities, mut outcomes),
-            (entity, pos, ori, beam_segment)|
+                 (entity, pos, ori, beam_segment)| {
-        {
                     let creation_time = match beam_segment.creation {
                         Some(time) => time,
                         // Skip newly created beam segments
@@ -93,9 +93,9 @@ impl<'a> System<'a> for Sys {
                     };
                     let end_time = creation_time + beam_segment.duration.as_secs_f64();
 
-            let beam_owner = beam_segment
+                    let beam_owner = beam_segment.owner.and_then(|uid| {
-                .owner
+                        read_data.uid_allocator.retrieve_entity_internal(uid.into())
-                .and_then(|uid| read_data.uid_allocator.retrieve_entity_internal(uid.into()));
+                    });
 
                     let mut rng = thread_rng();
                     if rng.gen_bool(0.005) {
@@ -120,7 +120,8 @@ impl<'a> System<'a> for Sys {
                     let time_since_creation = (time - creation_time) as f32;
                     let frame_start_dist =
                         (beam_segment.speed * (time_since_creation - frame_time)).max(0.0);
-            let frame_end_dist = (beam_segment.speed * time_since_creation).max(frame_start_dist);
+                    let frame_end_dist =
+                        (beam_segment.speed * time_since_creation).max(frame_start_dist);
 
                     // Group to ignore collisions with
                     // Might make this more nuanced if beams are used for non damage effects
@@ -156,21 +157,36 @@ impl<'a> System<'a> for Sys {
 
                         // Scales
                         let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
-                let rad_b = body_b.radius() * scale_b;
+                        let rad_b = body_b.max_radius() * scale_b;
                         let height_b = body_b.height() * scale_b;
 
                         // Check if it is a hit
-                let hit = entity != target && !health_b.is_dead
+                        // TODO: use Capsule Prism instead of cylinder
-                    // Collision shapes
+                        let hit = entity != target
-                    && sphere_wedge_cylinder_collision(pos.0, frame_start_dist, frame_end_dist, *ori.look_dir(), beam_segment.angle, pos_b.0, rad_b, height_b);
+                            && !health_b.is_dead
+                            && sphere_wedge_cylinder_collision(
+                                pos.0,
+                                frame_start_dist,
+                                frame_end_dist,
+                                *ori.look_dir(),
+                                beam_segment.angle,
+                                pos_b.0,
+                                rad_b,
+                                height_b,
+                            );
 
-                // Finally, ensure that a hit has actually occurred by performing a raycast. We do this last because
+                        // Finally, ensure that a hit has actually occurred by performing a raycast.
-                // it's likely to be the most expensive operation.
+                        // We do this last because it's likely to be the
+                        // most expensive operation.
                         let tgt_dist = pos.0.distance(pos_b.0);
-                let hit = hit && read_data.terrain
+                        let hit = hit
+                            && read_data
+                                .terrain
                                 .ray(pos.0, pos.0 + *ori.look_dir() * (tgt_dist + 1.0))
                                 .until(|b| b.is_filled())
-                    .cast().0 >= tgt_dist;
+                                .cast()
+                                .0
+                                >= tgt_dist;
 
                         if hit {
                             // See if entities are in the same group
@@ -190,14 +206,14 @@ impl<'a> System<'a> for Sys {
                             }
 
                             let attacker_info =
-                        beam_owner
+                                beam_owner.zip(beam_segment.owner).map(|(entity, uid)| {
-                            .zip(beam_segment.owner)
+                                    AttackerInfo {
-                            .map(|(entity, uid)| AttackerInfo {
                                         entity,
                                         uid,
                                         energy: read_data.energies.get(entity),
                                         combo: read_data.combos.get(entity),
                                         inventory: read_data.inventories.get(entity),
+                                    }
                                 });
 
                             let target_info = TargetInfo {
@@ -211,7 +227,6 @@ impl<'a> System<'a> for Sys {
                                 char_state: read_data.character_states.get(target),
                             };
 
-
                             // PvP check
                             let may_harm = combat::may_harm(
                                 &read_data.alignments,
@@ -242,14 +257,18 @@ impl<'a> System<'a> for Sys {
                         }
                     });
                     (server_events, add_hit_entities, outcomes)
-        }).reduce(|| (Vec::new(), Vec::new(), Vec::new()),
+                },
+            )
+            .reduce(
+                || (Vec::new(), Vec::new(), Vec::new()),
                 |(mut events_a, mut hit_entities_a, mut outcomes_a),
                  (mut events_b, mut hit_entities_b, mut outcomes_b)| {
                     events_a.append(&mut events_b);
                     hit_entities_a.append(&mut hit_entities_b);
                     outcomes_a.append(&mut outcomes_b);
                     (events_a, hit_entities_a, outcomes_a)
-            });
+                },
+            );
         job.cpu_stats.measure(ParMode::Single);
         outcomes.append(&mut new_outcomes);
 

common/systems/src/melee.rs

@@ -80,7 +80,8 @@ impl<'a> System<'a> for Sys {
             // Scales
             let eye_pos = pos.0 + Vec3::unit_z() * body.eye_height();
             let scale = read_data.scales.get(attacker).map_or(1.0, |s| s.0);
-            let rad = body.radius() * scale;
+            // TODO: use Capsule Prisms instead of Cylinders
+            let rad = body.max_radius() * scale;
 
             // Mine blocks broken by the attack
             if let Some((block_pos, tool)) = melee_attack.break_block {
@@ -115,7 +116,7 @@ impl<'a> System<'a> for Sys {
 
                 // Scales
                 let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
-                let rad_b = body_b.radius() * scale_b;
+                let rad_b = body_b.max_radius() * scale_b;
 
                 // Check if entity is dodging
                 let target_dodging = read_data

common/systems/src/shockwave.rs

@@ -152,7 +152,8 @@ impl<'a> System<'a> for Sys {
 
                 // Scales
                 let scale_b = read_data.scales.get(target).map_or(1.0, |s| s.0);
-                let rad_b = body_b.radius() * scale_b;
+                // TODO: use Capsule Prism instead of Cylinder
+                let rad_b = body_b.max_radius() * scale_b;
 
                 // Angle checks
                 let pos_b_ground = Vec3::new(pos_b.0.x, pos_b.0.y, pos.0.z);

server/src/events/entity_manipulation.rs

@@ -715,8 +715,8 @@ pub fn handle_explosion(server: &Server, pos: Vec3<f32>, explosion: Explosion, o
         cyl_body: Body,
     ) -> f32 {
         // 2d check
-        let horiz_dist =
+        let horiz_dist = Vec2::<f32>::from(sphere_pos - cyl_pos).distance(Vec2::default())
-            Vec2::<f32>::from(sphere_pos - cyl_pos).distance(Vec2::default()) - cyl_body.radius();
+            - cyl_body.max_radius();
         // z check
         let half_body_height = cyl_body.height() / 2.0;
         let vert_distance =

server/src/state_ext.rs

@@ -203,11 +203,7 @@ impl StateExt for State {
                 comp::Body::Ship(ship) => comp::Collider::Voxel {
                     id: ship.manifest_entry().to_string(),
                 },
-                _ => comp::Collider::Box {
+                _ => capsule(&body),
-                    radius: body.radius(),
-                    z_min: 0.0,
-                    z_max: body.height(),
-                },
             })
             .with(comp::Controller::default())
             .with(body)
@@ -239,11 +235,7 @@ impl StateExt for State {
             .with(comp::Ori::default())
             .with(body.mass())
             .with(body.density())
-            .with(comp::Collider::Box {
+            .with(capsule(&body))
-                radius: body.radius(),
-                z_min: 0.0,
-                z_max: body.height(),
-            })
             .with(body)
     }
 
@@ -305,11 +297,7 @@ impl StateExt for State {
         if projectile.is_point {
             projectile_base = projectile_base.with(comp::Collider::Point)
         } else {
-            projectile_base = projectile_base.with(comp::Collider::Box {
+            projectile_base = projectile_base.with(capsule(&body))
-                radius: body.radius(),
-                z_min: 0.0,
-                z_max: body.height(),
-            })
         }
 
         projectile_base.with(projectile).with(body)
@@ -382,11 +370,7 @@ impl StateExt for State {
             .with(pos)
             .with(comp::Vel(Vec3::zero()))
             .with(comp::Ori::default())
-            .with(comp::Collider::Box {
+            .with(capsule(&object.into()))
-                radius: comp::Body::Object(object).radius(),
-                z_min: 0.0,
-                z_max: comp::Body::Object(object).height()
-            })
             .with(comp::Body::Object(object))
             .with(comp::Mass(10.0))
             // .with(comp::Sticky)
@@ -458,7 +442,9 @@ impl StateExt for State {
             self.write_component_ignore_entity_dead(entity, comp::Pos(spawn_point));
             self.write_component_ignore_entity_dead(entity, comp::Vel(Vec3::zero()));
             self.write_component_ignore_entity_dead(entity, comp::Ori::default());
-            self.write_component_ignore_entity_dead(entity, comp::Collider::Box {
+            self.write_component_ignore_entity_dead(entity, comp::Collider::CapsulePrism {
+                p0: Vec2::zero(),
+                p1: Vec2::zero(),
                 radius: 0.4,
                 z_min: 0.0,
                 z_max: 1.75,
@@ -500,11 +486,7 @@ impl StateExt for State {
             // and we call nothing that can delete it in any of the subsequent
             // commands, so we can assume that all of these calls succeed,
             // justifying ignoring the result of insertion.
-            self.write_component_ignore_entity_dead(entity, comp::Collider::Box {
+            self.write_component_ignore_entity_dead(entity, capsule(&body));
-                radius: body.radius(),
-                z_min: 0.0,
-                z_max: body.height(),
-            });
             self.write_component_ignore_entity_dead(entity, body);
             self.write_component_ignore_entity_dead(entity, body.mass());
             self.write_component_ignore_entity_dead(entity, body.density());
@@ -887,3 +869,15 @@ fn send_to_group(g: &comp::Group, ecs: &specs::World, msg: &comp::ChatMsg) {
         }
     }
 }
+
+fn capsule(body: &comp::Body) -> comp::Collider {
+    let (p0, p1, radius) = body.sausage();
+
+    comp::Collider::CapsulePrism {
+        p0,
+        p1,
+        radius,
+        z_min: 0.0,
+        z_max: body.height(),
+    }
+}

server/src/sys/agent.rs

@@ -1783,9 +1783,9 @@ impl<'a> AgentData<'a> {
         // Wield the weapon as running towards the target
         controller.actions.push(ControlAction::Wield);
 
-        let min_attack_dist = (self.body.map_or(0.5, |b| b.radius()) + DEFAULT_ATTACK_RANGE)
+        let min_attack_dist = (self.body.map_or(0.5, |b| b.max_radius()) + DEFAULT_ATTACK_RANGE)
             * self.scale
-            + tgt_data.body.map_or(0.5, |b| b.radius()) * tgt_data.scale.map_or(1.0, |s| s.0);
+            + tgt_data.body.map_or(0.5, |b| b.max_radius()) * tgt_data.scale.map_or(1.0, |s| s.0);
         let dist_sqrd = self.pos.0.distance_squared(tgt_data.pos.0);
         let angle = self
             .ori
@@ -3676,7 +3676,7 @@ impl<'a> AgentData<'a> {
     ) {
         const BIRD_ATTACK_RANGE: f32 = 4.0;
         const BIRD_CHARGE_DISTANCE: f32 = 15.0;
-        let bird_attack_distance = self.body.map_or(0.0, |b| b.radius()) + BIRD_ATTACK_RANGE;
+        let bird_attack_distance = self.body.map_or(0.0, |b| b.max_radius()) + BIRD_ATTACK_RANGE;
         // Increase action timer
         agent.action_state.timer += read_data.dt.0;
         // If higher than 2 blocks
@@ -3748,7 +3748,7 @@ impl<'a> AgentData<'a> {
         const MINOTAUR_ATTACK_RANGE: f32 = 5.0;
         const MINOTAUR_CHARGE_DISTANCE: f32 = 15.0;
         let minotaur_attack_distance =
-            self.body.map_or(0.0, |b| b.radius()) + MINOTAUR_ATTACK_RANGE;
+            self.body.map_or(0.0, |b| b.max_radius()) + MINOTAUR_ATTACK_RANGE;
         let health_fraction = self.health.map_or(1.0, |h| h.fraction());
         // Sets action counter at start of combat
         if agent.action_state.counter < MINOTAUR_FRENZY_THRESHOLD
@@ -3815,7 +3815,7 @@ impl<'a> AgentData<'a> {
         const GOLEM_LASER_RANGE: f32 = 30.0;
         const GOLEM_LONG_RANGE: f32 = 50.0;
         const GOLEM_TARGET_SPEED: f32 = 8.0;
-        let golem_melee_range = self.body.map_or(0.0, |b| b.radius()) + GOLEM_MELEE_RANGE;
+        let golem_melee_range = self.body.map_or(0.0, |b| b.max_radius()) + GOLEM_MELEE_RANGE;
         // Fraction of health, used for activation of shockwave
         // If golem don't have health for some reason, assume it's full
         let health_fraction = self.health.map_or(1.0, |h| h.fraction());

voxygen/src/render/pipelines/debug.rs

@@ -36,6 +36,8 @@ pub struct Locals {
     /// by the shader
     pub pos: [f32; 4],
     pub color: [f32; 4],
+    /// quaternion as [x, y, z, w]
+    pub ori: [f32; 4],
 }
 
 pub type BoundLocals = Bound<Consts<Locals>>;

voxygen/src/scene/debug.rs

@@ -9,12 +9,21 @@ use vek::*;
 #[derive(Debug)]
 pub enum DebugShape {
     Line([Vec3<f32>; 2]),
-    Cylinder { radius: f32, height: f32 },
+    Cylinder {
+        radius: f32,
+        height: f32,
+    },
+    CapsulePrism {
+        p0: Vec2<f32>,
+        p1: Vec2<f32>,
+        radius: f32,
+        height: f32,
+    },
 }
 
 impl DebugShape {
     pub fn mesh(&self) -> Mesh<DebugVertex> {
-        use core::f32::consts::PI;
+        use core::f32::consts::{PI, TAU};
         let mut mesh = Mesh::new();
         let tri = |x: Vec3<f32>, y: Vec3<f32>, z: Vec3<f32>| {
             Tri::<DebugVertex>::new(x.into(), y.into(), z.into())
@@ -22,28 +31,115 @@ impl DebugShape {
         let quad = |x: Vec3<f32>, y: Vec3<f32>, z: Vec3<f32>, w: Vec3<f32>| {
             Quad::<DebugVertex>::new(x.into(), y.into(), z.into(), w.into())
         };
+
         match self {
             DebugShape::Line([a, b]) => {
                 let h = Vec3::new(0.0, 1.0, 0.0);
                 mesh.push_quad(quad(*a, a + h, b + h, *b));
             },
             DebugShape::Cylinder { radius, height } => {
-                const SUBDIVISIONS: usize = 16;
+                const SUBDIVISIONS: u8 = 16;
                 for i in 0..SUBDIVISIONS {
-                    let angle = |j: usize| (j as f32 / SUBDIVISIONS as f32) * 2.0 * PI;
+                    // dot on circle edge
-                    let a = Vec3::zero();
+                    let to = |n: u8| {
-                    let b = Vec3::new(radius * angle(i).cos(), radius * angle(i).sin(), 0.0);
+                        let angle = TAU * f32::from(n) / f32::from(SUBDIVISIONS);
-                    let c = Vec3::new(
+
-                        radius * angle(i + 1).cos(),
+                        Vec3::new(radius * angle.cos(), radius * angle.sin(), 0.0)
-                        radius * angle(i + 1).sin(),
+                    };
-                        0.0,
+
-                    );
+                    let origin = Vec3::zero();
+                    let r0 = to(i);
+                    let r1 = to(i + 1);
+
                     let h = Vec3::new(0.0, 0.0, *height);
-                    mesh.push_tri(tri(c, b, a));
+
-                    mesh.push_quad(quad(b, c, c + h, b + h));
+                    // Draw bottom sector
-                    mesh.push_tri(tri(a + h, b + h, c + h));
+                    mesh.push_tri(tri(r1, r0, origin));
+                    // Draw face
+                    mesh.push_quad(quad(r0, r1, r1 + h, r0 + h));
+                    // Draw top sector
+                    mesh.push_tri(tri(origin + h, r0 + h, r1 + h));
                 }
             },
+            DebugShape::CapsulePrism {
+                p0,
+                p1,
+                radius,
+                height,
+            } => {
+                // We split circle in two parts
+                const HALF_SECTORS: u8 = 8;
+                const TOTAL: u8 = HALF_SECTORS * 2;
+
+                let offset = (p0 - p1).angle_between(Vec2::new(0.0, 1.0));
+                let h = Vec3::new(0.0, 0.0, *height);
+
+                let draw_cylinder_sector =
+                    |mesh: &mut Mesh<DebugVertex>, origin: Vec3<f32>, from: u8, to: u8| {
+                        for i in from..to {
+                            // dot on circle edge
+                            let to = |n: u8| {
+                                let angle = offset + TAU * f32::from(n) / f32::from(TOTAL);
+                                let (x, y) = (radius * angle.cos(), radius * angle.sin());
+                                let to_edge = Vec3::new(x, y, 0.0);
+
+                                origin + to_edge
+                            };
+
+                            let r0 = to(i);
+                            let r1 = to(i + 1);
+
+                            // Draw bottom sector
+                            mesh.push_tri(tri(r1, r0, origin));
+                            // Draw face
+                            mesh.push_quad(quad(r0, r1, r1 + h, r0 + h));
+                            // Draw top sector
+                            mesh.push_tri(tri(origin + h, r0 + h, r1 + h));
+                        }
+                    };
+
+                let p0 = Vec3::new(p0.x, p0.y, 0.0);
+                let p1 = Vec3::new(p1.x, p1.y, 0.0);
+                // 1) Draw first half-cylinder
+                draw_cylinder_sector(&mut mesh, p0, 0, HALF_SECTORS);
+
+                // 2) Draw cuboid in-between
+                // get main line segment
+                let a = p1 - p0;
+                // normalize
+                let a = a / a.magnitude();
+                // stretch to radius
+                let a = a * *radius;
+                // rotate to 90 degrees to get needed shift
+                let ortoghonal = Quaternion::rotation_z(PI / 2.0);
+                let shift = ortoghonal * a;
+
+                // bottom points
+                let a0 = p0 + shift;
+                let b0 = p0 - shift;
+                let c0 = p1 - shift;
+                let d0 = p1 + shift;
+
+                // top points
+                let a1 = a0 + h;
+                let b1 = b0 + h;
+                let c1 = c0 + h;
+                let d1 = d0 + h;
+
+                // Bottom
+                mesh.push_quad(quad(d0, c0, b0, a0));
+
+                // Faces
+                // (we need only two of them, because other two are inside)
+                mesh.push_quad(quad(d0, a0, a1, d1));
+                mesh.push_quad(quad(b0, c0, c1, b1));
+
+                // Top
+                mesh.push_quad(quad(a1, b1, c1, d1));
+
+                // 3) Draw second half-cylinder
+                draw_cylinder_sector(&mut mesh, p1, HALF_SECTORS, TOTAL);
+            },
         }
         mesh
     }
@@ -55,7 +151,8 @@ pub struct DebugShapeId(pub u64);
 pub struct Debug {
     next_shape_id: DebugShapeId,
     pending_shapes: HashMap<DebugShapeId, DebugShape>,
-    pending_locals: HashMap<DebugShapeId, ([f32; 4], [f32; 4])>,
+    #[allow(clippy::type_complexity)]
+    pending_locals: HashMap<DebugShapeId, ([f32; 4], [f32; 4], [f32; 4])>,
     pending_deletes: HashSet<DebugShapeId>,
     models: HashMap<DebugShapeId, (Model<DebugVertex>, Bound<Consts<DebugLocals>>)>,
 }
@@ -78,8 +175,8 @@ impl Debug {
         id
     }
 
-    pub fn set_pos_and_color(&mut self, id: DebugShapeId, pos: [f32; 4], color: [f32; 4]) {
+    pub fn set_context(&mut self, id: DebugShapeId, pos: [f32; 4], color: [f32; 4], ori: [f32; 4]) {
-        self.pending_locals.insert(id, (pos, color));
+        self.pending_locals.insert(id, (pos, color, ori));
     }
 
     pub fn remove_shape(&mut self, id: DebugShapeId) { self.pending_deletes.insert(id); }
@@ -90,6 +187,7 @@ impl Debug {
                 let locals = renderer.create_debug_bound_locals(&[DebugLocals {
                     pos: [0.0; 4],
                     color: [1.0, 0.0, 0.0, 1.0],
+                    ori: [0.0, 0.0, 0.0, 1.0],
                 }]);
                 self.models.insert(id, (model, locals));
             } else {
@@ -99,12 +197,13 @@ impl Debug {
                 );
             }
         }
-        for (id, (pos, color)) in self.pending_locals.drain() {
+        for (id, (pos, color, ori)) in self.pending_locals.drain() {
             if let Some((_, locals)) = self.models.get_mut(&id) {
                 let lc = srgba_to_linear(color.into());
                 let new_locals = [DebugLocals {
                     pos,
                     color: [lc.r, lc.g, lc.b, lc.a],
+                    ori,
                 }];
                 renderer.update_consts(locals, &new_locals);
             } else {

voxygen/src/scene/mod.rs

@@ -1152,19 +1152,30 @@ impl Scene {
         if settings.interface.toggle_hitboxes {
             let positions = ecs.read_component::<comp::Pos>();
             let colliders = ecs.read_component::<comp::Collider>();
+            let orientations = ecs.read_component::<comp::Ori>();
             let groups = ecs.read_component::<comp::Group>();
-            for (entity, pos, collider, group) in
+            for (entity, pos, collider, ori, group) in (
-                (&ecs.entities(), &positions, &colliders, groups.maybe()).join()
+                &ecs.entities(),
+                &positions,
+                &colliders,
+                &orientations,
+                groups.maybe(),
+            )
+                .join()
             {
-                if let comp::Collider::Box {
+                match collider {
+                    comp::Collider::CapsulePrism {
+                        p0,
+                        p1,
                         radius,
                         z_min,
                         z_max,
-                } = collider
+                    } => {
-                {
                         current_entities.insert(entity);
                         let shape_id = hitboxes.entry(entity).or_insert_with(|| {
-                        self.debug.add_shape(DebugShape::Cylinder {
+                            self.debug.add_shape(DebugShape::CapsulePrism {
+                                p0: *p0,
+                                p1: *p1,
                                 radius: *radius,
                                 height: *z_max - *z_min,
                             })
@@ -1177,7 +1188,13 @@ impl Scene {
                         } else {
                             [0.0, 1.0, 0.0, 0.5]
                         };
-                    self.debug.set_pos_and_color(*shape_id, hb_pos, color);
+                        let ori = ori.to_quat();
+                        let hb_ori = [ori.x, ori.y, ori.z, ori.w];
+                        self.debug.set_context(*shape_id, hb_pos, color, hb_ori);
+                    },
+                    comp::Collider::Voxel { .. } | comp::Collider::Point => {
+                        // ignore terrain-like or point-hitboxes
+                    },
                 }
             }
         }

voxygen/src/scene/particle.rs

@@ -198,7 +198,7 @@ impl ParticleMgr {
                                     0.0,
                                 )
                                 .normalized()
-                                    * (body.radius() + 4.0)
+                                    * (body.max_radius() + 4.0)
                                 + Vec3::unit_z() * (body.height() + 2.0) * rng.gen::<f32>();
 
                             Particle::new_directed(
@@ -688,7 +688,7 @@ impl ParticleMgr {
                                     0.0,
                                 )
                                 .normalized()
-                                    * (body.radius() + 2.0)
+                                    * (body.max_radius() + 2.0)
                                 + Vec3::unit_z() * body.height() * rng.gen::<f32>();
 
                             let (start_pos, end_pos) =
@@ -720,8 +720,8 @@ impl ParticleMgr {
                                 || {
                                     let start_pos = pos.0
                                         + Vec3::new(
-                                            body.radius(),
+                                            body.max_radius(),
-                                            body.radius(),
+                                            body.max_radius(),
                                             body.height() / 2.0,
                                         )
                                         .map(|d| d * rng.gen_range(-1.0..1.0));
@@ -1021,7 +1021,11 @@ impl ParticleMgr {
                                 + usize::from(self.scheduler.heartbeats(Duration::from_millis(15))),
                             || {
                                 let start_pos = pos.0
-                                    + Vec3::new(body.radius(), body.radius(), body.height() / 2.0)
+                                    + Vec3::new(
+                                        body.max_radius(),
+                                        body.max_radius(),
+                                        body.height() / 2.0,
+                                    )
                                     .map(|d| d * rng.gen_range(-1.0..1.0));
                                 let end_pos = start_pos
                                     + Vec3::unit_z() * body.height()

voxygen/src/session/mod.rs

@@ -1612,12 +1612,13 @@ fn under_cursor(
         .filter_map(|(e, p, s, b, i)| {
             const RADIUS_SCALE: f32 = 3.0;
             // TODO: use collider radius instead of body radius?
-            let radius = s.map_or(1.0, |s| s.0) * b.radius() * RADIUS_SCALE;
+            let radius = s.map_or(1.0, |s| s.0) * b.max_radius() * RADIUS_SCALE;
             // Move position up from the feet
             let pos = Vec3::new(p.0.x, p.0.y, p.0.z + radius);
             // Distance squared from camera to the entity
             let dist_sqr = pos.distance_squared(cam_pos);
-            // We only care about interacting with entities that contain items, or are not inanimate (to trade with)
+            // We only care about interacting with entities that contain items,
+            // or are not inanimate (to trade with)
             if i.is_some() || !matches!(b, comp::Body::Object(_)) {
                 Some((e, pos, radius, dist_sqr))
             } else {

voxygen/src/ui/egui/mod.rs

@@ -59,9 +59,10 @@ impl EguiState {
                 scene.debug.remove_shape(DebugShapeId(*debug_shape_id));
             },
             DebugShapeAction::SetPosAndColor { id, pos, color } => {
+                let identity_ori = [0.0, 0.0, 0.0, 1.0];
                 scene
                     .debug
-                    .set_pos_and_color(DebugShapeId(*id), *pos, *color);
+                    .set_context(DebugShapeId(*id), *pos, *color, identity_ori);
             },
         })
     }