collider point collection

src/game.rs

@@ -2,8 +2,6 @@ use crate::{debug, game_setup};
 use bevy::prelude::*;
 use bevy_ecs_ldtk::{LdtkWorldBundle, LevelSelection};
 
-use self::darkness::SpotLight2D;
-
 pub mod camera;
 pub mod darkness;
 pub mod ldtk;
@@ -26,15 +24,4 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
         ldtk_handle: assets.load("levels/world.ldtk"),
         ..default()
     });
-
-    commands.spawn((
-        Name::new("Spot light"),
-        SpatialBundle::from_transform(Transform::from_xyz(32.0, 31.0, 0.0).with_rotation(
-            Quat::from_euler(EulerRot::YXZ, 0.0, 0.0, f32::to_radians(-90.0)),
-        )),
-        SpotLight2D {
-            radius: 100.0,
-            angle: 1.0,
-        },
-    ));
 }

src/game/darkness.rs

@@ -8,8 +8,11 @@ use bevy::{
     sprite::{Material2dPlugin, Mesh2dHandle},
 };
 use bevy_ecs_ldtk::{LdtkLevel, LevelEvent};
+use bevy_prototype_debug_lines::DebugLines;
 use bevy_rapier2d::prelude::{Collider, QueryFilter, RapierContext};
 
+use crate::debug::DebugMode;
+
 mod material;
 
 pub use material::*;
