RustyStriker/shape_maker
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

dragging! and some other things, also bevy 0.8 now(which is annoying me currently due to a weird bug in exit

Browse source
This commit is contained in:
RustyStriker 2022-08-01 18:33:21 +03:00
parent 509a11a6a9
commit 1da4c5b473
9 changed files with 509 additions and 478 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

765
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

6
Cargo.toml
View file

@ -6,6 +6,6 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
bevy = "0.7.0"
bevy_egui = { version = "0.14.0", features = ["manage_clipboard"] }
bevy_prototype_lyon = "0.5.0"
bevy = "0.8.0"
bevy_egui = { version = "0.15.0", features = ["manage_clipboard"] }
bevy_prototype_lyon = "0.6.0"

12
README.md
View file

@ -7,10 +7,14 @@ Eventually, this will be a level editor... But until then, I guess it's just fun
- [x] Items tree view showing all shapes with their child nodes and purposes(maybe location and such as well?)
- [x] Change shape name in tree view
- [x] Delete shapes in tree view - I should probably make it ask for confirmation...
- [ ] Highlight opened shapes in the tree(maybe allow only 1 opened shape?)
- [x] Highlight opened shapes in the tree(maybe allow only 1 opened shape? - I dont think egui allows me to do that)
- [x] Drag camera around
- [x] Zome in/out
- [ ] Import images
- [ ] Drag camera around
- [ ] Zome in/out
- [ ] Snap to grid
- [ ] Change grid size
- [ ] Show/Hide grid(also make a visible grid in the first place)
- [ ] Grab shapes instead of center points
- [ ] Save? (maybe just import and export directly?)
- [ ] Export
- [ ] Import
- [ ] Save? (maybe just import and export directly?)

2
src/helpers.rs
View file

@ -7,7 +7,7 @@ pub fn get_mouse_pos(q_cam: &Query<(&Camera, &GlobalTransform), With<MainCamera>
if let Some(screen_pos) = wnd.cursor_position() {
let w_size = Vec2::new(wnd.width() as f32, wnd.height() as f32);
let ndc = (screen_pos / w_size) * 2.0 - Vec2::ONE;
let ndc_to_world = cam_pos.compute_matrix() * cam.projection_matrix.inverse();
let ndc_to_world = cam_pos.compute_matrix() * cam.projection_matrix().inverse();
let world_pos = ndc_to_world.project_point3(ndc.extend(-1.0));
let world_pos: Vec2 = world_pos.truncate();

4
src/lib.rs
View file

@ -6,12 +6,10 @@ use bevy_egui::egui;
pub mod create;
pub mod helpers;
pub mod modify;
pub mod rotate;
pub mod ui;
pub use ui::{action_bar_sys, shape_tree_sys};
pub use modify::modify_sys;
pub use create::create_sys;
pub use rotate::rotate_sys;
pub use helpers::*;
@ -36,7 +34,7 @@ pub enum CreateShape {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum Action {
Create, Modify, Rotate
Create, Modify
}
pub struct UiState {
pub current_action: Action,

91
src/main.rs
View file

@ -1,4 +1,5 @@
use bevy::ecs::schedule::ShouldRun;
use bevy::input::mouse::{MouseMotion, MouseWheel};
use bevy::math::Vec3Swizzles;
use bevy::{prelude::*, window::PresentMode, winit::WinitSettings};
use bevy_egui::{egui, EguiContext, EguiPlugin};
@ -15,7 +16,7 @@ fn main() {
// Optimal power saving and present mode settings for desktop apps.
.insert_resource(WinitSettings::desktop_app())
.insert_resource(WindowDescriptor {
present_mode: PresentMode::Mailbox,
present_mode: PresentMode::Fifo,
title: "Shape Maker".to_string(),
..Default::default()
})
@ -39,13 +40,13 @@ fn main() {
.add_system(modify_sys.with_run_criteria(|state: Res<UiState>, mut ec: ResMut<EguiContext>|
if !ec.ctx_mut().is_pointer_over_area() && state.current_action == Action::Modify { ShouldRun::Yes } else { ShouldRun::No }
))
.add_system(rotate_sys.with_run_criteria(|state: Res<UiState>, mut ec: ResMut<EguiContext>|
if !ec.ctx_mut().is_pointer_over_area() && state.current_action == Action::Rotate { ShouldRun::Yes } else { ShouldRun::No }
))
.add_system(action_bar_sys)
.add_system(shape_tree_sys)
.add_system(show_hide_points)
.add_system(color_points)
.add_system(drag_camera_sys)
.add_system(zoom_camera_sys)
.add_system(scale_points)
;
app.run();
@ -54,7 +55,7 @@ fn main() {
fn basic_setup_sys(
mut coms: Commands,
) {
coms.spawn_bundle(OrthographicCameraBundle::new_2d())
coms.spawn_bundle(Camera2dBundle::default())
.insert(MainCamera);
}
@ -65,6 +66,70 @@ fn configure_visuals(mut egui_ctx: ResMut<EguiContext>) {
});
}
fn zoom_camera_sys(
mut mouse_scroll: EventReader<MouseWheel>,
mut cam: Query<&mut OrthographicProjection, With<MainCamera>>,
) {
let mut scroll = 0.0;
for m in mouse_scroll.iter() {
scroll += m.y * 0.1;
}
for mut op in cam.iter_mut() {
op.scale += scroll ;
if op.scale <= 0.0 {
op.scale = 0.1;
}
}
}
fn scale_points(
scale: Query<&OrthographicProjection, (With<MainCamera>, Changed<OrthographicProjection>)>,
shapes: Query<&ShapeData>,
p_size: Res<PointSize>,
mut paths: Query<&mut Path, With<Path>>,
) {
if let Ok(scale) = scale.get_single() {
let scale = scale.scale;
for sd in shapes.iter() {
if let Ok(mut p) = paths.get_mut(sd.center.unwrap()) {
let shape = shapes::Circle {
radius: p_size.0 * scale,
center: Vec2::ZERO,
};
*p = ShapePath::build_as(&shape);
}
for &edge in sd.edges.iter() {
if let Ok(mut p) = paths.get_mut(edge) {
let shape = shapes::Circle {
radius: p_size.0 * scale,
center: Vec2::ZERO,
};
*p = ShapePath::build_as(&shape);
}
}
}
}
}
fn drag_camera_sys(
mut mouse_move: EventReader<MouseMotion>,
mouse_input: Res<Input<MouseButton>>,
mut cam: Query<(&mut Transform, &OrthographicProjection), With<MainCamera>>,
) {
if mouse_input.pressed(MouseButton::Middle) {
let mut delta = Vec2::ZERO;
for m in mouse_move.iter() {
delta -= Vec2::new(m.delta.x, -m.delta.y) * 2.0;
}
for (mut t, op) in cam.iter_mut() {
t.translation += delta.extend(0.0) * op.scale;
}
}
}
fn show_hide_points(
state: Res<UiState>,
@ -74,7 +139,6 @@ fn show_hide_points(
let (center, edge) = match state.current_action {
Action::Create => (false, false),
Action::Modify => (true, true),
Action::Rotate => (true, true),
};
for sd in shapes.iter() {
@ -96,6 +160,7 @@ fn show_hide_points(
fn color_points(
mut current: Local<Option<Entity>>,
scale: Query<&OrthographicProjection, With<MainCamera>>,
wnds: Res<Windows>,
p_size: Res<PointSize>,
q_cam: Query<(&Camera, &GlobalTransform), With<MainCamera>>,
@ -103,16 +168,18 @@ fn color_points(
global_transforms: Query<&GlobalTransform, With<Path>>,
mut dots: Query<&mut DrawMode, With<Path>>,
) {
let normal = DrawMode::Outlined { fill_mode: FillMode::color(Color::RED), outline_mode: StrokeMode::new(Color::rgb(0.9,0.0,0.0), 1.0) };
let hover = DrawMode::Outlined { fill_mode: FillMode::color(Color::RED), outline_mode: StrokeMode::new(Color::ORANGE, 3.0) };
let scale = scale.get_single().map(|s| s.scale).unwrap_or(1.0);
let normal = DrawMode::Outlined { fill_mode: FillMode::color(Color::RED), outline_mode: StrokeMode::new(Color::rgb(0.9,0.0,0.0), 0.0) };
let hover = DrawMode::Outlined { fill_mode: FillMode::color(Color::RED), outline_mode: StrokeMode::new(Color::ORANGE, 3.0 * scale) };
let mouse_pos = get_mouse_pos(&q_cam, &wnds);
if let Some(mpos) = mouse_pos {
let mut hovering = false;
'shapes: for sd in shapes.iter() {
let e = sd.center.unwrap();
let p = global_transforms.get(e).unwrap().translation.xy();
if (mpos - p).length_squared() < p_size.0.powi(2) {
let p = global_transforms.get(e).unwrap().translation().xy();
if (mpos - p).length_squared() < (p_size.0 * scale).powi(2) {
if Some(e) != *current {
if let Some(c) = &*current {
if let Ok(mut md) = dots.get_mut(*c) {
@ -128,8 +195,8 @@ fn color_points(
break;
}
for edge in sd.edges.iter() {
let p = global_transforms.get(*edge).unwrap().translation.xy();
if (mpos - p).length_squared() < p_size.0.powi(2) {
let p = global_transforms.get(*edge).unwrap().translation().xy();
if (mpos - p).length_squared() < (p_size.0 * scale).powi(2) {
if Some(*edge) != *current {
if let Some(c) = &*current {
if let Ok(mut md) = dots.get_mut(*c) {

15
src/modify.rs
View file

@ -8,6 +8,7 @@ pub fn modify_sys(
mut holding: Local<Option<(Entity, Entity)>>,
mouse: Res<Input<MouseButton>>,
wnds: Res<Windows>,
scale: Query<&OrthographicProjection, With<MainCamera>>,
p_size: Res<PointSize>,
mut paths: Query<&mut Path>,
mut transforms: Query<&mut Transform>,
@ -15,6 +16,7 @@ pub fn modify_sys(
q_cam: Query<(&Camera, &GlobalTransform), With<MainCamera>>,
shapes: Query<(Entity, &ShapeData)>,
) {
let scale = scale.get_single().map(|s| s.scale).unwrap_or(1.0);
let mouse_pos = get_mouse_pos(&q_cam, &wnds);
if let Some(mouse_pos) = mouse_pos {
@ -22,18 +24,18 @@ pub fn modify_sys(
// Grab attempt - search if we are holding a shape or something
for (e, sd) in shapes.iter() {
if let Ok(t) = gtransforms.get(sd.center.unwrap()) {
let t = t.translation.xy();
let t = t.translation().xy();
if (mouse_pos - t).length_squared() < p_size.0.powi(2) {
if (mouse_pos - t).length_squared() < (p_size.0 * scale).powi(2) {
*holding = Some((e, sd.center.unwrap()));
break;
}
}
for edge in sd.edges.iter() {
if let Ok(t) = gtransforms.get(*edge) {
let t = t.translation.xy();
let t = t.translation().xy();
if (mouse_pos - t).length_squared() < p_size.0.powi(2) {
if (mouse_pos - t).length_squared() < (p_size.0 * scale).powi(2) {
*holding = Some((e, *edge));
break;
}
@ -55,8 +57,9 @@ pub fn modify_sys(
else if let Ok(mut t) = transforms.get_mut(pe) {
// Update the dot position
let gt = gtransforms.get(pe).unwrap();
let ang = gt.rotation.to_euler(EulerRot::XYZ).2;
let delta = Mat2::from_angle(-ang) * (mouse_pos - gt.translation.xy());
let rot = gt.to_scale_rotation_translation().1;
let ang = rot.to_euler(EulerRot::XYZ).2;
let delta = Mat2::from_angle(-ang) * (mouse_pos - gt.translation().xy());
t.translation += delta.extend(0.0);
// We need to recalculate the center, and update the points to be the new relevant point from the center
let center_offset = calc_shape_center_offset(&transforms, sd);

44
src/rotate.rs
View file

@ -1,44 +0,0 @@
use bevy::prelude::*;
use bevy::math::Vec3Swizzles;
use crate::*;
pub fn rotate_sys(
mut holding: Local<Option<(Entity, f32)>>, // main_shape we hold and the angle offset
mouse: Res<Input<MouseButton>>,
wnds: Res<Windows>,
q_cam: Query<(&Camera, &GlobalTransform), With<MainCamera>>,
p_size: Res<PointSize>,
mut transforms: Query<&mut Transform>,
gtransforms: Query<&GlobalTransform>,
shapes: Query<&ShapeData>,
) {
if let Some(mouse_pos) = get_mouse_pos(&q_cam, &wnds) {
if mouse.just_pressed(MouseButton::Left) && holding.is_none() {
for sd in shapes.iter().filter(|x| x.shape != CreateShape::Circle /* no reason to rotate circles ;) */) {
for edge in sd.edges.iter() {
if let Ok(gt) = gtransforms.get(*edge) {
if (mouse_pos - gt.translation.xy()).length_squared() < p_size.0.powi(2) {
// We grabbed an entity, we now need an angle offset
let center = gtransforms.get(sd.main_shape).unwrap().translation.xy();
let angle_offset = (mouse_pos - center).angle_between(Vec2::X);
let angle_offset = transforms.get(sd.main_shape).unwrap().rotation.to_euler(EulerRot::XYZ).2 + angle_offset;
*holding = Some((sd.main_shape, angle_offset));
}
}
}
}
}
else if mouse.just_released(MouseButton::Left) {
*holding = None;
}
else if let Some((en, ang_offset)) = *holding {
let center = gtransforms.get(en).unwrap().translation.xy();
let ang_curr = (mouse_pos - center).angle_between(Vec2::X);
if let Ok(mut t) = transforms.get_mut(en) {
t.rotation = Quat::from_rotation_z(ang_offset - ang_curr);
}
}
}
}

48
src/ui.rs
View file

@ -1,7 +1,7 @@
use bevy::math::{Vec3Swizzles, Mat2};
use bevy::prelude::*;
use bevy_egui::{egui, EguiContext};
use bevy_prototype_lyon::prelude::Path;
use bevy_prototype_lyon::prelude::{Path, DrawMode, FillMode, StrokeMode};
use crate::*;
pub fn action_bar_sys(
@ -20,11 +20,6 @@ pub fn action_bar_sys(
if m.clicked() {
state.current_action = Action::Modify;
}
let r = hui.button(egui::RichText::new("R").color(state.current_action_color(&colors, Action::Rotate)))
.on_hover_text("Rotate");
if r.clicked() {
state.current_action = Action::Rotate;
}
let c = hui.button(egui::RichText::new("C").color(state.current_action_color(&colors, Action::Create)))
.on_hover_text("Create");
if c.clicked() {
@ -74,6 +69,7 @@ pub fn shape_tree_sys(
mut transforms: Query<&mut Transform>,
global_transforms: Query<&GlobalTransform>,
mut paths: Query<&mut Path>,
mut draw_modes: Query<&mut DrawMode, With<Path>>,
) {
if !shapes.is_empty() {
egui::Window::new("Shape Tree")
@ -83,7 +79,7 @@ pub fn shape_tree_sys(
.show(egui_ctx.ctx_mut(), |ui| {
for (e, mut sd) in shapes.iter_mut () {
ui.push_id(e.id(), |ui| {
let ui_func = |ui: &mut egui::Ui| {
let mut ui_func = |ui: &mut egui::Ui| {
if let Ok(mut t) = transforms.get_mut(sd.main_shape) {
ui.horizontal(|hui| {
hui.label("Translation:");
@ -102,14 +98,15 @@ pub fn shape_tree_sys(
ui.horizontal(|hui| {
hui.label(format!("Edge {}", i));
let gt = global_transforms.get(*edge).unwrap();
let mut gt_x = gt.translation.x;
let mut gt_y = gt.translation.y;
let mut gt_x = gt.translation().x;
let mut gt_y = gt.translation().y;
let c1 = hui.add(egui::DragValue::new(&mut gt_x)).changed();
let c2 = hui.add(egui::DragValue::new(&mut gt_y)).changed();
if c1 || c2 {
let ang = gt.rotation.to_euler(EulerRot::XYZ).2;
let delta = Mat2::from_angle(-ang) * (Vec2::new(gt_x, gt_y) - gt.translation.xy());
let rot = gt.to_scale_rotation_translation().1;
let ang = rot.to_euler(EulerRot::XYZ).2;
let delta = Mat2::from_angle(-ang) * (Vec2::new(gt_x, gt_y) - gt.translation().xy());
if let Ok(mut t) = transforms.get_mut(*edge) {
t.translation += delta.extend(0.0);
}
@ -143,7 +140,19 @@ pub fn shape_tree_sys(
else {
let default_name = format!("{:?}", sd.shape);
ui.horizontal(|hui| {
let closed = hui.collapsing(sd.name.as_ref().unwrap_or(&default_name), ui_func).fully_closed();
let collapse = hui.collapsing(sd.name.as_ref().unwrap_or(&default_name), |ui| {
ui.horizontal(|hui| {
if hui.button("E").clicked() {
*name_change = Some((e, format!("{:?}", sd.shape)));
}
if hui.button("D").clicked() {
coms.entity(sd.main_shape).despawn_recursive();
coms.entity(e).despawn();
}
});
ui_func(ui);
});
let closed = collapse.fully_closed();
if closed && hui.button("E").clicked() {
*name_change = Some((e, default_name));
}
@ -151,6 +160,21 @@ pub fn shape_tree_sys(
coms.entity(sd.main_shape).despawn_recursive();
coms.entity(e).despawn();
}
let d_normal = DrawMode::Outlined {
fill_mode: FillMode::color(Color::rgba(0.0, 0.5, 0.5, 0.4)),
outline_mode: StrokeMode::new(Color::rgba(0.0, 0.5, 0.5, 0.6), 3.0),
};
let d_open = DrawMode::Outlined {
fill_mode: FillMode::color(Color::rgba(0.0, 0.5, 0.5, 0.4)),
outline_mode: StrokeMode::new(Color::GOLD, 3.0),
};
let wanted_dm = if collapse.fully_open() { d_open } else { d_normal };
if let Ok(mut dm) = draw_modes.get_mut(sd.main_shape) {
if *dm != wanted_dm {
*dm = wanted_dm
}
}
});
}
});