chiron 0.1.0

Graphical and command-line interface tools for Biomechanics Foundation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::gui::ui::notifications::Notifications;
use crate::ui::notifications::Toast;
use crate::visualizer::marker::Marker;
use bevy::prelude::*;
use bevy_c3d::*;
use rfd::FileDialog;
use std::path::PathBuf;

pub struct IoPlugin;

impl Plugin for IoPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(
            Update,
            (
                load_file_dialog,
                load_file_system,
                save_file_system,
                save_as_file_system,
                close_c3d_system,
            ),
        )
        .add_event::<CloseC3DEvent>()
        .add_event::<SaveAsFileEvent>()
        .add_event::<SaveFileEvent>()
        .add_event::<LoadFileEvent>();
    }
}

#[derive(Event)]
pub struct LoadFileEvent;

#[derive(Component)]
struct LoadFile(Option<PathBuf>);

fn load_file_dialog(mut commands: Commands, mut events: EventReader<LoadFileEvent>) {
    for _ in events.read() {
      let file = FileDialog::new().add_filter("C3D Files", &["c3d", "C3D", "C3d", "c3D"]).pick_file();
        commands.spawn(LoadFile(file));
    }
}

fn load_file_system(
    mut commands: Commands,
    mut tasks: Query<(Entity, &mut LoadFile)>,
    mut c3d_state: ResMut<C3dState>,
    asset_server: Res<AssetServer>,
) {
    for (entity, mut task) in tasks.iter_mut() {
        if let Some(path) = task.0.take() {
            c3d_state.path = path.to_str().unwrap().to_string();
            c3d_state.handle = asset_server.load(&c3d_state.path);
            c3d_state.loaded = false;
            commands.entity(entity).remove::<LoadFile>();
        }
    }
}

fn save_file(path: &str, c3d_state: &Res<C3dState>, c3d_assets: &Res<Assets<C3dAsset>>, notifications: &mut ResMut<Notifications>) {
        if c3d_state.loaded {
            let c3d_asset = c3d_assets.get(&c3d_state.handle);
            if let Some(c3d_asset) = c3d_asset {
                match c3d_asset.c3d.write(path) {
                    Ok(_) => notifications.add(Toast::success("File saved")),
                    Err(_) => notifications.add(Toast::error("Failed to save file")),
                }
            } else {
                notifications.add(Toast::error("Failed to save file"));
            }
        }
        else {
            notifications.add(Toast::error("No file loaded"));
        }
}

#[derive(Event)]
pub struct SaveFileEvent;

fn save_file_system(
    mut events: EventReader<SaveFileEvent>,
    c3d_state: Res<C3dState>,
    c3d_assets: Res<Assets<C3dAsset>>,
    mut notifications: ResMut<Notifications>,
    ) {
    for _ in events.read() {
        save_file(&c3d_state.path, &c3d_state, &c3d_assets, &mut notifications);
    }
}

#[derive(Event)]
pub struct SaveAsFileEvent;

fn save_as_file_system(
    mut events: EventReader<SaveAsFileEvent>,
    c3d_state: Res<C3dState>,
    c3d_assets: Res<Assets<C3dAsset>>,
    mut notifications: ResMut<Notifications>,
    ) {
    for _ in events.read() {
        let file = FileDialog::new().add_filter("C3D Files", &["c3d", "C3D", "C3d", "c3D"]).save_file();
        if let Some(file) = file {
            save_file(file.to_str().unwrap(), &c3d_state, &c3d_assets, &mut notifications);
        }
    }
}

#[derive(Event)]
pub struct CloseC3DEvent;

fn close_c3d_system(
    mut commands: Commands,
    mut events: EventReader<CloseC3DEvent>,
    mut c3d_state: ResMut<C3dState>,
    mut c3d_assets: ResMut<Assets<C3dAsset>>,
    mut notifications: ResMut<Notifications>,
    entities: Query<Entity, With<Marker>>,
    ) {
    for _ in events.read() {
        if !c3d_state.loaded {
            return;
        }
        c3d_state.loaded = false;
        c3d_state.path = "".to_string();
        c3d_assets.remove(&c3d_state.handle);
        c3d_state.handle = Handle::default();
        for entity in entities.iter() {
            //TODO: Add entity struct that indicates if it should be removed on file close
            // and use Query<Entity, With<CloseOnFileClose>> instead of Query<Entity, With<Marker>>
            commands.entity(entity).despawn_recursive();
        }
        notifications.add(Toast::info("File closed"));
    }
}