@@ -174,8 +177,12 @@ fn add_to_level(
 fn prepare_lights(
     mut materials: ResMut<Assets<DarknessMaterial>>,
     mut images: ResMut<Assets<Image>>,
+    mut debug_draw: ResMut<DebugLines>,
+    debug_mode: Res<DebugMode>,
     rapier_context: Res<RapierContext>,
     visibility_blocker_query: Query<&VisibilityBlocker>,
+    transform_query: Query<&GlobalTransform>,
+    collider_query: Query<&Collider>,
     material_query: Query<&Handle<DarknessMaterial>>,
     point_light_query: Query<(&GlobalTransform, &PointLight2D)>,
     spot_light_query: Query<(&GlobalTransform, &SpotLight2D)>,
@@ -201,14 +208,43 @@ fn prepare_lights(
             .iter()
             .enumerate()
             .for_each(|(i, (transform, light))| {
-                get_light_geometry(&rapier_context, &visibility_blocker_query, *light);
+                let rect = light.aabb();
+                let polygon = get_light_geometry(
+                    &rapier_context,
+                    &visibility_blocker_query,
+                    &transform_query,
+                    &collider_query,
+                    Rect::from_corners(
+                        rect.min + transform.translation().truncate(),
+                        rect.max + transform.translation().truncate(),
+                    ),
+                );
+
+                if debug_mode.enabled {
+                    for (i, arr) in polygon.iter().as_slice().windows(2).enumerate() {
+                        let p1 = arr[0];
+                        let p2 = arr[1];
+                        let t1 = i as f32 / polygon.len() as f32;
+                        let t2 = (i + 1) as f32 / polygon.len() as f32;
+                        let color1 = Color::rgba(1.0 - t1, t1, 0.0, 1.0);
+                        let color2 = Color::rgba(1.0 - t2, t2, 0.0, 1.0);
+                        debug_draw.line_gradient(
+                            p1.extend(0.0),
+                            p2.extend(0.0),
+                            0.0,
+                            color1,
+                            color2,
+                        );
+                    }
+                }
+
                 material.point_lights[i] = GpuPointLight2D {
                     position: transform.translation().truncate(),
                     radius: light.radius,
                 };
                 for x in 0..SHADOWMAP_RESOLUTION {
                     let offset = (i * SHADOWMAP_RESOLUTION + x) * 4;
-                    let distance = x as f32 / SHADOWMAP_RESOLUTION as f32 * light.radius;
+                    let distance = light.radius;
                     let distance_bytes = bytes_of(&distance);
                     shadowmap.data[offset + 0] = distance_bytes[0];
                     shadowmap.data[offset + 1] = distance_bytes[1];
@@ -247,17 +283,89 @@ fn prepare_lights(
 fn get_light_geometry(
     rapier_context: &Res<RapierContext>,
     visibility_blocker_query: &Query<&VisibilityBlocker>,
-    light: &impl LightAabb,
+    transform_query: &Query<&GlobalTransform>,
+    collider_query: &Query<&Collider>,
+    aabb: Rect,
 ) -> Vec<Vec2> {
-    let rect = light.aabb();
+    let mut points = vec![
-    let collider = Collider::cuboid(rect.half_size().x, rect.half_size().y);
+        Vec2::new(aabb.min.x, aabb.min.y),
+        Vec2::new(aabb.max.x, aabb.min.y),
+        Vec2::new(aabb.max.x, aabb.max.y),
+        Vec2::new(aabb.min.x, aabb.max.y),
+    ];
+
+    let collider = Collider::cuboid(aabb.half_size().x, aabb.half_size().y);
     let mut filter = QueryFilter::new().exclude_sensors();
     let predicate = |coll_entity| visibility_blocker_query.get(coll_entity).is_ok();
     filter.predicate = Some(&predicate);
-    let mut colls = vec![];
+
-    rapier_context.intersections_with_shape(rect.center(), 0.0, &collider, filter, |coll| {
+    rapier_context.intersections_with_shape(aabb.center(), 0.0, &collider, filter, |coll| {
-        colls.push(coll);
+        let transform = transform_query
+            .get(coll)
+            .expect("Collider should have GlobalTransform");
+        if let Ok(collider) = collider_query.get(coll) {
+            if let Some(cuboid) = collider.as_cuboid() {
+                let rect = Rect::from_center_half_size(
+                    transform.translation().truncate(),
+                    cuboid.half_extents(),
+                );
+                points.push(rect.min);
+                points.push(rect.max);
+                points.push(Vec2::new(rect.min.x, rect.max.y));
+                points.push(Vec2::new(rect.max.x, rect.min.y));
+            }
+        }
         true
     });
-    vec![]
+
+    let center = aabb.center();
+    points.sort_unstable_by(|a, b| {
+        f32::atan2(a.y - center.y, a.x - center.x)
+            .partial_cmp(&f32::atan2(b.y - center.y, b.x - center.x))
+            .unwrap()
+    });
+
+    // Build visibility polygon
+    let mut polygon: Vec<_> = vec![];
+    for point in points.drain(..) {
+        // We shoot 2 rays offset by this angle from the point.
+        const ANGLE_OFFSET: f32 = 0.0001;
+        offset_cast(
+            aabb.center(),
+            (point - aabb.center()).normalize_or_zero(),
+            aabb.size().max_element(),
+            true,
+            filter,
+            ANGLE_OFFSET,
+            &rapier_context,
+        )
+        .iter()
+        .for_each(|ray| polygon.push(aabb.center() + *ray));
+    }
+
+    polygon.push(*polygon.first().unwrap());
+    polygon
+}
+
+fn offset_cast(
+    ray_origin: Vec2,
+    ray_dir: Vec2,
+    max_toi: f32,
+    solid: bool,
+    filter: QueryFilter,
+    angle_offset: f32,
+    rapier_context: &Res<RapierContext>,
+) -> Vec<Vec2> {
+    let dir1 = Vec2::new((-angle_offset).cos(), (-angle_offset).sin()).rotate(ray_dir);
+    let dir2 = Vec2::new(angle_offset.cos(), angle_offset.sin()).rotate(ray_dir);
+    let ray1 = rapier_context.cast_ray(ray_origin, dir1, max_toi, solid, filter);
+    let ray2 = rapier_context.cast_ray(ray_origin, dir2, max_toi, solid, filter);
+    let toi1 = ray1.map_or(max_toi, |(_, toi)| toi);
+    let toi2 = ray2.map_or(max_toi, |(_, toi)| toi);
+
+    if (toi1 - toi2).abs() > toi1 * 0.1 {
+        vec![dir1 * toi1, dir2 * toi2]
+    } else {
+        vec![(dir1 * toi1 + dir2 * toi2) / 2.0]
+    }
 }