This commit is contained in:
1 parent
93ab6c2ea2
commit
02beeb7085
5 files changed
+333
-3
No files matched your search
@@ -0,0 +1,248 @@
|
||||
//! MVP brush CSG operations for convex cuboid/prism blockout brushes.
|
||||
|
||||
use bevy::math::Affine3A;
|
||||
use bevy::prelude::*;
|
||||
use shared::{BrushDesc, LevelObject};
|
||||
|
||||
use crate::history::{
|
||||
delete_entities_with_history, set_brush_with_history, set_transform_with_history,
|
||||
};
|
||||
use crate::scene_io::SceneIo;
|
||||
use crate::ui::UiState;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||||
struct BrushBounds {
|
||||
min: Vec3,
|
||||
max: Vec3,
|
||||
}
|
||||
|
||||
impl BrushBounds {
|
||||
fn union(self, other: Self) -> Self {
|
||||
Self {
|
||||
min: self.min.min(other.min),
|
||||
max: self.max.max(other.max),
|
||||
}
|
||||
}
|
||||
|
||||
fn intersection(self, other: Self) -> Option<Self> {
|
||||
let min = self.min.max(other.min);
|
||||
let max = self.max.min(other.max);
|
||||
((max.x - min.x) > 0.001 && (max.y - min.y) > 0.001 && (max.z - min.z) > 0.001)
|
||||
.then_some(Self { min, max })
|
||||
}
|
||||
|
||||
fn center(self) -> Vec3 {
|
||||
(self.min + self.max) * 0.5
|
||||
}
|
||||
|
||||
fn size(self) -> Vec3 {
|
||||
self.max - self.min
|
||||
}
|
||||
|
||||
fn volume(self) -> f32 {
|
||||
let size = self.size();
|
||||
size.x.max(0.0) * size.y.max(0.0) * size.z.max(0.0)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn selected_brush_count(world: &World) -> usize {
|
||||
world
|
||||
.resource::<UiState>()
|
||||
.selected_entities
|
||||
.iter()
|
||||
.filter(|entity| world.get::<BrushDesc>(*entity).is_some())
|
||||
.count()
|
||||
}
|
||||
|
||||
pub fn intersect_selected_brushes(world: &mut World) {
|
||||
run_bounds_csg(world, BrushCsgOp::Intersect);
|
||||
}
|
||||
|
||||
pub fn merge_selected_brushes(world: &mut World) {
|
||||
run_bounds_csg(world, BrushCsgOp::Merge);
|
||||
}
|
||||
|
||||
pub fn subtract_selected_brushes(world: &mut World) {
|
||||
run_bounds_csg(world, BrushCsgOp::Subtract);
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum BrushCsgOp {
|
||||
Intersect,
|
||||
Merge,
|
||||
Subtract,
|
||||
}
|
||||
|
||||
fn run_bounds_csg(world: &mut World, op: BrushCsgOp) {
|
||||
let selected: Vec<Entity> = world
|
||||
.resource::<UiState>()
|
||||
.selected_entities
|
||||
.iter()
|
||||
.filter(|entity| {
|
||||
world.get::<LevelObject>(*entity).is_some() && world.get::<BrushDesc>(*entity).is_some()
|
||||
})
|
||||
.collect();
|
||||
if selected.len() < 2 {
|
||||
set_status(world, "Select at least two brushes for CSG");
|
||||
return;
|
||||
}
|
||||
|
||||
let Some(primary_bounds) = brush_world_bounds(world, selected[0]) else {
|
||||
set_status(world, "Primary brush has no valid bounds");
|
||||
return;
|
||||
};
|
||||
|
||||
let result = match op {
|
||||
BrushCsgOp::Merge => selected
|
||||
.iter()
|
||||
.skip(1)
|
||||
.filter_map(|entity| brush_world_bounds(world, *entity))
|
||||
.fold(primary_bounds, BrushBounds::union),
|
||||
BrushCsgOp::Intersect => {
|
||||
let mut result = primary_bounds;
|
||||
for entity in selected.iter().skip(1) {
|
||||
let Some(bounds) = brush_world_bounds(world, *entity) else {
|
||||
continue;
|
||||
};
|
||||
let Some(intersection) = result.intersection(bounds) else {
|
||||
set_status(world, "Brush intersect failed: no overlap");
|
||||
return;
|
||||
};
|
||||
result = intersection;
|
||||
}
|
||||
result
|
||||
}
|
||||
BrushCsgOp::Subtract => {
|
||||
let Some(cutter_bounds) = brush_world_bounds(world, selected[1]) else {
|
||||
set_status(world, "Subtract failed: cutter brush has no valid bounds");
|
||||
return;
|
||||
};
|
||||
let Some(overlap) = primary_bounds.intersection(cutter_bounds) else {
|
||||
set_status(world, "Subtract failed: brushes do not overlap");
|
||||
return;
|
||||
};
|
||||
let Some(result) = largest_remaining_slab(primary_bounds, overlap) else {
|
||||
set_status(world, "Subtract failed: result would be empty");
|
||||
return;
|
||||
};
|
||||
result
|
||||
}
|
||||
};
|
||||
|
||||
apply_bounds_result(world, selected[0], result);
|
||||
if matches!(op, BrushCsgOp::Merge | BrushCsgOp::Intersect) {
|
||||
delete_entities_with_history(world, &selected[1..]);
|
||||
}
|
||||
set_status(
|
||||
world,
|
||||
match op {
|
||||
BrushCsgOp::Intersect => "Brush intersect committed",
|
||||
BrushCsgOp::Merge => "Brush convex merge committed",
|
||||
BrushCsgOp::Subtract => "Brush subtract committed",
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
fn apply_bounds_result(world: &mut World, entity: Entity, bounds: BrushBounds) {
|
||||
let center = bounds.center();
|
||||
let size = bounds.size();
|
||||
let new_brush = BrushDesc::cuboid(size);
|
||||
let old_transform = world.get::<Transform>(entity).copied().unwrap_or_default();
|
||||
let mut new_transform = old_transform;
|
||||
new_transform.translation = center;
|
||||
new_transform.rotation = Quat::IDENTITY;
|
||||
new_transform.scale = Vec3::ONE;
|
||||
set_transform_with_history(world, entity, old_transform, new_transform);
|
||||
set_brush_with_history(world, entity, new_brush);
|
||||
}
|
||||
|
||||
fn brush_world_bounds(world: &World, entity: Entity) -> Option<BrushBounds> {
|
||||
let brush = world.get::<BrushDesc>(entity)?;
|
||||
let transform = world
|
||||
.get::<GlobalTransform>(entity)
|
||||
.map(|global| global.affine())
|
||||
.or_else(|| {
|
||||
world
|
||||
.get::<Transform>(entity)
|
||||
.map(|transform| transform.compute_affine())
|
||||
})
|
||||
.unwrap_or(Affine3A::IDENTITY);
|
||||
let mut min = Vec3::splat(f32::INFINITY);
|
||||
let mut max = Vec3::splat(f32::NEG_INFINITY);
|
||||
let mut found = false;
|
||||
for vertex in brush
|
||||
.faces
|
||||
.iter()
|
||||
.flat_map(|face| face.vertices.iter().copied())
|
||||
{
|
||||
let world_vertex = transform.transform_point3(vertex);
|
||||
min = min.min(world_vertex);
|
||||
max = max.max(world_vertex);
|
||||
found = true;
|
||||
}
|
||||
found.then_some(BrushBounds { min, max })
|
||||
}
|
||||
|
||||
fn largest_remaining_slab(source: BrushBounds, overlap: BrushBounds) -> Option<BrushBounds> {
|
||||
let candidates = [
|
||||
BrushBounds {
|
||||
min: source.min,
|
||||
max: Vec3::new(overlap.min.x, source.max.y, source.max.z),
|
||||
},
|
||||
BrushBounds {
|
||||
min: Vec3::new(overlap.max.x, source.min.y, source.min.z),
|
||||
max: source.max,
|
||||
},
|
||||
BrushBounds {
|
||||
min: source.min,
|
||||
max: Vec3::new(source.max.x, overlap.min.y, source.max.z),
|
||||
},
|
||||
BrushBounds {
|
||||
min: Vec3::new(source.min.x, overlap.max.y, source.min.z),
|
||||
max: source.max,
|
||||
},
|
||||
BrushBounds {
|
||||
min: source.min,
|
||||
max: Vec3::new(source.max.x, source.max.y, overlap.min.z),
|
||||
},
|
||||
BrushBounds {
|
||||
min: Vec3::new(source.min.x, source.min.y, overlap.max.z),
|
||||
max: source.max,
|
||||
},
|
||||
];
|
||||
candidates
|
||||
.into_iter()
|
||||
.filter(|bounds| bounds.size().cmpgt(Vec3::splat(0.001)).all())
|
||||
.max_by(|a, b| a.volume().total_cmp(&b.volume()))
|
||||
}
|
||||
|
||||
fn set_status(world: &mut World, status: impl Into<String>) {
|
||||
if let Some(mut scene_io) = world.get_resource_mut::<SceneIo>() {
|
||||
scene_io.status = status.into();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn bounds(min: Vec3, max: Vec3) -> BrushBounds {
|
||||
BrushBounds { min, max }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersects_overlapping_bounds() {
|
||||
let a = bounds(Vec3::ZERO, Vec3::splat(2.0));
|
||||
let b = bounds(Vec3::ONE, Vec3::splat(3.0));
|
||||
assert_eq!(a.intersection(b), Some(bounds(Vec3::ONE, Vec3::splat(2.0))));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn subtract_picks_largest_remaining_slab() {
|
||||
let source = bounds(Vec3::ZERO, Vec3::new(4.0, 2.0, 2.0));
|
||||
let overlap = bounds(Vec3::ZERO, Vec3::new(1.0, 2.0, 2.0));
|
||||
let result = largest_remaining_slab(source, overlap).expect("remaining slab");
|
||||
assert_eq!(result.min, Vec3::new(1.0, 0.0, 0.0));
|
||||
assert_eq!(result.max, source.max);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user