dymokomi/luce-geocore
Source of release 0.7.3
0.7.3 / src / verbs / bevel.lucb
## PolyBevel: the group's edges replaced by strips of `segments` faces whose
## sides lie `offset` into the faces beside them, after Houdini's PolyBevel
## and Blender's bevel. Around each vertex of a beveled edge, each face's
## corner there becomes:
##
## - between two beveled edges: one point where their offset lines meet;
## - beside one beveled edge: a point slid along its other edge, as far as
## puts it `offset` from the beveled edge (edges slide once, shared by the
## faces on both sides);
## - between two edges that are not beveled: the slides of its edges, with
## the vertex between them while some edge at the vertex does not slide
## (else the vertex goes).
##
## Each strip runs from one face's offset line to the other's along a profile
## (a quadratic curve whose control point is the vertex for the round 0.5).
## A hole the strips leave at a vertex (the triangle where three beveled
## edges meet, the corner beside an edge ending at a vertex that stays)
## becomes a patch face: the loop of edges among the vertex's new points
## that no face answers. Faces keep their attributes: new corners mix the
## face's corners along the edge they slid on, so UV seams survive; strips
## mix across. The strips and patches are the output selection.
let bevel_parms: ParmSpec[4] = [
ParmSpec("Offset", ParmKind.number, 0.1, 0.0, 100000.0, 1, "", "Distance from each beveled edge to the sides of its strip, measured in the faces beside it.", 1.0),
ParmSpec("Segments", ParmKind.integer, 1.0, 1.0, 64.0, 1, "", "Faces across each strip."),
ParmSpec("Profile", ParmKind.number, 0.5, 0.0, 1.0, 1, "", "Shape across the strip: 0.5 round, toward 1 the original corner, 0 flat."),
ParmSpec("Clamp overlap", ParmKind.toggle, 1.0, 0.0, 1.0, 1, "", "Keep each offset within half of the edges it slides along, so strips cannot cross.")]
func bevel_verb() -> Verb:
return Verb("PolyBevel", "Modeling", "Bevel the group's edges into strips of faces", Domain.edge, true, bevel_parms, true, cook_bevel)
## A new corner of a face: its point, and (for a slide) the face's corner at
## the far end of the edge it slid on, mixed in at `weight`.
struct NewCorner:
let point: i32
let other: i32
let weight: f32
## A new point: position, parents (`a`, or `a` and `b` at `t`) and the bevel
## vertex it belongs to.
struct NewPoint:
let position: Vector3
let a: i32
let b: i32
let t: f32
let slot: i32
struct Bevel:
var topology: Topology
var beveled: Bits
var offset: f64
var segments: usize
var profile: f64
var clamp: bool
var origin: Vector3
var points: const Float3[]
var exact: const Vector3[]
## Per input point: its bevel vertex slot, or -1.
var slot_of: Growing[i32]
## Per slot: the point, its fan (corners in `fans`), whether the fan
## closes, whether the point stays (0 goes, 1 stays, 2 stays at the end
## of its one beveled edge).
var vertex_points: Growing[i32]
var fan_starts: Growing[u32]
var fans: Growing[i32]
var cyclic: Growing[u8]
var fan_valid: Growing[u8]
var retained: Growing[u8]
## Per slot: where its new points and corner entries start (sizes while
## counting; see bevel_corners.lucb).
var slot_points: Growing[u32]
var slot_entries: Growing[u32]
## Per corner at a bevel vertex: its new corners (a run of `sequence`).
var corner_first: Growing[u32]
var corner_count: Growing[u8]
var sequence: Growing[NewCorner]
## New points; their ids follow the input's points.
var created: Growing[NewPoint]
## Profiles (bevel_profiles.lucb): their points, and per edge end (edge * 2,
## + 1 at its end) where its profile starts and whether it runs reversed.
var profile_points: Growing[i32]
var end_profile: Growing[u32]
var end_reversed: Growing[u8]
## Per new point: the first face corner that uses it (corner << 32 |
## its entry in `sequence`), or -1; patches take its corner values.
var point_source: Growing[i64]
## Patches (bevel_patches.lucb): each loop's size, their points, and the
## loops each vertex could not close.
var patch_sizes: Growing[u32]
var patch_points: Growing[i32]
var patch_skipped: Growing[u8]
var skipped: usize
func init(mesh: const Mesh*, topology: Topology, offset: f64, segments: usize, profile: f64, clamp: bool):
self.topology = topology
self.beveled = Bits()
self.offset = offset
self.segments = segments
self.profile = profile
self.clamp = clamp
self.origin = mesh.position_origin()
self.points = mesh.point_span()
self.exact = precise_span(mesh)
self.slot_of = Growing[i32]()
self.vertex_points = Growing[i32]()
self.fan_starts = Growing[u32]()
self.fans = Growing[i32]()
self.cyclic = Growing[u8]()
self.fan_valid = Growing[u8]()
self.slot_points = Growing[u32]()
self.slot_entries = Growing[u32]()
self.retained = Growing[u8]()
self.corner_first = Growing[u32]()
self.corner_count = Growing[u8]()
self.sequence = Growing[NewCorner]()
self.created = Growing[NewPoint]()
self.profile_points = Growing[i32]()
self.end_profile = Growing[u32]()
self.end_reversed = Growing[u8]()
self.point_source = Growing[i64]()
self.patch_sizes = Growing[u32]()
self.patch_points = Growing[i32]()
self.patch_skipped = Growing[u8]()
self.skipped = 0
func close():
self.slot_of.close()
self.vertex_points.close()
self.fan_starts.close()
self.fans.close()
self.cyclic.close()
self.fan_valid.close()
self.slot_points.close()
self.slot_entries.close()
self.retained.close()
self.corner_first.close()
self.corner_count.close()
self.sequence.close()
self.created.close()
self.profile_points.close()
self.end_profile.close()
self.end_reversed.close()
self.point_source.close()
self.patch_sizes.close()
self.patch_points.close()
self.patch_skipped.close()
## Where point `point` is (input or new), in world space.
func point_at(work: const Bevel*, point: i32) -> Vector3:
let at = (usize)point
if at >= work.topology.points: return work.created.items[at - work.topology.points].position
if work.exact.length > 0: return work.exact[at]
return work.points[at].vector().add(work.origin)
func far_end(work: const Bevel*, edge: i32, point: i32) -> i32:
let a = work.topology.edge_points[(usize)edge * 2]
return work.topology.edge_points[(usize)edge * 2 + 1] if a == point else a
func first_point(work: const Bevel*, corner: usize) -> i32:
return work.sequence.items[(usize)work.corner_first.items[corner]].point
func last_point(work: const Bevel*, corner: usize) -> i32:
return work.sequence.items[(usize)work.corner_first.items[corner] + (usize)work.corner_count.items[corner] - 1].point
func cook_bevel(input: const VerbInput*, output: VerbOutput*) -> !:
let offset = input.parms.at(0)
if not math.is_finite(offset) or offset < 0.0: error(errors.invalid, "Bevel offset must be finite and not negative")
let segments = (usize)math.max(1.0, math.min(64.0, input.parms.at(1)))
let mesh = input.mesh
let topology = try Topology.of(mesh)
# Interior manifold edges only: two corners in different faces.
var beveled = try BitsBuilder.zeros(topology.edges())
defer beveled.close()
for edge in 0..<topology.edges():
if not input.group.get(edge): continue
let first = (usize)topology.edge_corner_offsets[edge]
if (usize)topology.edge_corner_offsets[edge + 1] - first != 2: continue
if topology.corner_faces[(usize)topology.edge_corners[first]] == topology.corner_faces[(usize)topology.edge_corners[first + 1]]: continue
beveled.set(edge)
if offset == 0.0 or not beveled.view().any():
output.warning = "No interior edges in the group to bevel (or a zero offset); the input passes through"
return
var work = Bevel(mesh, topology, offset, segments, math.max(0.0, math.min(1.0, input.parms.at(2))), input.parms.at(3) != 0.0)
defer work.close()
try find_fans(&work, mesh, &beveled)
if not beveled.view().any():
output.warning = "The group's edges meet at points without a single fan of faces; the input passes through"
return
work.beveled = beveled.view()
try place_corners(&work)
try build(&work, mesh, output)
if work.skipped > 0: output.warning = "Some bevel corners could not be closed or edges beveled and were left as they were"
## Emit the mesh: the input's points and the new ones, the faces (untouched
## runs copied whole), strips, patches; then drop the vertices that went.
func build(work: Bevel*, mesh: const Mesh*, output: VerbOutput*) -> !:
let topology = &work.topology
let n = work.segments
# Profiles first, so every new point exists before any is emitted.
try place_profiles(work)
var builder = &output.builder
try builder.begin(mesh)
try builder.copy_points(mesh)
output.built = true
for made in work.created.view():
if made.b >= 0:
let parents: i32[2] = [made.a, made.b]
let weights: f32[2] = [1.0 - made.t, made.t]
_ = try builder.mixed_point(made.position, parents[..<2], weights[..<2])
else:
_ = try builder.point(made.position, made.a)
let faces = topology.faces()
var run: usize = 0
for face in 0..<faces:
var touched = false
for corner in (usize)topology.offsets[face]..<(usize)topology.offsets[face + 1]:
if work.slot_of.items[(usize)topology.corners[corner]] >= 0: touched = true
if not touched: continue
try builder.copy_faces(mesh, run, face)
run = face + 1
try builder.face((i32)face)
for corner in (usize)topology.offsets[face]..<(usize)topology.offsets[face + 1]:
if work.slot_of.items[(usize)topology.corners[corner]] < 0:
try builder.corner(topology.corners[corner], (i32)corner)
continue
let start = (usize)work.corner_first.items[corner]
for at in start..<start + (usize)work.corner_count.items[corner]:
let made = work.sequence.items[at]
if made.other < 0:
try builder.corner(made.point, (i32)corner)
else:
let parents: i32[2] = [(i32)corner, made.other]
let weights: f32[2] = [1.0 - made.weight, made.weight]
try builder.mixed_corner(made.point, parents[..<2], weights[..<2])
try builder.end_face()
try builder.copy_faces(mesh, run, faces)
let bevel_first = builder.face_count()
# Strips: quads between the profiles at the edge's two ends, facing the
# way face 1 does.
for edge in 0..<topology.edges():
if not work.beveled.get(edge): continue
let first = (usize)topology.edge_corner_offsets[edge]
let c1 = (usize)topology.edge_corners[first]
let c2 = (usize)topology.edge_corners[first + 1]
let c1_end = topology.next(c1)
let c2_end = topology.next(c2)
let face = topology.corner_faces[c1]
# Each side blends the corner values its faces gave its end points.
let start_mix = CornerPair(c1, last_entry(work, c1), c2_end, first_entry(work, c2_end))
let end_mix = CornerPair(c1_end, first_entry(work, c1_end), c2, last_entry(work, c2))
# A lone edge's end vertex joins a one-segment strip between its
# side points (with more segments it is the profile's inner points).
let start_vertex = terminal(work, topology.corners[c1])
let end_vertex = terminal(work, topology.corners[c2])
for step in 0..<n:
let t0 = (f32)step / (f32)n
let t1 = (f32)(step + 1) / (f32)n
var ring = Ring()
ring.add(profile_point(work, edge, 1, step), 1, t0)
ring.add(profile_point(work, edge, 0, step), 0, t0)
if n == 1 and start_vertex >= 0: ring.add(start_vertex, 0, 0.5)
ring.add(profile_point(work, edge, 0, step + 1), 0, t1)
ring.add(profile_point(work, edge, 1, step + 1), 1, t1)
if n == 1 and end_vertex >= 0: ring.add(end_vertex, 1, 0.5)
if ring.count > 1 and ring.points[ring.count - 1] == ring.points[0]: ring.count -= 1
# Both ends' inner points are the vertices: that segment is the
# edge between them, and the segments beside it share it.
if ring.count < 3: continue
try builder.face(face)
for index in 0..<ring.count:
let pair = start_mix if ring.sides[index] == 0 else end_mix
let vertex = start_vertex if ring.sides[index] == 0 else end_vertex
if ring.points[index] == vertex:
let parents: i32[2] = [(i32)pair.first_corner, (i32)pair.second_corner]
let weights: f32[2] = [0.5, 0.5]
try builder.mixed_corner(vertex, parents[..<2], weights[..<2])
else:
try strip_corner(work, builder, ring.points[index], pair, ring.t[index])
try builder.end_face()
try patches(work, builder)
output.selection = try BitsBuilder.zeros(builder.face_count())
output.selection.set_range(bevel_first, builder.face_count())
output.selection_domain = Domain.face
try builder.drop_unused_points()
## The vertex `point` when it stays at the end of its one beveled edge,
## else -1.
func terminal(work: const Bevel*, point: i32) -> i32:
let slot = work.slot_of.items[(usize)point]
return point if slot >= 0 and work.retained.items[(usize)slot] == 2 else -1
## The corners of one strip segment, without repeats: each point, its side
## (0 the edge's start, 1 its end) and where across the strip it is.
struct Ring:
var points: i32[6]
var sides: u8[6]
var t: f32[6]
var count: usize = 0
func add(point: i32, side: u8, t: f32):
if self.count > 0 and self.points[self.count - 1] == point: return
self.points[self.count] = point
self.sides[self.count] = side
self.t[self.count] = t
self.count += 1
## One side of a strip: face 1's corner and new-corner entry at its end
## point, and face 2's.
struct CornerPair:
let first_corner: usize
let first_entry: usize
let second_corner: usize
let second_entry: usize
func first_entry(work: const Bevel*, corner: usize) -> usize:
return (usize)work.corner_first.items[corner]
func last_entry(work: const Bevel*, corner: usize) -> usize:
return (usize)work.corner_first.items[corner] + (usize)work.corner_count.items[corner] - 1
## A strip corner at `t` across: the two faces' corner values blended.
func strip_corner(work: const Bevel*, builder: TopologyBuilder*, point: i32, pair: CornerPair, t: f32) -> !:
var parents: i32[4]
var weights: f32[4]
var count: usize = 0
for side in 0..<(usize)2:
let share = 1.0 - t if side == 0 else t
if share <= 0.0: continue
let corner = pair.first_corner if side == 0 else pair.second_corner
let made = work.sequence.items[pair.first_entry if side == 0 else pair.second_entry]
parents[count] = (i32)corner
weights[count] = share * (1.0 - made.weight if made.other >= 0 else 1.0)
count += 1
if made.other >= 0:
parents[count] = made.other
weights[count] = share * made.weight
count += 1
try mixed_or_single(builder, point, parents[..<count], weights[..<count])
func mixed_or_single(builder: TopologyBuilder*, point: i32, parents: const i32[], weights: const f32[]) -> !:
if parents.length == 1: return try builder.corner(point, parents[0])
try builder.mixed_corner(point, parents, weights)