Improve quick brush creation workflow

This commit is contained in:
Rbanh committed 2026-06-06 14:16:12 -04:00
1 parent f09d35e54e
commit 48b1448c57
9 files changed
+701 -61

No files matched your search

+236 -7
View File
@@ -152,33 +152,196 @@ pub fn signed_area_xz(vertices: &[Vec3]) -> f32 {
* 0.5
}
pub fn validate_floor_polygon(vertices: &[Vec3]) -> Result<(), BrushPolygonError> {
pub fn normalize_floor_polygon(vertices: &[Vec3]) -> Result<Vec<Vec3>, BrushPolygonError> {
if vertices.len() < 3 {
return Err(BrushPolygonError::TooFewVertices);
}
if !vertices.iter().all(|vertex| vertex.is_finite()) {
return Err(BrushPolygonError::NonFiniteVertex);
}
for i in 0..vertices.len() {
for j in (i + 1)..vertices.len() {
if vertices[i].xz().distance_squared(vertices[j].xz()) <= EPSILON * EPSILON {
let mut normalized = Vec::with_capacity(vertices.len());
for vertex in vertices {
if normalized.last().is_some_and(|previous: &Vec3| {
previous.xz().distance_squared(vertex.xz()) <= EPSILON * EPSILON
}) {
continue;
}
normalized.push(*vertex);
}
if normalized.len() >= 2
&& normalized[0]
.xz()
.distance_squared(normalized[normalized.len() - 1].xz())
<= EPSILON * EPSILON
{
normalized.pop();
}
if normalized.len() < 3 {
return Err(BrushPolygonError::TooFewVertices);
}
for i in 0..normalized.len() {
for j in (i + 1)..normalized.len() {
if normalized[i].xz().distance_squared(normalized[j].xz()) <= EPSILON * EPSILON {
return Err(BrushPolygonError::DuplicateVertex);
}
}
}
let area = signed_area_xz(vertices);
if self_intersects_xz(vertices) {
Ok(normalized)
}
pub fn validate_simple_floor_polygon(vertices: &[Vec3]) -> Result<(), BrushPolygonError> {
let vertices = normalize_floor_polygon(vertices)?;
let area = signed_area_xz(&vertices);
if self_intersects_xz(&vertices) {
return Err(BrushPolygonError::SelfIntersecting);
}
if area.abs() <= EPSILON {
return Err(BrushPolygonError::ZeroArea);
}
if !is_convex_xz(vertices) {
Ok(())
}
pub fn validate_floor_polygon(vertices: &[Vec3]) -> Result<(), BrushPolygonError> {
let vertices = normalize_floor_polygon(vertices)?;
validate_simple_floor_polygon(&vertices)?;
if !is_convex_xz(&vertices) {
return Err(BrushPolygonError::NonConvex);
}
Ok(())
}
pub fn decompose_floor_polygon_to_convex(
vertices: &[Vec3],
) -> Result<Vec<Vec<Vec3>>, BrushPolygonError> {
let mut vertices = normalize_floor_polygon(vertices)?;
validate_simple_floor_polygon(&vertices)?;
if is_convex_xz(&vertices) {
if signed_area_xz(&vertices) < 0.0 {
vertices.reverse();
}
return Ok(vec![vertices]);
}
if signed_area_xz(&vertices) < 0.0 {
vertices.reverse();
}
let mut remaining = vertices;
let mut triangles = Vec::with_capacity(remaining.len().saturating_sub(2));
while remaining.len() > 3 {
let Some(ear_index) = find_ear_xz(&remaining) else {
return Err(BrushPolygonError::NonConvex);
};
let prev = (ear_index + remaining.len() - 1) % remaining.len();
let next = (ear_index + 1) % remaining.len();
triangles.push(vec![remaining[prev], remaining[ear_index], remaining[next]]);
remaining.remove(ear_index);
}
triangles.push(remaining);
Ok(merge_convex_parts(triangles))
}
fn merge_convex_parts(mut parts: Vec<Vec<Vec3>>) -> Vec<Vec<Vec3>> {
let mut merged_any = true;
while merged_any {
merged_any = false;
'pairs: for a in 0..parts.len() {
for b in (a + 1)..parts.len() {
let Some(merged) = merge_convex_pair(&parts[a], &parts[b]) else {
continue;
};
parts[a] = merged;
parts.remove(b);
merged_any = true;
break 'pairs;
}
}
}
parts
}
fn merge_convex_pair(a: &[Vec3], b: &[Vec3]) -> Option<Vec<Vec3>> {
let mut edges = Vec::<(Vec3, Vec3)>::with_capacity(a.len() + b.len());
for part in [a, b] {
for index in 0..part.len() {
edges.push((part[index], part[(index + 1) % part.len()]));
}
}
let mut boundary = Vec::<(Vec3, Vec3)>::new();
let mut removed_shared_edges = 0;
for (index, edge) in edges.iter().enumerate() {
let is_reversed_duplicate = edges.iter().enumerate().any(|(other_index, other)| {
index != other_index && same_point_xz(edge.0, other.1) && same_point_xz(edge.1, other.0)
});
if is_reversed_duplicate {
removed_shared_edges += 1;
} else {
boundary.push(*edge);
}
}
if removed_shared_edges != 2 || boundary.len() < 3 {
return None;
}
let mut polygon = Vec::with_capacity(boundary.len());
let first = boundary.remove(0);
polygon.push(first.0);
let mut current = first.1;
while !boundary.is_empty() {
let next_index = boundary
.iter()
.position(|edge| same_point_xz(edge.0, current))?;
let (_, next) = boundary.remove(next_index);
if !same_point_xz(current, polygon[0]) {
polygon.push(current);
}
current = next;
}
if !same_point_xz(current, polygon[0]) {
return None;
}
let mut polygon = normalize_floor_polygon(&polygon).ok()?;
if signed_area_xz(&polygon) < 0.0 {
polygon.reverse();
}
validate_floor_polygon(&polygon).ok()?;
Some(polygon)
}
fn find_ear_xz(vertices: &[Vec3]) -> Option<usize> {
vertices.iter().enumerate().find_map(|(index, current)| {
let prev_index = (index + vertices.len() - 1) % vertices.len();
let next_index = (index + 1) % vertices.len();
let prev = vertices[prev_index];
let next = vertices[next_index];
if orient_xz(prev, *current, next) <= EPSILON {
return None;
}
let contains_other_vertex = vertices.iter().enumerate().any(|(candidate, point)| {
candidate != prev_index
&& candidate != index
&& candidate != next_index
&& point_in_triangle_xz(*point, prev, *current, next)
});
(!contains_other_vertex).then_some(index)
})
}
fn point_in_triangle_xz(point: Vec3, a: Vec3, b: Vec3, c: Vec3) -> bool {
let ab = orient_xz(a, b, point);
let bc = orient_xz(b, c, point);
let ca = orient_xz(c, a, point);
ab >= -EPSILON && bc >= -EPSILON && ca >= -EPSILON
}
fn same_point_xz(a: Vec3, b: Vec3) -> bool {
a.xz().distance_squared(b.xz()) <= EPSILON * EPSILON
}
fn self_intersects_xz(vertices: &[Vec3]) -> bool {
for a in 0..vertices.len() {
let b = (a + 1) % vertices.len();
@@ -317,6 +480,57 @@ mod tests {
);
}
#[test]
fn normalizes_adjacent_and_closing_duplicate_floor_points() {
let normalized = normalize_floor_polygon(&[
p(-1.0, -1.0),
p(-1.0, -1.0),
p(1.0, -1.0),
p(1.0, 1.0),
p(-1.0, 1.0),
p(-1.0, -1.0),
])
.expect("normalized polygon");
assert_eq!(normalized.len(), 4);
assert!(validate_floor_polygon(&normalized).is_ok());
}
#[test]
fn decomposes_concave_floor_polygon_into_convex_parts() {
let parts = decompose_floor_polygon_to_convex(&[
p(-1.0, -1.0),
p(1.0, -1.0),
p(0.0, 0.0),
p(1.0, 1.0),
p(-1.0, 1.0),
])
.expect("convex decomposition");
assert_eq!(parts.len(), 2);
for part in parts {
assert!(validate_floor_polygon(&part).is_ok());
}
}
#[test]
fn merges_l_shaped_floor_polygon_to_two_convex_parts() {
let parts = decompose_floor_polygon_to_convex(&[
p(0.0, 0.0),
p(4.0, 0.0),
p(4.0, 1.0),
p(1.0, 1.0),
p(1.0, 4.0),
p(0.0, 4.0),
])
.expect("convex decomposition");
assert_eq!(parts.len(), 2);
for part in parts {
assert!(validate_floor_polygon(&part).is_ok());
}
}
#[test]
fn reports_invalid_brush_faces() {
let mut brush = BrushDesc::default();
@@ -364,4 +578,19 @@ mod tests {
.iter()
.any(|diagnostic| diagnostic.message.contains("non-manifold")));
}
#[test]
fn validates_extruded_prism_winding() {
let brush = BrushDesc::extruded_prism(
&[p(-1.0, -1.0), p(1.0, -1.0), p(1.0, 1.0), p(-1.0, 1.0)],
1.0,
)
.expect("valid prism");
let report = validate_brush(&brush);
assert!(
report.is_valid(),
"unexpected diagnostics: {:?}",
report.diagnostics
);
}
}
+6 -8
View File
@@ -438,11 +438,9 @@ impl BrushDesc {
}
pub fn extruded_prism(base_vertices: &[Vec3], height: f32) -> Option<Self> {
if crate::brush_math::validate_floor_polygon(base_vertices).is_err() {
return None;
}
let mut base = crate::brush_math::normalize_floor_polygon(base_vertices).ok()?;
crate::brush_math::validate_floor_polygon(&base).ok()?;
let height = height.max(0.001);
let mut base = base_vertices.to_vec();
if crate::brush_math::signed_area_xz(&base) < 0.0 {
base.reverse();
}
@@ -450,12 +448,12 @@ impl BrushDesc {
.iter()
.map(|vertex| *vertex + Vec3::Y * height)
.collect();
let mut bottom = base.clone();
bottom.reverse();
let mut top_face = top;
top_face.reverse();
let mut faces = Vec::with_capacity(base.len() + 2);
faces.push(brush_face("face:+y", Vec3::Y, top));
faces.push(brush_face("face:-y", Vec3::NEG_Y, bottom));
faces.push(brush_face("face:+y", Vec3::Y, top_face));
faces.push(brush_face("face:-y", Vec3::NEG_Y, base.clone()));
for index in 0..base.len() {
let next = (index + 1) % base.len();
let a = base[index];