Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.9

0.7.9 / src / verbs / loop_cut.lucb

## Loop Cut: new edge loops across the quads of the group's edge rings,
## after Blender's Loop Cut and Slide. A ring runs through quads only (a
## triangle or an n-gon ends it, as Blender's does); each ring edge gets
## `cuts` new points, slid together toward one side of the ring by `slide`.
## Each quad crossed by the ring splits into `cuts + 1` quads, a triangle on
## a ring edge fans from its far corner to the new points, and any other face
## on a ring edge takes the new points into its boundary, so the surface
## stays closed. Edges keep a direction along the ring, so the cuts line up.
##
## Even slides every cut the same distance (the slide times the ring edges'
## mean spacing), so a loop keeps its shape; with Flip it ends the same
## distance short of the next loop instead, taking that loop's shape. The
## new loops are the output selection; a slide drag runs along the ring
## edges (`loop_cut_rails`).

let loop_cut_parms: ParmSpec[5] = [
    ParmSpec("Cuts", ParmKind.integer, 1.0, 1.0, 64.0, 1, "", "New loops across each ring."),
    ParmSpec("Slide", ParmKind.number, 0.0, -1.0, 1.0, 1, "", "Move the loops toward one side of the ring (-1..1)."),
    ParmSpec("Whole ring", ParmKind.toggle, 1.0, 0.0, 1.0, 1, "", "Cut the whole ring through each of the group's edges; off: only across the group's edges.", more = true),
    ParmSpec("Even", ParmKind.toggle, 0.0, 0.0, 1.0, 1, "", "Slide every cut the same distance, so each loop keeps its shape."),
    ParmSpec("Flip", ParmKind.toggle, 0.0, 0.0, 1.0, 1, "", "With Even: keep each loop the same distance from the next loop on the slide's side, taking its shape.")]

func loop_cut_verb() -> Verb:
    return Verb("Loop Cut", "Modeling", "Cut edge loops across the rings of the group's edges", Domain.edge, true, loop_cut_parms, true, cook_loop_cut,
                section = "Modify", family = "Cut", icon = "loop-cut", picks = pick_edges, drag = 1, drag_mode = "slide", follows = true, wheel = 0,
                rails = loop_cut_rails, gesture = "hover")

struct Rings:
    ## Per edge: the point its ring direction starts from, or -1 off the
    ## ring; and the builder id of its first new point.
    var start: Growing[i32]
    var first_new: Growing[i32]
    ## Per face: the corner whose edge the split enters by, or -1.
    var split: Growing[i32]
    var queue: Growing[i32]
    ## Per ring edge and cut (edge * cuts + k - 1): how far along the edge
    ## from its ring start cut k sits.
    var fractions: Growing[f64]
    var cuts: usize

    func init():
        self.start = Growing[i32]()
        self.first_new = Growing[i32]()
        self.split = Growing[i32]()
        self.queue = Growing[i32]()
        self.fractions = Growing[f64]()
        self.cuts = 1

    func close():
        self.start.close()
        self.first_new.close()
        self.split.close()
        self.queue.close()
        self.fractions.close()

## One cut's settings.
struct LoopCut:
    let cuts: usize
    let slide: f64
    let whole: bool
    let even: bool
    let flip: bool

func loop_cut_settings(input: const VerbInput*) -> LoopCut!:
    if not math.is_finite(input.parms.at(1)): error(errors.invalid, "Loop Cut slide must be finite")
    let cuts = (usize)math.max(1.0, math.min(64.0, input.parms.at(0)))
    return LoopCut(cuts, math.max(-1.0, math.min(1.0, input.parms.at(1))), input.parms.at(2) != 0.0, input.parms.at(3) != 0.0, input.parms.at(4) != 0.0)

func cook_loop_cut(input: const VerbInput*, output: VerbOutput*) -> !:
    let settings = try loop_cut_settings(input)
    let mesh = input.mesh
    let topology = try Topology.of(mesh)
    var rings = Rings()
    defer rings.close()
    let splits = try find_rings(mesh, &topology, input.group, settings, &rings)
    if splits == 0:
        output.warning = "No quad crossed by the group's edge rings to cut; the input passes through"
        return
    try build_cuts(mesh, &topology, &rings, settings, output)

