jackdaw 0.4.0

A 3D level editor built with Bevy
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

//! Scene I/O operators: new / open / save / save as / save selection
//! as template / open recent.
//!
//! These wrap the existing free functions in [`crate::scene_io`] so they
//! can be dispatched uniformly through the operator API (menu, keybind,
//! F3 command palette, extension code). BEI bindings for the
//! usual Ctrl+N / Ctrl+O / Ctrl+S / Ctrl+Shift+S keybinds are attached
//! here.

use bevy::prelude::*;
use bevy_enhanced_input::prelude::{Press, *};
use jackdaw_api::prelude::*;

use crate::core_extension::CoreExtensionInputContext;

pub(crate) fn add_to_extension(ctx: &mut ExtensionContext) {
    ctx.register_operator::<SceneNewOp>()
        .register_operator::<SceneOpenOp>()
        .register_operator::<SceneSaveOp>()
        .register_operator::<SceneSaveAsOp>()
        .register_operator::<SceneSaveSelectionAsTemplateOp>()
        .register_operator::<SceneOpenRecentOp>();

    let ext = ctx.id();
    ctx.entity_mut().world_scope(|world| {
        world.spawn((
            Action::<SceneNewOp>::new(),
            ActionOf::<CoreExtensionInputContext>::new(ext),
            bindings![(
                KeyCode::KeyN.with_mod_keys(ModKeys::CONTROL | ModKeys::SHIFT),
                Press::default(),
            )],
        ));
        world.spawn((
            Action::<SceneOpenOp>::new(),
            ActionOf::<CoreExtensionInputContext>::new(ext),
            bindings![(
                KeyCode::KeyO.with_mod_keys(ModKeys::CONTROL),
                Press::default(),
            )],
        ));
        world.spawn((
            Action::<SceneSaveOp>::new(),
            ActionOf::<CoreExtensionInputContext>::new(ext),
            bindings![(
                KeyCode::KeyS.with_mod_keys(ModKeys::CONTROL),
                Press::default(),
            )],
        ));
        world.spawn((
            Action::<SceneSaveAsOp>::new(),
            ActionOf::<CoreExtensionInputContext>::new(ext),
            bindings![(
                KeyCode::KeyS.with_mod_keys(ModKeys::CONTROL | ModKeys::SHIFT),
                Press::default(),
            )],
        ));
    });
}

#[operator(id = "scene.new", label = "New")]
pub(crate) fn scene_new(_: In<OperatorParameters>, mut commands: Commands) -> OperatorResult {
    commands.queue(|world: &mut World| {
        crate::scene_io::new_scene(world);
    });
    OperatorResult::Finished
}

#[operator(id = "scene.open", label = "Open")]
pub fn scene_open(_: In<OperatorParameters>, mut commands: Commands) -> OperatorResult {
    commands.queue(|world: &mut World| {
        crate::scene_io::load_scene(world);
    });
    OperatorResult::Finished
}

#[operator(id = "scene.save", label = "Save", allows_undo = false)]
pub fn scene_save(_: In<OperatorParameters>, mut commands: Commands) -> OperatorResult {
    commands.queue(|world: &mut World| {
        crate::scene_io::save_scene(world);
    });
    OperatorResult::Finished
}

#[operator(id = "scene.save_as", label = "Save As...", allows_undo = false)]
pub fn scene_save_as(_: In<OperatorParameters>, mut commands: Commands) -> OperatorResult {
    commands.queue(|world: &mut World| {
        crate::scene_io::save_scene_as(world);
    });
    OperatorResult::Finished
}

#[operator(
    id = "scene.save_selection_as_template",
    label = "Save Selection as Template",
    allows_undo = false
)]
pub(crate) fn scene_save_selection_as_template(
    _: In<OperatorParameters>,
    mut commands: Commands,
) -> OperatorResult {
    commands.queue(|world: &mut World| {
        let selection = world.resource::<crate::selection::Selection>();
        let name = selection
            .primary()
            .and_then(|e| world.get::<Name>(e).map(|n| n.as_str().to_string()))
            .unwrap_or_else(|| "template".to_string());
        crate::entity_templates::save_entity_template(world, &name);
    });
    OperatorResult::Finished
}

#[operator(id = "scene.open_recent", label = "Open Recent...")]
pub(crate) fn scene_open_recent(
    _: In<OperatorParameters>,
    mut commands: Commands,
) -> OperatorResult {
    commands.queue(|world: &mut World| {
        crate::open_recent_dialog(world);
    });
    OperatorResult::Finished
}