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 bevy_inspector_egui::quick::WorldInspectorPlugin;
use global_state::GlobalState;
use polygon::ObjectInfos;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugin(EguiPlugin)
        .add_plugin(WorldInspectorPlugin::new())
        .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, mut global_state: ResMut<GlobalState>) {
    global_state.setup_2d_cam(&mut cmd);
}

// Create UI
fn update_ui_side_panel(
    mut contexts: EguiContexts,
    mut global_state: ResMut<GlobalState>,
    mut object_infos: ResMut<ObjectInfos>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut standard_materials: ResMut<Assets<StandardMaterial>>,
    mut color_materials: ResMut<Assets<ColorMaterial>>,
) {
    egui::SidePanel::right("2D View")
        .default_width(400.0)
        .show(contexts.ctx_mut(), |ui| {
            if global_state.view_2d {
                if ui.button("Change to 3D View").clicked() {
                    global_state.view_2d = false;

                    object_infos.iter_mut().for_each(|polygon| {
                        polygon.swap_to_3d(
                            &global_state,
                            &mut commands,
                            &mut meshes,
                            &mut standard_materials,
                        )
                    });

                    global_state.setup_3d_cam(&mut commands);

                    debug_assert!(global_state.camera.is_some());
                    debug_assert!(global_state.camera.as_ref().unwrap().is_3d());
                }
            } else {
                if ui.button("Change to 2D View").clicked() {
                    global_state.view_2d = true;

                    object_infos.iter_mut().for_each(|polygon| {
                        polygon.swap_to_2d(
                            &global_state,
                            &mut commands,
                            &mut meshes,
                            &mut color_materials,
                        )
                    });

                    global_state.setup_2d_cam(&mut commands);

                    debug_assert!(global_state.camera.is_some());
                    debug_assert!(global_state.camera.as_ref().unwrap().is_2d());
                }
            }

            if global_state.view_2d {
                if global_state.polygon_started {
                    if let Some(polygon) = object_infos.active_polygon() {
                        for (index, point) in polygon.points().iter().enumerate() {
                            ui.label(&format!("{}: ({}, {})", index, point.x, point.y));
                        }
                    }
                } 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 && global_state.view_2d {
                        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);
    }
}