## The rings through the group's edges and where each cut sits on them;
## returns the quads they split.
func find_rings(mesh: const Mesh*, topology: const Topology*, group: Bits, settings: LoopCut, rings: Rings*) -> usize!:
    try rings.start.fill(topology.edges(), -1)
    try rings.first_new.fill(topology.edges(), -1)
    try rings.split.fill(topology.faces(), -1)
    var splits: usize = 0
    for edge in 0..<topology.edges():
        if not group.get(edge) or rings.start.items[edge] >= 0: continue
        rings.start.items[edge] = topology.edge_points[edge * 2]
        splits += try walk_ring_edges(topology, group, settings.whole, rings, (i32)edge)
    try place_cuts(mesh, topology, settings, rings)
    return splits

## Spread the ring from `seed`: across each quad beside a ring edge to the
## opposite edge (in the group, unless the whole ring is cut), carrying the
## direction. Returns the quads it will split.
func walk_ring_edges(topology: const Topology*, group: Bits, whole: bool, rings: Rings*, seed: i32) -> usize!:
    var splits: usize = 0
    rings.queue.clear()
    try rings.queue.push(seed)
    var at: usize = 0
    while at < rings.queue.count:
        let edge = (usize)rings.queue.items[at]
        at += 1
        for slot in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
            let corner = (usize)topology.edge_corners[slot]
            let face = (usize)topology.corner_faces[corner]
            if topology.offsets[face + 1] - topology.offsets[face] != 4: continue
            let opposite = topology.next(topology.next(corner))
            let other = (usize)topology.corner_edges[opposite]
            if other == edge: continue
            if not whole and not group.get(other): continue
            # A quad split already, across the other pair, stops this ring.
            let entered = rings.split.items[face]
            if entered >= 0 and (usize)entered != corner and (usize)entered != opposite: continue
            if entered < 0:
                rings.split.items[face] = (i32)corner
                splits += 1
            if rings.start.items[other] >= 0: continue
            # The corner's point faces the opposite edge's end: the ring
            # direction runs from there when it runs from this corner.
            let from_corner = rings.start.items[edge] == topology.corners[corner]
            rings.start.items[other] = topology.corners[topology.next(opposite)] if from_corner else topology.corners[opposite]
            try rings.queue.push((i32)other)
    return splits

## Where each cut sits on each ring edge, from its ring start: evenly
## spaced and slid by a share of the spacing, or (Even) slid by a distance
## the same on every edge.
func place_cuts(mesh: const Mesh*, topology: const Topology*, settings: LoopCut, rings: Rings*) -> !:
    let cuts = settings.cuts
    rings.cuts = cuts
    try rings.fractions.fill(topology.edges() * cuts, 0.0)
    let step = 1.0 / (f64)(cuts + 1)
    let reach = settings.slide * step * 0.98
    var total = 0.0
    var count = 0.0
    for edge in 0..<topology.edges():
        if rings.start.items[edge] < 0: continue
        total += edge_length(mesh, topology, edge)
        count += 1.0
    let mean = total / count if count > 0.0 else 0.0
    for edge in 0..<topology.edges():
        if rings.start.items[edge] < 0: continue
        let length = edge_length(mesh, topology, edge)
        for k in 1..<cuts + 1:
            let base = (f64)k * step
            var t = base + reach
            if settings.even and length > 0.0:
                # On the mean edge's scale: the rail spans `span`, the slide
                # moves `slid`. Even moves every cut by `slid`; Flip keeps it
                # `span - slid` short of its rail's end.
                let side = -1.0 if settings.slide < 0.0 else 1.0
                let rail = step * 0.98
                let span = rail * mean
                let slid = math.abs(reach) * mean
                let distance = rail * length - (span - slid) if settings.flip else slid
                t = base + side * math.max(0.0, math.min(rail, distance / length))
            rings.fractions.items[edge * cuts + k - 1] = t

