forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Add segments to ExtrusionBuilder (#13719)

Browse Source 
# Objective

- Add support for `segments` for extrusion-meshes, akin to what is
possible with cylinders

## Solution

- Added a `.segments(segments: usize)` function to `ExtrusionBuilder`.
- Implemented support for segments in the meshing algorithm.
- If you set `.segments(0)`, the meshing will fail, just like it does
with cylinders.

## Additional information

Here is a wireframe of some extrusions with 1, 2, 3, etc. segments:

![image_2024-06-06_233205114](https://github.com/bevyengine/bevy/assets/62256001/358081e2-172d-407b-8bdb-9cda88eb4664)

---------

Co-authored-by: Lynn Büttgenbach <62256001+solis-lumine-vorago@users.noreply.github.com>
This commit is contained in:
Lynn 2024-06-10 14:50:29 +02:00 committed by GitHub
parent 1f61c26d2e
commit 1196186257
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 91 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
crates/bevy_render/src/mesh/primitives/extrusion.rs
View File

@ -91,6 +91,7 @@ where
ExtrusionBuilder {
base_builder: self.base_shape.mesh(),
half_depth: self.half_depth,
segments: 1,
}
}
}
@ -101,8 +102,9 @@ where
P: Primitive2d + Meshable,
P::Output: Extrudable,
{
base_builder: P::Output,
half_depth: f32,
pub base_builder: P::Output,
pub half_depth: f32,
pub segments: usize,
}
impl<P> ExtrusionBuilder<P>
@ -115,8 +117,16 @@ where
Self {
base_builder: base_shape.mesh(),
half_depth: depth / 2.,
segments: 1,
}
}
/// Sets the number of segments along the depth of the extrusion.
/// Must be greater than `0` for the geometry of the mantel to be generated.
pub fn segments(mut self, segments: usize) -> Self {
self.segments = segments;
self
}
}
impl ExtrusionBuilder<Circle> {
@ -218,14 +228,19 @@ where
panic!("The base mesh did not have vertex positions");
};
debug_assert!(self.segments > 0);
let layers = self.segments + 1;
let layer_depth_delta = self.half_depth * 2.0 / self.segments as f32;
let perimeter = self.base_builder.perimeter();
let (vert_count, index_count) =
perimeter
.iter()
.fold((0, 0), |(verts, indices), perimeter| {
(
verts + 2 * perimeter.vertices_per_layer(),
indices + perimeter.indices_per_segment(),
verts + layers * perimeter.vertices_per_layer(),
indices + self.segments * perimeter.indices_per_segment(),
)
});
let mut positions = Vec::with_capacity(vert_count);
@ -253,36 +268,37 @@ where
// Get the index of the next vertex added to the mantel.
let index = positions.len() as u32;
// Push the positions of the two indices and their equivalent points on the back face.
// This works, since the front face has already been moved to the correct depth.
positions.push(a);
positions.push(b);
positions.push([a[0], a[1], -a[2]]);
positions.push([b[0], b[1], -b[2]]);
// Push the positions of the two indices and their equivalent points on each layer.
for i in 0..layers {
let i = i as f32;
let z = a[2] - layer_depth_delta * i;
positions.push([a[0], a[1], z]);
positions.push([b[0], b[1], z]);
// UVs for the mantel are between (0, 0.5) and (1, 1).
uvs.extend_from_slice(&[
[uv_x, 0.5],
[uv_x + uv_delta, 0.5],
[uv_x, 1.],
[uv_x + uv_delta, 1.],
]);
// UVs for the mantel are between (0, 0.5) and (1, 1).
let uv_y = 0.5 + 0.5 * i / self.segments as f32;
uvs.push([uv_x, uv_y]);
uvs.push([uv_x + uv_delta, uv_y]);
}
// The normal is calculated to be the normal of the line segment connecting a and b.
let n = Vec3::from_array([b[1] - a[1], a[0] - b[0], 0.])
.normalize_or_zero()
.to_array();
normals.extend_from_slice(&[n; 4]);
normals.extend_from_slice(&vec![n; 2 * layers]);
// Add the indices for the vertices created above to the mesh.
indices.extend_from_slice(&[
index,
index + 2,
index + 1,
index + 1,
index + 2,
index + 3,
]);
for i in 0..self.segments as u32 {
let base_index = index + 2 * i;
indices.extend_from_slice(&[
base_index,
base_index + 2,
base_index + 1,
base_index + 1,
base_index + 2,
base_index + 3,
]);
}
}
}
PerimeterSegment::Smooth {
@ -296,14 +312,22 @@ where
// we need to store the index of the first vertex that is part of this segment.
let base_index = positions.len() as u32;
// If there is a first vertex, we need to add it and its counterpart on the back face.
// If there is a first vertex, we need to add it and its counterparts on each layer.
// The normal is provided by `segment.first_normal`.
if let Some(i) = segment_indices.first() {
let p = cap_verts[*i as usize];
positions.push(p);
positions.push([p[0], p[1], -p[2]]);
uvs.extend_from_slice(&[[uv_start, 0.5], [uv_start, 1.]]);
normals.extend_from_slice(&[first_normal.extend(0.).to_array(); 2]);
for i in 0..layers {
let i = i as f32;
let z = p[2] - layer_depth_delta * i;
positions.push([p[0], p[1], z]);
let uv_y = 0.5 + 0.5 * i / self.segments as f32;
uvs.push([uv_start, uv_y]);
}
normals.extend_from_slice(&vec![
first_normal.extend(0.).to_array();
layers
]);
}
// For all points inbetween the first and last vertices, we can automatically compute the normals.
@ -315,11 +339,15 @@ where
let b = cap_verts[segment_indices[i] as usize];
let c = cap_verts[segment_indices[i + 1] as usize];
// Add the current vertex and its counterpart on the backface
positions.push(b);
positions.push([b[0], b[1], -b[2]]);
// Add the current vertex and its counterparts on each layer.
for i in 0..layers {
let i = i as f32;
let z = b[2] - layer_depth_delta * i;
positions.push([b[0], b[1], z]);
uvs.extend_from_slice(&[[uv_x, 0.5], [uv_x, 1.]]);
let uv_y = 0.5 + 0.5 * i / self.segments as f32;
uvs.push([uv_x, uv_y]);
}
// The normal for the current vertices can be calculated based on the two neighbouring vertices.
// The normal is interpolated between the normals of the two line segments connecting the current vertex with its neighbours.
@ -333,32 +361,42 @@ where
.extend(0.)
.to_array()
};
normals.extend_from_slice(&[n; 2]);
normals.extend_from_slice(&vec![n; layers]);
}
// If there is a last vertex, we need to add it and its counterpart on the back face.
// If there is a last vertex, we need to add it and its counterparts on each layer.
// The normal is provided by `segment.last_normal`.
if let Some(i) = segment_indices.last() {
let p = cap_verts[*i as usize];
positions.push(p);
positions.push([p[0], p[1], -p[2]]);
uvs.extend_from_slice(&[
[uv_start + uv_segment_delta, 0.5],
[uv_start + uv_segment_delta, 1.],
for i in 0..layers {
let i = i as f32;
let z = p[2] - layer_depth_delta * i;
positions.push([p[0], p[1], z]);
let uv_y = 0.5 + 0.5 * i / self.segments as f32;
uvs.push([uv_start + uv_segment_delta, uv_y]);
}
normals.extend_from_slice(&vec![
last_normal.extend(0.).to_array();
layers
]);
normals.extend_from_slice(&[last_normal.extend(0.).to_array(); 2]);
}
for i in 0..(segment_indices.len() as u32 - 1) {
let index = base_index + 2 * i;
indices.extend_from_slice(&[
index,
index + 1,
index + 2,
index + 2,
index + 1,
index + 3,
]);
let columns = segment_indices.len() as u32;
let segments = self.segments as u32;
let layers = segments + 1;
for s in 0..segments {
for column in 0..(columns - 1) {
let index = base_index + s + column * layers;
indices.extend_from_slice(&[
index,
index + 1,
index + layers,
index + layers,
index + 1,
index + layers + 1,
]);
}
}
}
}