Build production-ready editor authoring workflows
CI / Format, lint, test, build (push) Waiting to run

This commit is contained in:
Rbanh committed 2026-07-11 12:41:04 -04:00
1 parent cc1fa6ea3b
commit 0553a85220
163 files changed
+34547 -1565

No files matched your search

+150 -11
View File
@@ -248,10 +248,15 @@ fn sync_brush_element_gizmo(
mode: Res<BrushEditMode>,
selection: Res<BrushElementSelection>,
mut state: ResMut<BrushElementGizmoState>,
brushes: Query<(&BrushDesc, &GlobalTransform)>,
mut brushes: Query<(&mut BrushDesc, &GlobalTransform)>,
mut gizmos: Query<&mut Transform, With<BrushElementGizmo>>,
) {
if !mode.is_element_mode() || matches!(*mode, BrushEditMode::Clip) {
if let Some((brush_entity, old_brush)) = take_brush_edit_rollback(&mut state) {
if let Ok((mut brush, _)) = brushes.get_mut(brush_entity) {
*brush = old_brush;
}
}
clear_brush_element_gizmo(&mut commands, &mut state);
return;
}
@@ -427,6 +432,19 @@ fn apply_brush_element_gizmo(
state.changed = false;
}
fn take_brush_edit_rollback(state: &mut BrushElementGizmoState) -> Option<(Entity, BrushDesc)> {
let rollback = if state.changed {
state.brush.zip(state.old_brush.take())
} else {
None
};
state.old_brush = None;
state.old_gizmo = None;
state.last_gizmo = None;
state.changed = false;
rollback
}
fn clear_brush_element_gizmo(commands: &mut Commands, state: &mut BrushElementGizmoState) {
if let Some(entity) = state.entity.take() {
if let Ok(mut entity_mut) = commands.get_entity(entity) {
@@ -587,13 +605,14 @@ fn draw_brush_elements(
gizmos: &mut Gizmos,
) {
let base_color = match mode {
BrushEditMode::Vertex => Color::srgb(0.2, 0.72, 1.0),
BrushEditMode::Edge => Color::srgb(1.0, 0.68, 0.24),
BrushEditMode::Face => Color::srgb(0.24, 1.0, 0.56),
BrushEditMode::Clip => Color::srgb(0.92, 0.36, 1.0),
BrushEditMode::Vertex => Color::srgb(0.31, 0.75, 0.88),
BrushEditMode::Edge => Color::srgb(0.95, 0.62, 0.2),
BrushEditMode::Face => Color::srgb(0.32, 0.82, 0.52),
BrushEditMode::Clip => Color::srgb(0.86, 0.42, 0.92),
BrushEditMode::Object => Color::WHITE,
};
let selected_color = Color::srgb(1.0, 0.95, 0.2);
}
.with_alpha(if active { 0.9 } else { 0.38 });
let selected_color = Color::srgb(1.0, 0.76, 0.34);
for face in &brush.faces {
let vertices = world_vertices(face, transform);
if vertices.is_empty() {
@@ -613,8 +632,29 @@ fn draw_brush_elements(
} else {
base_color
};
gizmos.sphere(face_center, 0.08, color);
gizmos.line(face_center, face_center + normal * 0.55, color);
gizmos.sphere(
face_center,
if active && selected.contains(&key) {
0.11
} else {
0.075
},
color,
);
gizmos.line(face_center, face_center + normal * 0.65, color);
if matches!(mode, BrushEditMode::Face) {
for index in 0..vertices.len() {
gizmos.line(
vertices[index],
vertices[(index + 1) % vertices.len()],
color.with_alpha(if active && selected.contains(&key) {
1.0
} else {
0.42
}),
);
}
}
}
for index in 0..vertices.len() {
let next = (index + 1) % vertices.len();
@@ -628,7 +668,15 @@ fn draw_brush_elements(
} else {
base_color
};
gizmos.sphere(vertices[index], 0.06, color);
gizmos.sphere(
vertices[index],
if active && selected.contains(&key) {
0.1
} else {
0.055
},
color,
);
}
if matches!(mode, BrushEditMode::Edge | BrushEditMode::Clip) {
let key = BrushElementKey::Edge {
@@ -641,6 +689,10 @@ fn draw_brush_elements(
base_color
};
gizmos.line(vertices[index], vertices[next], color);
if active && selected.contains(&key) {
gizmos.sphere(vertices[index], 0.07, color);
gizmos.sphere(vertices[next], 0.07, color);
}
}
}
}
@@ -1073,7 +1125,11 @@ fn set_brush_edit_status(
#[cfg(test)]
mod tests {
use super::*;
use shared::BrushDesc;
use crate::history::EditorHistory;
use crate::operators::test_harness::{assert_undo_redo_round_trip, OperatorInvariantHarness};
use crate::scene_io::SceneIo;
use crate::selection::SelectedEntity;
use shared::{BrushDesc, LevelObject};
#[test]
fn point_inside_convex_polygon_is_detected() {
@@ -1158,4 +1214,87 @@ mod tests {
assert_eq!(command.label(), "Clip Brush");
}
#[test]
fn clip_commit_is_one_undo_group_and_round_trips_geometry() {
let mut world = World::new();
world.init_resource::<ActiveOperator>();
world.init_resource::<EditorHistory>();
world.init_resource::<SceneIo>();
world.init_resource::<SelectedEntity>();
let initial_transform = Transform::default();
let initial_brush = BrushDesc::default();
let entity = world
.spawn((LevelObject, initial_transform, initial_brush.clone()))
.id();
let face = initial_brush.faces[0].id.clone();
let result = clip_preview_result(&initial_brush, &initial_transform, &face).unwrap();
let committed = (result.transform, result.brush.clone());
let harness = OperatorInvariantHarness::capture(&mut world);
set_brush_transform_with_history(&mut world, entity, result.transform, result.brush);
set_brush_edit_status(
&mut world.resource_mut::<ActiveOperator>(),
OperatorPhase::Committed,
"Brush clip committed",
);
harness.assert_committed(&mut world, 1, 0);
assert_undo_redo_round_trip(
&mut world,
(initial_transform, initial_brush),
committed,
|world| {
(
*world.get::<Transform>(entity).unwrap(),
world.get::<BrushDesc>(entity).unwrap().clone(),
)
},
);
}
#[test]
fn escape_from_element_preview_restores_brush_and_despawns_helper() {
let mut app = App::new();
app.init_resource::<ActiveOperator>()
.init_resource::<EditorHistory>()
.init_resource::<SceneIo>()
.init_resource::<BrushEditMode>()
.init_resource::<BrushElementSelection>()
.init_resource::<BrushElementGizmoState>()
.add_systems(Update, sync_brush_element_gizmo);
let initial = BrushDesc::default();
let mut preview = initial.clone();
preview.faces[0].vertices[0] += Vec3::X * 0.25;
let brush_entity = app
.world_mut()
.spawn((LevelObject, preview, GlobalTransform::default()))
.id();
let helper = app.world_mut().spawn(BrushElementGizmo).id();
*app.world_mut().resource_mut::<BrushEditMode>() = BrushEditMode::Object;
*app.world_mut().resource_mut::<BrushElementGizmoState>() = BrushElementGizmoState {
entity: Some(helper),
brush: Some(brush_entity),
old_brush: Some(initial.clone()),
old_gizmo: Some(Transform::default()),
last_gizmo: Some(Transform::from_translation(Vec3::X)),
changed: true,
};
set_brush_edit_status(
&mut app.world_mut().resource_mut::<ActiveOperator>(),
OperatorPhase::Canceled,
"Object mode",
);
let harness = OperatorInvariantHarness::capture(app.world_mut());
app.update();
harness.assert_canceled(app.world_mut());
assert_eq!(app.world().get::<BrushDesc>(brush_entity), Some(&initial));
harness.assert_no_helpers::<BrushElementGizmo>(app.world_mut());
let state = app.world().resource::<BrushElementGizmoState>();
assert!(state.entity.is_none());
assert!(state.old_brush.is_none());
assert!(!state.changed);
}
}