func edge_length(mesh: const Mesh*, topology: const Topology*, edge: usize) -> f64:
    return point_of(mesh, topology.edge_points[edge * 2 + 1]).subtract(point_of(mesh, topology.edge_points[edge * 2])).length()

func build_cuts(mesh: const Mesh*, topology: const Topology*, rings: Rings*, settings: LoopCut, output: VerbOutput*) -> !:
    let cuts = settings.cuts
    var builder = &output.builder
    try builder.begin(mesh)
    try builder.copy_points(mesh)
    output.built = true
    for edge in 0..<topology.edges():
        let start = rings.start.items[edge]
        if start < 0: continue
        let a = topology.edge_points[edge * 2]
        let end = topology.edge_points[edge * 2 + 1] if a == start else a
        rings.first_new.items[edge] = (i32)builder.point_count()
        let head = builder.position(start)
        let tail = builder.position(end)
        for k in 1..<cuts + 1:
            let t = rings.fractions.items[edge * cuts + k - 1]
            let parents: i32[2] = [start, end]
            let weights: f32[2] = [(f32)(1.0 - t), (f32)t]
            _ = try builder.mixed_point(head.add(tail.subtract(head).multiply_scalar(t)), parents[..<2], weights[..<2])
    let faces = topology.faces()
    var run: usize = 0
    for face in 0..<faces:
        var touched: usize = 0
        var ring_edge_corner: usize = 0
        for corner in (usize)topology.offsets[face]..<(usize)topology.offsets[face + 1]:
            if rings.start.items[(usize)topology.corner_edges[corner]] >= 0:
                touched += 1
                ring_edge_corner = corner
        if touched == 0: continue
        try builder.copy_faces(mesh, run, face)
        run = face + 1
        let entered = rings.split.items[face]
        if entered >= 0:
            try split_quad(topology, rings, builder, (usize)entered, cuts)
            continue
        if touched == 1 and topology.offsets[face + 1] - topology.offsets[face] == 3:
            try fan_triangle(topology, rings, builder, ring_edge_corner, cuts)
            continue
        try builder.face((i32)face)
        for corner in (usize)topology.offsets[face]..<(usize)topology.offsets[face + 1]:
            try corner_and_cuts(topology, rings, builder, corner, cuts)
        try builder.end_face()
    try builder.copy_faces(mesh, run, faces)

## New point `k` (1..cuts, from the corner's point) on corner `corner`'s edge.
func cut_point(topology: const Topology*, rings: const Rings*, corner: usize, k: usize, cuts: usize) -> i32:
    let edge = (usize)topology.corner_edges[corner]
    let index = k if rings.start.items[edge] == topology.corners[corner] else cuts + 1 - k
    return rings.first_new.items[edge] + (i32)index - 1

## The fraction of the way from corner `corner`'s point to the next that its
## edge's new point `k` (counted from the corner) lies.
func cut_fraction(topology: const Topology*, rings: const Rings*, corner: usize, k: usize, cuts: usize) -> f64:
    let edge = (usize)topology.corner_edges[corner]
    let forward = rings.start.items[edge] == topology.corners[corner]
    let index = k if forward else cuts + 1 - k
    let t = rings.fractions.items[edge * cuts + index - 1]
    return t if forward else 1.0 - t

## Corner `corner` of its face, then the new points on its edge (when it is
## on a ring) in the face's order, their values blended along the edge.
func corner_and_cuts(topology: const Topology*, rings: const Rings*, builder: TopologyBuilder*, corner: usize, cuts: usize) -> !:
    try builder.corner(topology.corners[corner], (i32)corner)
    if rings.start.items[(usize)topology.corner_edges[corner]] < 0: return
    for k in 1..<cuts + 1:
        try edge_corner(topology, rings, builder, corner, k, cuts)

