application_exercise/src/main.rs

mod global_state;
mod polygon;

use bevy::{
    input::{
        mouse::{MouseButtonInput, MouseWheel},
        ButtonState,
    },
    prelude::*,
    window::WindowResized,
};

use bevy_egui::{egui, EguiContexts, EguiPlugin};
use global_state::GlobalState;
use polygon::ObjectInfos;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugin(EguiPlugin)
        .insert_resource(GlobalState::default())
        .insert_resource(ObjectInfos::default())
        .add_startup_system(setup_camera)
        .add_systems((mouse_event_system, update_ui_side_panel, on_resize_system))
        .run();
}

// Spawns the camera
fn setup_camera(mut cmd: Commands) {
    cmd.spawn(Camera2dBundle::default());
}

// Create UI
fn update_ui_side_panel(mut contexts: EguiContexts, mut global_state: ResMut<GlobalState>) {
    egui::Window::new("Hello").show(contexts.ctx_mut(), |ui| {
        if global_state.polygon_started {
            // TODO
        } else {
            if ui.button("New Polygon").clicked() {
                global_state.polygon_started = true;
            }
        }
    });
}

/// Handles all mouse events
fn mouse_event_system(
    mut mouse_button_input_events: EventReader<MouseButtonInput>,
    mut cursor_moved_events: EventReader<CursorMoved>,
    mut mouse_wheel_events: EventReader<MouseWheel>,
    mut global_state: ResMut<GlobalState>,
    mut object_infos: ResMut<ObjectInfos>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    for event in mouse_button_input_events.iter() {
        match event.button {
            MouseButton::Left => match event.state {
                ButtonState::Pressed => {
                    // only add new points if "New Polygon" button got pressed
                    if global_state.polygon_started {
                        let polygon = match object_infos.active_polygon() {
                            Some(polygon) => polygon,
                            None => object_infos.add_polygon(),
                        };

                        if polygon.add_point(
                            &global_state,
                            &mut commands,
                            &mut meshes,
                            &mut materials,
                        ) {
                            global_state.polygon_started = false;
                        }
                    }
                }
                ButtonState::Released => (),
            },

            _ => (),
        }
    }

    // store latest mouse cursor location
    for event in cursor_moved_events.iter() {
        global_state.cursor_position = event.position;
    }

    for _event in mouse_wheel_events.iter() {
        //
    }
}

// Handles resize events
fn on_resize_system(
    mut resize_reader: EventReader<WindowResized>,
    mut global_state: ResMut<GlobalState>,
) {
    for e in resize_reader.iter() {
        // When resolution is being changed
        global_state.window_extent = Vec2::new(e.width, e.height);
    }
}