Post Update Functions

pub fn disable_tiled_entities_when_hidden(
    mut commands: Commands,
    q_rendereable_entities: Query<(Entity, &Visibility, &InheritedVisibility), (With<TiledCollidersSpawned>, Or<(With<TiledMapMarker>, With<TiledMapLayer>, With<TiledMapObject>)>)>
) {
    for (entity, visibility, inherited_visibility) in q_rendereable_entities {
        if
            visibility == Visibility::Visible ||
            visibility == Visibility::Inherited && inherited_visibility.get()
        {
            continue;
        }

        info!("disabled entity {}", entity);

        commands.entity(entity).insert((
            Disabled,
            DisabledByVisibility
        ));
    }
}

pub fn enable_tiled_entities(
    mut commands: Commands,
    q_rendereable_entities: Query<Entity, (With<DisabledByVisibility>, With<Disabled>, Or<(With<TiledMapMarker>, With<TiledMapLayer>, With<TiledMapObject>)>)>
) {
    info!("enabled all entities");
    for entity in q_rendereable_entities {
        commands.entity(entity).remove::<(
            Disabled,
            DisabledByVisibility
        )>();
    }
}

pub fn disable_tiled_colliders_when_parent_disabled(
    mut commands: Commands,
    q_colliders: Query<(Entity, &ChildOf), With<TiledColliderMarker>>,
    q_parents: Query<Entity, With<Disabled>>
) {
    for (entity, child_of) in q_colliders.iter() {
        if !q_parents.contains(child_of.0) {
            continue;
        };

        info!("disabled collider {}", entity);

        commands.entity(entity).insert((
            DisabledByParent,
            Disabled
        ));
    }
}

pub fn enable_tiled_colliders_when_parent_enabled(
    mut commands: Commands,
    q_colliders: Query<(Entity, &ChildOf), (With<DisabledByParent>, With<Disabled>, With<TiledColliderMarker>)>,
    q_parents: Query<Entity>
) {
    for (entity, child_of) in q_colliders.iter() {
        if !q_parents.contains(child_of.0) {
            continue;
        };

        info!("enabled collider {}", entity);

        commands.entity(entity).remove::<(
            DisabledByParent,
            Disabled
        )>();
    }
}

fn compute_grid_collision(
    mut commands: Commands,
    mut s_grid: Single<(&mut Grid<CardinalNeighborhood>, &GridTileSize, &TilemapAnchor)>,
    s_scan_collider: Single<&Collider, With<ScanCollider>>,
    q_colliders: Query<(Entity, &GlobalTransform, &Collider, &RigidBody), (Without<GridCollisionCalculated>, Without<TriggerCollider>)>,
) {
    if q_colliders.is_empty() {
        return;
    }

    info!("computed grid");

    let (grid, tile_size, anchor) = s_grid.deref_mut();

    let offset = anchor.as_offset(
        &TilemapSize::new(grid.width(), grid.height()),
        &TilemapGridSize::new(tile_size.0.x, tile_size.0.y),
        &TilemapTileSize::new(tile_size.0.x, tile_size.0.y),
        &TilemapType::Square,
    );

    let collider = s_scan_collider.into_inner();

    for (entity, other_collider_transform, other_collider, rigid_body) in q_colliders.iter() {
        if *rigid_body != RigidBody::Static {
            continue;
        }

        for x in 0..grid.width() {
            for y in 0..grid.height() {
                let collider_translation = offset + tile_size.0 * Vec2::new(x as f32, y as f32);

                let Ok(result) = contact_query::intersection_test(
                    collider,
                    collider_translation,
                    Quat::default(),
                    other_collider,
                    other_collider_transform.translation().truncate(),
                    other_collider_transform.rotation()
                ) else {
                    continue;
                };

                if !result {
                    continue;
                }

                grid.set_point(UVec3::new(x, y, 0), Point::new(0, true));
            }
        }

        commands.entity(entity).insert(GridCollisionCalculated);
    }

    grid.build();

}