func edge_corner(topology: const Topology*, rings: const Rings*, builder: TopologyBuilder*, corner: usize, k: usize, cuts: usize) -> !:
    let t = (f32)cut_fraction(topology, rings, corner, k, cuts)
    let parents: i32[2] = [(i32)corner, (i32)topology.next(corner)]
    let weights: f32[2] = [1.0 - t, t]
    try builder.mixed_corner(cut_point(topology, rings, corner, k, cuts), parents[..<2], weights[..<2])

## A quad crossed at corner `c0`'s edge and the opposite one: `cuts + 1`
## quads between the cut lines, the side edges keeping any points of
## another ring. Each cut line is selected.
func split_quad(topology: const Topology*, rings: const Rings*, builder: TopologyBuilder*, c0: usize, cuts: usize) -> !:
    let c1 = topology.next(c0)
    let c2 = topology.next(c1)
    let c3 = topology.next(c2)
    let face = (i32)topology.corner_faces[c0]
    for j in 0..<cuts + 1:
        try builder.face(face)
        # A_j, A_{j+1} along c0→c1; B_{j+1}, B_j back along c3→c2.
        if j == 0: try builder.corner(topology.corners[c0], (i32)c0)
        else: try edge_corner(topology, rings, builder, c0, j, cuts)
        if j == cuts: try corner_and_cuts(topology, rings, builder, c1, cuts)
        else: try edge_corner(topology, rings, builder, c0, j + 1, cuts)
        if j == cuts: try builder.corner(topology.corners[c2], (i32)c2)
        else: try edge_corner(topology, rings, builder, c2, cuts - j, cuts)
        if j == 0: try corner_and_cuts(topology, rings, builder, c3, cuts)
        else: try edge_corner(topology, rings, builder, c2, cuts + 1 - j, cuts)
        try builder.end_face()
        if j > 0: try builder.select_edge(cut_point(topology, rings, c0, j, cuts), cut_point(topology, rings, c2, cuts + 1 - j, cuts))

## A triangle with one ring edge (corner `c0`'s): a fan from its far corner
## to the new points, the loops running on to that corner (selected).
func fan_triangle(topology: const Topology*, rings: const Rings*, builder: TopologyBuilder*, c0: usize, cuts: usize) -> !:
    let c1 = topology.next(c0)
    let c2 = topology.next(c1)
    let face = (i32)topology.corner_faces[c0]
    for j in 0..<cuts + 1:
        try builder.face(face)
        if j == 0: try builder.corner(topology.corners[c0], (i32)c0)
        else: try edge_corner(topology, rings, builder, c0, j, cuts)
        if j == cuts: try builder.corner(topology.corners[c1], (i32)c1)
        else: try edge_corner(topology, rings, builder, c0, j + 1, cuts)
        try builder.corner(topology.corners[c2], (i32)c2)
        try builder.end_face()
        if j > 0: try builder.select_edge(cut_point(topology, rings, c0, j, cuts), topology.corners[c2])

## A slide drag's rails: each ring edge's first cut, from where it sits
## toward either end of its slide (the slide at -1 and at +1).
func loop_cut_rails(input: const VerbInput*, rails: Rails*) -> !:
    let settings = try loop_cut_settings(input)
    let mesh = input.mesh
    let topology = try Topology.of(mesh)
    var rings = Rings()
    defer rings.close()
    _ = try find_rings(mesh, &topology, input.group, LoopCut(settings.cuts, 0.0, settings.whole, false, false), &rings)
    let step = 1.0 / (f64)(settings.cuts + 1)
    for edge in 0..<topology.edges():
        let start = rings.start.items[edge]
        if start < 0: continue
        let a = topology.edge_points[edge * 2]
        let head = point_of(mesh, start)
        let tail = point_of(mesh, topology.edge_points[edge * 2 + 1] if a == start else a)
        let t = rings.fractions.items[edge * settings.cuts]
        let at = head.add(tail.subtract(head).multiply_scalar(t))
        try rails.push((i64)edge, at, head.add(tail.subtract(head).multiply_scalar(t + step * 0.98)), 1.0)
        try rails.push((i64)edge, at, head.add(tail.subtract(head).multiply_scalar(t - step * 0.98)), -1.0)