Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.9

0.7.9 / src / verbs / rotate_edge.lucb

## Rotate Edge: each of the group's edges turns within the two faces beside
## it, after Blender's Rotate Edge and Cinema 4D's Spin Edge: the two faces
## join into one outline and split again along the diagonal one corner on
## (Counterclockwise, seen from the faces' front) or one corner back
## (Clockwise). An edge on a boundary, of three or more faces, sharing a
## face with an edge turned before it, or whose new diagonal is an edge
## already is left, and counted in the warning. The new edges are the
## output selection.

let rotate_edge_parms: ParmSpec[1] = [
    ParmSpec("Direction", ParmKind.menu, 0.0, 0.0, 1.0, 1, "Clockwise|Counterclockwise", "Which way each edge turns, seen from its faces' front.")]

## A face copied with its own point numbers takes an empty slice of this.
let same_points: i32[1] = [0]

func rotate_edge_verb() -> Verb:
    return Verb("Rotate Edge", "Modeling", "Turn each of the group's edges within the two faces beside it", Domain.edge, true, rotate_edge_parms, true, cook_rotate_edge, section = "Modify", family = "Cut", icon = "rotate-tool", picks = pick_edges)

## One turned edge: its two faces and the outline they join into (points
## and, per point, its corner in the first face and in the second; -1 where
## it has none), and where the new diagonal's ends sit on it.
struct Turn:
    var points: Growing[i32]
    var first_corners: Growing[i32]
    var second_corners: Growing[i32]

    func init():
        self.points = Growing[i32]()
        self.first_corners = Growing[i32]()
        self.second_corners = Growing[i32]()

    func close():
        self.points.close()
        self.first_corners.close()
        self.second_corners.close()

func cook_rotate_edge(input: const VerbInput*, output: VerbOutput*) -> !:
    let counterclockwise = input.parms.at(0) != 0.0
    let mesh = input.mesh
    let topology = try Topology.of(mesh)
    let faces = topology.faces()
    # Per face: the turned edge that rebuilds it (-1: none).
    let owner = try new i32[faces] --- in memory.heap
    defer free(owner) in memory.heap
    for face in 0..<faces: owner[face] = -1
    var skipped: usize = 0
    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:
            skipped += 1
            continue
        let a = (usize)topology.corner_faces[(usize)topology.edge_corners[first]]
        let b = (usize)topology.corner_faces[(usize)topology.edge_corners[first + 1]]
        if a == b or owner[a] >= 0 or owner[b] >= 0:
            skipped += 1
            continue
        owner[a] = (i32)edge
        owner[b] = (i32)edge
    var builder = &output.builder
    try builder.begin(mesh)
    try builder.copy_points(mesh)
    output.built = true
    var outline = Turn()
    defer outline.close()
    var run: usize = 0
    for face in 0..<faces:
        let edge = owner[face]
        if edge < 0: continue
        try builder.copy_faces(mesh, run, face)
        run = face + 1
        # Each pair is rebuilt at its lower face's place.
        let first = (usize)topology.edge_corner_offsets[(usize)edge]
        let one = (usize)topology.edge_corners[first]
        let other = (usize)topology.edge_corners[first + 1]
        if (usize)topology.corner_faces[one] != face and (usize)topology.corner_faces[other] != face: continue
        let lower = one if (usize)topology.corner_faces[one] < (usize)topology.corner_faces[other] else other
        if (usize)topology.corner_faces[lower] != face: continue
        let upper = other if lower == one else one
        if not try rotated_pair(&topology, &outline, lower, upper, counterclockwise, builder):
            skipped += 1
            try builder.copy_face(mesh, (usize)topology.corner_faces[lower], same_points[..<0])
            try builder.copy_face(mesh, (usize)topology.corner_faces[upper], same_points[..<0])
    try builder.copy_faces(mesh, run, faces)
    if builder.selected_edges.count == 0:
        output.warning = "No edge of the group could outline (each needs two faces of its own); the input passes through"
    elif skipped > 0:
        output.warning = "Edges on a boundary, sharing a face with another, or whose new diagonal exists already were left"

