Improve quick brush creation workflow
This commit is contained in:
1 parent
f09d35e54e
commit
48b1448c57
9 files changed
+701
-61
No files matched your search
@@ -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
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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];
|
||||
|
||||
Reference in new issue
Block a user