Culling Offscreen Sprites

[ecumene]

I'm looking for a generic way to cull some off screen sprites. My problem is that I have a really large environment with lots of sprites but they're all rendering at once even if they're off screen. What I want is a basic component that when attached to an entity they do not render off screen.

I tried to adapt the code from this issue, but it seems to have drifted a bit and I'm not sure how to implement it.

Here it is:

pub fn camera_view_check(
    mut commands: Commands,
    time: Res<Time>,
    mut camera_query: Query<(&Camera, &Transform, &OrthographicProjection)>,
    mut draw_query: Query<(Entity, &mut Draw)>,
    draw_transform_query: Query<(&Draw, &Transform)>,
) {
    for (camera, camera_transform, ortho_proj) in &mut camera_query.iter() {
        if time.seconds_since_startup() > 2.0 {
            for (entity, mut draw) in &mut draw_query.iter() {
                if let Ok(transform) = draw_transform_query.get(entity) {
                    let visual_check = camera.projection_matrix.transform_point3(Vec3::from(
                        camera_transform.value.w_axis().truncate()
                            - transform.value.w_axis().truncate(),
                    ));
                    match ortho_proj.window_origin {
                        WindowOrigin::Center => {
                            if visual_check[0].abs() > 1.0 || visual_check[1].abs() > 1.0 {
                                draw.is_visible = false;
                            }
                        }
                        WindowOrigin::BottomLeft => {}
                    }
                }
            }
        }
    }
}

Here's the errors in order from top to bottom:

1. the trait bound bevy_ecs::core::query::FetchMut<bevy::prelude::Draw>: bevy::ecs::ReadOnlyFetch is not satisfied
   required because of the requirements on the impl of bevy::ecs::ReadOnlyFetch for (bevy_ecs::core::query::EntityFetch, bevy_ecs::core::query::FetchMut<bevy::prelude::Draw>)

2. no field projection_matrix on type ...Camera unknown field
   This one I think I know how to fix. Do I replace it with ortho_proj.get_projection_matrix()?

3. no field value on type (&bevy::prelude::Draw, &bevy::prelude::Transform)
   How do I get the w_axis() of a transform?

4. no field is_visible on type bevy::prelude::Mut<'_, bevy::prelude::Draw> unknown field
   How has this changed?

[CleanCut]

@ecumene It looks like you're experiencing a bunch of issues. I might have some answers. If your project is open source, providing a link to it would be helpful.

1. The error from mutable + immutable Draw components in different queries should by fixed as a side effect of changing mut draw_query: Query<(Entity, &mut Draw)>, to something like mut visible_query: Query<(Entity, &mut Visible)>, (see item 4 for more info).
2. Yes, I believe so.
3. I'm not sure what you're looking for here, so here's some shots in the dark:

• Transform's fields are translation, rotation, and scale.
• Transform.rotation is a glam.f32.Quat, which has a w value.
• w_axis occurs only in this file -- perhaps face_toward is related?

4. is_visible moved to a separate Visible component. You should be able to get that component with a query and set var.is_visible = false;

[ristew]

I've adapted this to a naive bounding box implementation which greatly improves performance for ~50000 sprites.

pub fn camera_view_check(
    mut camera_query: Query<(&Camera, &Transform, &OrthographicProjection)>,
    mut visible_query: Query<(&Transform, &mut Visible)>,
) {
    for (camera, camera_transform, ortho_proj) in &mut camera_query.iter() {
        let left_bound = ortho_proj.left + camera_transform.translation.x - TILE_SIZE;
        let right_bound = ortho_proj.right + camera_transform.translation.x + TILE_SIZE;
        let bottom_bound = ortho_proj.bottom + camera_transform.translation.y - TILE_SIZE;
        let top_bound = ortho_proj.top + camera_transform.translation.y + TILE_SIZE;
        for (transform, mut visible) in visible_query.iter_mut() {
            if transform.translation.x < left_bound
                || transform.translation.x > right_bound
                || transform.translation.y < bottom_bound
                || transform.translation.y > top_bound {
                    visible.is_visible = false;
                } else {
                    visible.is_visible = true;
                }
        }
    }
}

[johanhelsing]

Thanks!

I made a version that accounts for projection scaling as well:

pub fn camera_view_check(
    camera_query: Query<(&Transform, &OrthographicProjection), With<Camera>>,
    mut visible_query: Query<(&Transform, &mut Visible)>,
) {
    const MAX_TILE_SIZE: f32 = 50.;
    for (camera_transform, projection) in camera_query.iter() {
        let camera_pos = camera_transform.translation;
        let scale = projection.scale;
        let left = projection.left * scale + camera_pos.x - MAX_TILE_SIZE;
        let right = projection.right * scale + camera_pos.x + MAX_TILE_SIZE;
        let bottom = projection.bottom * scale + camera_pos.y - MAX_TILE_SIZE;
        let top = projection.top * scale + camera_pos.y + MAX_TILE_SIZE;

        for (transform, mut visible) in visible_query.iter_mut() {
            let pos = transform.translation;
            visible.is_visible =
                pos.x > left && pos.x < right &&
                pos.y > bottom && pos.y < top;
        }
    }
}

[alice-i-cecile]

#1492 handles this nicely, and seems likely to be merged shortly :) 3D frustrum culling is likely to follow soon, after a series of PRs to establish the foundations needed.