## The faces of corners `lower` and `upper` (which share an edge) joined
## and split along the diagonal turned one corner on; false when that
## diagonal is an edge already or leaves a face under three corners.
func rotated_pair(topology: const Topology*, outline: Turn*, lower: usize, upper: usize, counterclockwise: bool, builder: TopologyBuilder*) -> bool!:
    outline.points.clear()
    outline.first_corners.clear()
    outline.second_corners.clear()
    # The outline: the first face from the edge's far end round to its near
    # end, then the second face's corners between.
    let near = (usize)topology.corners[lower]
    var at = topology.next(lower)
    while true:
        try outline.points.push(topology.corners[at])
        try outline.first_corners.push((i32)at)
        try outline.second_corners.push(-1)
        if at == lower: break
        at = topology.next(at)
    let start_second = outline.points.count
    at = topology.next(topology.next(upper))
    while at != upper:
        try outline.points.push(topology.corners[at])
        try outline.first_corners.push(-1)
        try outline.second_corners.push((i32)at)
        at = topology.next(at)
    let size = outline.points.count
    # The old diagonal runs from the outline's first point (the edge's far
    # end) to point `start_second - 1` (its near end); each end moves one
    # point along the outline.
    let old_far: usize = 0
    let old_near = start_second - 1
    if (usize)outline.points.items[old_near] != near: return false
    let step = 1 if counterclockwise else size - 1
    let u = (old_far + step) % size
    let v = (old_near + step) % size
    if u == v or (u + 1) % size == v or (v + 1) % size == u: return false
    let a = outline.points.items[u]
    let b = outline.points.items[v]
    if connected(topology, (usize)a, (usize)b): return false
    # Each end takes its corner from the face its new face lies mostly in.
    let first_face = topology.corner_faces[lower]
    let second_face = topology.corner_faces[upper]
    try outline_face(topology, outline, u, v, first_face, second_face, builder)
    try outline_face(topology, outline, v, u, first_face, second_face, builder)
    try builder.select_edge(a, b)
    return true

## The outline's points from `head` round to `tail` as one face, whose parent
## is whichever old face holds more of them.
func outline_face(topology: const Topology*, outline: const Turn*, head: usize, tail: usize, first_face: i32, second_face: i32, builder: TopologyBuilder*) -> !:
    let size = outline.points.count
    var firsts: usize = 0
    var seconds: usize = 0
    var at = head
    while true:
        if outline.first_corners.items[at] >= 0: firsts += 1
        if outline.second_corners.items[at] >= 0: seconds += 1
        if at == tail: break
        at = (at + 1) % size
    let take_first = firsts >= seconds
    try builder.face(first_face if take_first else second_face)
    at = head
    while true:
        var corner = outline.first_corners.items[at] if take_first else outline.second_corners.items[at]
        if corner < 0: corner = outline.second_corners.items[at] if take_first else outline.first_corners.items[at]
        if corner < 0: corner = point_corner(topology, outline.points.items[at], first_face if take_first else second_face)
        try builder.corner(outline.points.items[at], corner)
        if at == tail: break
        at = (at + 1) % size
    try builder.end_face()

## A corner of face `face` at point `point`, else any corner at it.
func point_corner(topology: const Topology*, point: i32, face: i32) -> i32:
    let start = (usize)topology.offsets[(usize)face]
    for corner in start..<(usize)topology.offsets[(usize)face + 1]:
        if topology.corners[corner] == point: return (i32)corner
    return -1

## Whether an edge joins points `a` and `b`.
func connected(topology: const Topology*, a: usize, b: usize) -> bool:
    for slot in (usize)topology.point_edge_offsets[a]..<(usize)topology.point_edge_offsets[a + 1]:
        let edge = (usize)topology.point_edges[slot]
        let p = (usize)topology.edge_points[edge * 2]
        let q = (usize)topology.edge_points[edge * 2 + 1]
        if (p == a and q == b) or (p == b and q == a): return true
    return false