Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.4

0.7.4 / 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)