Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.8

0.7.8 / src / verbs / bevel_emit.lucb

## PolyBevel's output: every input face (rebuilt where it touches a bevel
## vertex), then the strips, then the vertex patches.
##
## A face touching a bevel vertex takes, in the vertex's place, the ring's
## points from the boundary point on its arriving edge clockwise round to
## the one on its leaving edge, with any profile points between. A strip
## runs between the profiles at its edge's two ends. New corners take the
## values of the face they lie in, interpolated at their position by mean
## value coordinates in that face's plane (so UVs carry on across the
## bevel): a rebuilt face's own face, a strip's face on that side of its
## middle, a patch's face beside its boundary point. New points copy the
## bevel vertex they replace. The strips and patches are the output
## selection; the bevel vertices go.
##
## The work is split into pieces (ranges of input faces, of edges, of
## bevel vertices), each filling its own batch of faces in parallel; the
## batches join in order (face_batch.lucb), so the output is the same
## whatever the threads.
## What emitting collects for the finishing passes (bevel_marks.lucb),
## each part only when a pass wants it.
struct Emitted:
    ## Per output face: its kind (face_kept…): Harden normals, Face strength.
    var kinds: Growing[u8]
    ## Per output corner: whether its edge runs along a strip (Harden
    ## normals).
    var long: Growing[u8]
    ## Output edges that continue an input edge, as point pairs: what
    ## values they take (0 every edge value, 1 the seam, 2 the sharp mark)
    ## and from which input edge (when the mesh has edge values).
    var pairs: Growing[i32]
    var sources: Growing[i32]
    var what: Growing[u8]
    var first_new_face: usize
    var wants_kinds: bool
    var wants_long: bool
    var wants_pairs: bool

    func init():
        self.kinds = Growing[u8]()
        self.long = Growing[u8]()
        self.pairs = Growing[i32]()
        self.sources = Growing[i32]()
        self.what = Growing[u8]()
        self.first_new_face = 0
        self.wants_kinds = false
        self.wants_long = false
        self.wants_pairs = false

    func close():
        self.kinds.close()
        self.long.close()
        self.pairs.close()
        self.sources.close()
        self.what.close()

    ## Collect what `other` collects.
    func wanting(other: const Emitted*):
        self.wants_kinds = other.wants_kinds
        self.wants_long = other.wants_long
        self.wants_pairs = other.wants_pairs

    func pair(a: i32, b: i32, source: i32, what: u8) -> !:
        if not self.wants_pairs or a < 0 or b < 0 or a == b: return
        try self.pairs.push(a)
        try self.pairs.push(b)
        try self.sources.push(source)
        try self.what.push(what)

## One face being emitted: its points and, per point, the input face its
## corner values come from.
struct FaceDraft:
    var points: Growing[i32]
    var faces: Growing[i32]

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

    func close():
        self.points.close()
        self.faces.close()

    func clear():
        self.points.clear()
        self.faces.clear()

    ## Add a point (a repeat of the last one is dropped).
    func add(point: i32, face: i32) -> !:
        if point < 0: return
        if self.points.count > 0 and self.points.items[self.points.count - 1] == point: return
        try self.points.push(point)
        try self.faces.push(face)

## Which interpolation a point's corners in a face share (the last one
## made for each place of the cache): the corners round a new point in one
## input face store one mix, not one each.
let mix_cache_size: usize = 1024

struct MixCache:
    var points: i32[1024]
    var faces: i32[1024]
    var codes: i32[1024]

func empty_cache() -> MixCache:
    var cache: MixCache = ---
    for at in 0..<mix_cache_size:
        cache.points[at] = -1
        cache.faces[at] = -1
        cache.codes[at] = 0
    return cache

## A piece of the output: a range of input faces, of edges (their strips)
## or of bevel vertices (their patches).
let piece_faces: u8 = 0
let piece_strips: u8 = 1
let piece_patches: u8 = 2

struct Piece:
    var kind: u8
    var first: usize
    var end: usize

## How many faces, edges and vertices a piece takes.
let faces_per_piece: usize = 4096
let edges_per_piece: usize = 8192
let vertices_per_piece: usize = 2048

## One piece's output: its faces, and the parts of Emitted for them.
struct EmitBatch:
    var faces: FaceBatch
    var emitted: Emitted
    var draft: FaceDraft
    var cache: MixCache

    func init():
        self.faces = FaceBatch()
        self.emitted = Emitted()
        self.draft = FaceDraft()
        self.cache = empty_cache()

    func close():
        self.faces.close()
        self.emitted.close()
        self.draft.close()

struct Emitting:
    var work: const Bevel*
    ## What the whole output collects (each batch the same).
    var whole: const Emitted*
    var pieces: const Piece[]
    var batches: EmitBatch[]
    ## The output points so far, measured from `origin`.
    var positions: const Vector3[]
    var origin: Vector3

func emit(work: Bevel*, output: VerbOutput*) -> !:
    let mesh = work.mesh
    let topology = &work.topology
    var builder = &output.builder
    try builder.begin(mesh)
    try builder.copy_points(mesh)
    output.built = true
    try place_grid_points(work, builder)
    var emitted = Emitted()
    defer emitted.close()
    emitted.wants_kinds = work.settings.harden or work.settings.strength > 0
    emitted.wants_long = work.settings.harden
    emitted.wants_pairs = carries_edge_values(mesh)
    # The pieces in output order: input faces, strips, patches.
    var pieces = Growing[Piece]()
    defer pieces.close()
    try add_pieces(&pieces, piece_faces, topology.faces(), faces_per_piece)
    let face_pieces = pieces.count
    if not work.settings.vertices: try add_pieces(&pieces, piece_strips, topology.edges(), edges_per_piece)
    try add_pieces(&pieces, piece_patches, work.vertices.count, vertices_per_piece)
    let batches = try new EmitBatch[pieces.count] --- in memory.heap
    for at in 0..<pieces.count: batches[at] = EmitBatch()
    defer close_batches(batches)
    var emitting = Emitting(work, &emitted, pieces.view(), batches, builder.positions.view(), builder.origin)
    try parallel.for_each(pieces.count, (void*)&emitting, emit_piece)
    # Join the batches in order.
    var faces = try new FaceBatch[pieces.count] --- in memory.heap
    defer free(faces) in memory.heap
    for at in 0..<pieces.count: faces[at] = batches[at].faces
    try append_batches(builder, mesh, faces[..<pieces.count])
    for at in 0..<face_pieces: emitted.first_new_face += batches[at].faces.face_count()
    for at in 0..<pieces.count: try join_emitted(&emitted, &batches[at].emitted)
    try unbeveled_pairs(work, &emitted)
    try mark_runs(work, &emitted)
    output.selection = try BitsBuilder.zeros(builder.face_count())
    output.selection.set_range(emitted.first_new_face, builder.face_count())
    output.selection_domain = Domain.face
    try drop_points(builder, &emitted)
    try finish_bevel(work, output, &emitted)

func close_batches(batches: EmitBatch[]):
    for at in 0..<batches.length: batches[at].close()
    free(batches) in memory.heap

## Pieces of `kind` over `count` items, `size` each.
func add_pieces(pieces: Growing[Piece]*, kind: u8, count: usize, size: usize) -> !:
    var first: usize = 0
    while first < count:
        let end = first + size if count - first > size else count
        try pieces.push(Piece(kind, first, end))
        first = end

## Append a batch's collected parts.
func join_emitted(into: Emitted*, part: const Emitted*) -> !:
    try append_all(&into.kinds, part.kinds.view())
    try append_all(&into.long, part.long.view())
    try append_all(&into.pairs, part.pairs.view())
    try append_all(&into.sources, part.sources.view())
    try append_all(&into.what, part.what.view())

func append_all[T](into: Growing[T]*, values: const T[]) -> !:
    if values.length == 0: return
    try into.reserve(into.count + values.length)
    memory.copy(into.items[into.count..], values, values.length)
    into.count += values.length

## Whether the mesh has edge values a strip's sides carry on.
func carries_edge_values(mesh: const Mesh*) -> bool:
    for index in 0..<(usize)mesh.attribute_count():
        let entry = mesh.attribute_entry((i64)index) catch failure:
            return true
        if entry.domain == Domain.edge and entry.storage == Storage.array and entry.kind != DataType.text and not hidden_name(entry.name()): return true
    return false

func emit_piece(context: void*, index: usize, worker: usize) -> !:
    let emitting = (Emitting*)context
    let work = emitting.work
    let piece = emitting.pieces[index]
    let batch = &emitting.batches[index]
    batch.emitted.wanting(emitting.whole)
    if piece.kind == piece_faces:
        try face_piece(emitting, batch, piece.first, piece.end)
    elif piece.kind == piece_strips:
        for edge in piece.first..<piece.end:
            if work.beveled.view().get(edge): try strip_faces(emitting, batch, (i32)edge)
    else:
        for slot in piece.first..<piece.end: try vertex_faces(emitting, batch, (i32)slot)

## Input faces first..<end: copied whole, or rebuilt round the bevel
## vertices they touch.
func face_piece(emitting: const Emitting*, batch: EmitBatch*, first: usize, end: usize) -> !:
    let work = emitting.work
    let topology = &work.topology
    for face in first..<end:
        let corner_first = (usize)topology.offsets[face]
        let corner_end = (usize)topology.offsets[face + 1]
        var touched = false
        for corner in corner_first..<corner_end:
            if work.slot_of.items[(usize)topology.corners[corner]] >= 0: touched = true
        if not touched:
            try batch.faces.copy_face(topology.offsets, face)
            if batch.emitted.wants_kinds: try batch.emitted.kinds.push(face_kept)
            if batch.emitted.wants_long: try batch.emitted.long.extend(batch.emitted.long.count + corner_end - corner_first, 0)
            continue
        var draft = &batch.draft
        draft.clear()
        for corner in corner_first..<corner_end:
            let point = topology.corners[corner]
            let slot = work.slot_of.items[(usize)point]
            if slot < 0:
                try draft.add(point, (i32)face)
                continue
            try rebuilt_corner(work, draft, slot, corner, (i32)face)
        try finish_face(emitting, batch, (i32)face, face_rebuilt)

## Give every grid point that is its own an output point (copying the bevel
## vertex), and every alias its root's. Points of one vertex mesh that fall
## on one place (a square or hollow shape folds profiles onto the vertex or
## onto each other) become one point, so the faces between them collapse
## instead of keeping no area. Vertices in parallel: each numbers its own
## places, then takes its share of the new points in order.
func place_grid_points(work: Bevel*, builder: TopologyBuilder*) -> !:
    try work.grid_ids.fill(work.grid.count, -1)
    let vertices = work.vertices.count
    var places = try new usize[vertices + 1] --- in memory.heap
    defer free(places) in memory.heap
    var placing = Placing(work, builder, places[..<vertices + 1])
    try parallel.for_each_range(vertices, 1024, (void*)&placing, number_places)
    var total: usize = 0
    for slot in 0..<vertices:
        let count = places[slot]
        places[slot] = total
        total += count
    places[vertices] = total
    let first = builder.positions.count
    try builder.positions.reserve(first + total)
    try builder.point_parents.reserve(first + total)
    builder.positions.count = first + total
    builder.point_parents.count = first + total
    try parallel.for_each_range(vertices, 1024, (void*)&placing, make_places)
    try parallel.for_each_range(work.grid.count, 65536, (void*)&placing, link_places)

struct Placing:
    var work: Bevel*
    var builder: TopologyBuilder*
    ## Per vertex: how many places, then the first of them among the new
    ## points.
    var places: usize[]

## A place's number while a vertex numbers them: its first point keeps the
## number, the points welded to it -3 - number.
func place_number(id: i32) -> i32:
    return id if id >= 0 else -3 - id

func number_places(context: void*, first: usize, end: usize, worker: usize) -> !:
    let placing = (Placing*)context
    let work = placing.work
    var owned = Growing[u32]()
    defer owned.close()
    let segments = work.settings.segments
    for slot in first..<end:
        placing.places[slot] = 0
        let vertex = work.vertices.items[slot]
        if vertex.grid < 0: continue
        let size = (usize)vertex.bounds * (segments // 2 + 1) * (segments + 1)
        owned.clear()
        for at in (usize)vertex.grid..<(usize)vertex.grid + size:
            if work.grid_links.items[at] == -2: try owned.push((u32)at)
        sort_by_x(work, owned.items[..<owned.count])
        var count: i32 = 0
        for index in 0..<owned.count:
            let at = (usize)owned.items[index]
            let position = work.grid.items[at]
            # An earlier point at the same place (they are sorted by x).
            var same: i64 = -1
            var back = index
            while back > 0:
                back -= 1
                let other = (usize)owned.items[back]
                if position.x - work.grid.items[other].x > weld_distance: break
                if work.grid.items[other].subtract(position).length() <= weld_distance:
                    same = (i64)other
                    break
            if same >= 0:
                work.grid_ids.items[at] = -3 - place_number(work.grid_ids.items[(usize)same])
            else:
                work.grid_ids.items[at] = count
                count += 1
        placing.places[slot] = (usize)count

## Each vertex's own points become output points at its first place on.
func make_places(context: void*, first: usize, end: usize, worker: usize) -> !:
    let placing = (Placing*)context
    let work = placing.work
    let builder = placing.builder
    let base = builder.positions.count - placing.places[work.vertices.count]
    let segments = work.settings.segments
    for slot in first..<end:
        let vertex = work.vertices.items[slot]
        if vertex.grid < 0: continue
        let size = (usize)vertex.bounds * (segments // 2 + 1) * (segments + 1)
        let start = base + placing.places[slot]
        for at in (usize)vertex.grid..<(usize)vertex.grid + size:
            if work.grid_links.items[at] != -2: continue
            let id = work.grid_ids.items[at]
            let point = start + (usize)place_number(id)
            if id >= 0:
                builder.positions.items[point] = work.grid.items[at].subtract(builder.origin)
                builder.point_parents.items[point] = vertex.point
            work.grid_ids.items[at] = (i32)point

## Every alias takes its root's output point.
func link_places(context: void*, first: usize, end: usize, worker: usize) -> !:
    let work = ((Placing*)context).work
    for at in first..<end:
        if work.grid_links.items[at] < 0: continue
        var chain_root = at
        var steps = 0
        while work.grid_links.items[chain_root] >= 0 and steps < 64:
            chain_root = (usize)work.grid_links.items[chain_root]
            steps += 1
        if work.grid_links.items[chain_root] == -2: work.grid_ids.items[at] = work.grid_ids.items[chain_root]

## How near two points of a vertex mesh are to count as one.
let weld_distance: f64 = 0.0000000001

## Sort grid indices by their points' x (insertion sort: a vertex mesh is
## small and nearly in order).
func sort_by_x(work: const Bevel*, indices: u32[]):
    for at in 1..<indices.length:
        let value = indices[at]
        let x = work.grid.items[(usize)value].x
        var place = at
        while place > 0 and work.grid.items[(usize)indices[place - 1]].x > x:
            indices[place] = indices[place - 1]
            place -= 1
        indices[place] = value

## The output point at (i, j, k) of vertex `slot`'s mesh, or -1.
func vm_point(work: const Bevel*, slot: i32, i: usize, j: usize, k: usize) -> i32:
    return work.grid_ids.items[vm_index(work, slot, i, j, k)]

## The output point of boundary point `bound`.
func bound_point(work: const Bevel*, bound: i32) -> i32:
    let item = &work.bounds.items[(usize)bound]
    return vm_point(work, item.slot, (usize)item.index, 0, 0)

## In face `face`'s corner `corner` at bevel vertex `slot`: the ring's
## points from the boundary point on the arriving edge clockwise to the one
## on the leaving edge (the face goes clockwise round the vertex), with
## the profile points between; an arc's attached edge starts or ends partway
## along its profile.
func rebuilt_corner(work: const Bevel*, draft: FaceDraft*, slot: i32, corner: usize, face: i32) -> !:
    let topology = &work.topology
    let leaving = half_of(work, slot, topology.corner_edges[corner])
    let arriving = half_of(work, slot, topology.corner_edges[topology.previous(corner)])
    let segments = work.settings.segments
    var current = work.halves.items[(usize)arriving].left
    let last = work.halves.items[(usize)leaving].right
    var on_profile = false
    if work.halves.items[(usize)arriving].profile_index > 0:
        current = next_bound(work, current)
        on_profile = true
    if not on_profile: try draft.add(bound_point(work, current), face)
    var steps: u32 = 0
    let limit = work.vertices.items[(usize)slot].bounds + 1
    while current != last and steps < limit:
        let previous = previous_bound(work, current)
        let i = (usize)work.bounds.items[(usize)previous].index
        var k_start = (i64)segments - 1
        if on_profile:
            k_start = (i64)work.halves.items[(usize)arriving].profile_index
            on_profile = false
        var k_end: i64 = 0
        if work.halves.items[(usize)leaving].right == previous and work.halves.items[(usize)leaving].profile_index > 0: k_end = (i64)work.halves.items[(usize)leaving].profile_index
        var k = k_start
        while k >= k_end:
            try draft.add(vm_point(work, slot, i, 0, (usize)k), face)
            k -= 1
        current = previous
        steps += 1

## Close the batch's draft as one output face with parent `parent` and
## kind `kind`, each corner interpolated in its draft face (an input point's
## corner of that face copies its own values).
func finish_face(emitting: const Emitting*, batch: EmitBatch*, parent: i32, kind: u8) -> !:
    let work = emitting.work
    let draft = &batch.draft
    var count = draft.points.count
    if count > 1 and draft.points.items[count - 1] == draft.points.items[0]: count -= 1
    if count < 3: return
    try batch.faces.face(parent)
    for at in 0..<count:
        let point = draft.points.items[at]
        let face = draft.faces.items[at]
        if point < (i32)work.topology.points:
            # An input point kept: its corner in the face is copied.
            let corner = face_corner(work, face, point)
            if corner >= 0:
                try batch.faces.corner(point, (i32)corner)
                continue
        try interpolated_corner(emitting, batch, point, face)
    try batch.faces.end_face()
    if batch.emitted.wants_kinds: try batch.emitted.kinds.push(kind)
    if batch.emitted.wants_long:
        for at in 0..<count: try batch.emitted.long.push(1 if kind == face_strip and (at == 0 or at == 2) else 0)

## A corner at output point `point` whose values are face `face`'s,
## interpolated at the point's position (shared with the point's other
## corners in that face while the cache holds it).
func interpolated_corner(emitting: const Emitting*, batch: EmitBatch*, point: i32, face: i32) -> !:
    let at = (usize)point % mix_cache_size
    if batch.cache.points[at] == point and batch.cache.faces[at] == face:
        return try batch.faces.shared_corner(point, batch.cache.codes[at])
    var parents: i32[64] = ---
    var weights: f32[64] = ---
    let position = emitting.positions[(usize)point].add(emitting.origin)
    let count = mvc_weights(emitting.work, face, position, parents[..<64], weights[..<64])
    let code = parents[0] if count == 1 else try batch.faces.shared_mix(parents[..<count], weights[..<count])
    try batch.faces.shared_corner(point, code)
    batch.cache.points[at] = point
    batch.cache.faces[at] = face
    batch.cache.codes[at] = code

## Mean value coordinates of `position` in input face `face` (projected to
## its plane): weights of its corners into `parents` and `weights`, exact at
## a corner or on an edge; how many. A face of more than 64 corners takes
## its nearest corner.
func mvc_weights(work: const Bevel*, face: i32, position: Vector3, parents: i32[], weights: f32[]) -> usize:
    let topology = &work.topology
    let first = (usize)topology.offsets[(usize)face]
    let end = (usize)topology.offsets[(usize)face + 1]
    let size = end - first
    if size > 64:
        var best = first
        var best_distance = norm(input_point(work, topology.corners[first]).subtract(position))
        for corner in first..<end:
            let distance = norm(input_point(work, topology.corners[corner]).subtract(position))
            if distance < best_distance:
                best = corner
                best_distance = distance
        parents[0] = (i32)best
        weights[0] = 1.0
        return 1
    let normal = normal_of(work, face)
    let u = unit_of(normal.cross(Vector3(1.0, 0.0, 0.0) if math.abs(normal.x) < 0.9 else Vector3(0.0, 1.0, 0.0)))
    let v = normal.cross(u)
    var xs: f64[64] = ---
    var ys: f64[64] = ---
    var lengths: f64[64] = ---
    var scale = 0.0
    for at in 0..<size:
        let offset = input_point(work, topology.corners[first + at]).subtract(position)
        xs[at] = offset.dot(u)
        ys[at] = offset.dot(v)
        lengths[at] = math.sqrt(xs[at] * xs[at] + ys[at] * ys[at])
        scale = math.max(scale, lengths[at])
    let near = 0.0000001 * math.max(scale, 1.0)
    for at in 0..<size:
        if lengths[at] <= near:
            parents[0] = (i32)(first + at)
            weights[0] = 1.0
            return 1
    for at in 0..<size:
        let next_at = (at + 1) % size
        let area = xs[at] * ys[next_at] - ys[at] * xs[next_at]
        let dot = xs[at] * xs[next_at] + ys[at] * ys[next_at]
        if math.abs(area) <= near * scale and dot < 0.0:
            # On the edge between two corners.
            let total = lengths[at] + lengths[next_at]
            parents[0] = (i32)(first + at)
            weights[0] = (f32)(lengths[next_at] / total)
            parents[1] = (i32)(first + next_at)
            weights[1] = (f32)(lengths[at] / total)
            return 2
    var sum = 0.0
    var raw: f64[64] = ---
    for at in 0..<size:
        let previous_at = (at + size - 1) % size
        let next_at = (at + 1) % size
        let before = half_tangent(xs[previous_at], ys[previous_at], lengths[previous_at], xs[at], ys[at], lengths[at])
        let after = half_tangent(xs[at], ys[at], lengths[at], xs[next_at], ys[next_at], lengths[next_at])
        raw[at] = (before + after) / lengths[at]
        sum += raw[at]
    if sum == 0.0 or not math.is_finite(sum):
        parents[0] = (i32)first
        weights[0] = 1.0
        return 1
    for at in 0..<size:
        parents[at] = (i32)(first + at)
        weights[at] = (f32)(raw[at] / sum)
    return size

## tan(a / 2) of the signed angle a between two corner offsets.
func half_tangent(x0: f64, y0: f64, r0: f64, x1: f64, y1: f64, r1: f64) -> f64:
    let area = x0 * y1 - y0 * x1
    if area == 0.0: return 0.0
    return (r0 * r1 - (x0 * x1 + y0 * y1)) / area

## The input face a boundary point's patch corners take their values from.
func bound_face(work: const Bevel*, bound: i32) -> i32:
    let item = work.bounds.items[(usize)bound]
    if item.bevel >= 0 and work.halves.items[(usize)item.bevel].before >= 0: return work.halves.items[(usize)item.bevel].before
    if item.first >= 0:
        let first = work.halves.items[(usize)item.first]
        if first.before >= 0: return first.before
        if first.after >= 0: return first.after
        if item.last >= 0 and work.halves.items[(usize)item.last].before >= 0: return work.halves.items[(usize)item.last].before
    let previous = work.bounds.items[(usize)previous_bound(work, bound)]
    if previous.last >= 0 and work.halves.items[(usize)previous.last].after >= 0: return work.halves.items[(usize)previous.last].after
    let following = work.bounds.items[(usize)next_bound(work, bound)]
    if following.first >= 0 and work.halves.items[(usize)following.first].before >= 0: return work.halves.items[(usize)following.first].before
    let vertex = work.vertices.items[(usize)item.slot]
    for at in vertex.first_half..<vertex.first_half + vertex.halves:
        if work.halves.items[at].after >= 0: return work.halves.items[at].after
    return 0

## Edge `edge`'s strip: a quad per segment between the profiles at its two
## ends, each side's corners in that side's face.
func strip_faces(emitting: const Emitting*, batch: EmitBatch*, edge: i32) -> !:
    let work = emitting.work
    let draft = &batch.draft
    let topology = &work.topology
    let slot1 = work.slot_of.items[(usize)topology.edge_points[(usize)edge * 2]]
    let slot2 = work.slot_of.items[(usize)topology.edge_points[(usize)edge * 2 + 1]]
    let one = half_of(work, slot1, edge)
    let two = half_of(work, slot2, edge)
    if one < 0 or two < 0: return
    let segments = work.settings.segments
    let half1 = work.halves.items[(usize)one]
    let half2 = work.halves.items[(usize)two]
    let face1 = half1.before
    let face2 = half1.after
    let i1 = (usize)work.bounds.items[(usize)half1.left].index
    let i2 = (usize)work.bounds.items[(usize)half2.left].index
    var a = bound_point(work, half1.left)
    var b = bound_point(work, half2.right)
    for k in 1..<segments + 1:
        let d = vm_point(work, slot1, i1, 0, k)
        let c = vm_point(work, slot2, i2, 0, segments - k)
        let parent = face1 if 2 * k <= segments + 1 else face2
        draft.clear()
        try draft.add(a, side_face(k - 1, segments, face1, face2, parent))
        try draft.add(b, side_face(k - 1, segments, face1, face2, parent))
        try draft.add(c, side_face(k, segments, face1, face2, parent))
        try draft.add(d, side_face(k, segments, face1, face2, parent))
        try finish_face(emitting, batch, parent, face_strip)
        a = d
        b = c
    try batch.emitted.pair(bound_point(work, half1.left), bound_point(work, half2.right), edge, 0)
    try batch.emitted.pair(bound_point(work, half2.left), bound_point(work, half1.right), edge, 0)

## The face a strip corner `k` of `segments` across takes its values from.
func side_face(k: usize, segments: usize, first: i32, second: i32, middle: i32) -> i32:
    if 2 * k < segments: return first
    if 2 * k > segments: return second
    return middle

## Vertex `slot`'s patch faces by its mesh's kind.
func vertex_faces(emitting: const Emitting*, batch: EmitBatch*, slot: i32) -> !:
    let work = emitting.work
    let draft = &batch.draft
    let vertex = work.vertices.items[(usize)slot]
    let count = (usize)vertex.bounds
    let segments = work.settings.segments
    let half = segments // 2
    let odd = segments % 2 == 1
    let first = (i32)vertex.first_bound
    let kind = vertex.kind
    if kind == mesh_none or count < 2: return
    if kind == mesh_polygon or kind == mesh_fan:
        draft.clear()
        for i in 0..<count:
            let bound = first + (i32)i
            let face = bound_face(work, bound)
            try draft.add(vm_point(work, slot, i, 0, 0), face)
            if work.bounds.items[(usize)bound].bevel >= 0 and segments > 1:
                for k in 1..<segments: try draft.add(vm_point(work, slot, i, 0, k), face)
        if draft.points.count < 3: return
        if kind == mesh_polygon or draft.points.count == 3:
            return try finish_face(emitting, batch, draft.faces.items[0], face_patch)
        # A fan from the last point.
        var points = Growing[i32]()
        defer points.close()
        var faces = Growing[i32]()
        defer faces.close()
        try points.assign(draft.points.view())
        try faces.assign(draft.faces.view())
        let last = points.count - 1
        for at in 0..<last - 1:
            draft.clear()
            try draft.add(points.items[last], faces.items[last])
            try draft.add(points.items[at], faces.items[at])
            try draft.add(points.items[at + 1], faces.items[at + 1])
            try finish_face(emitting, batch, faces.items[at], face_patch)
        return
    if kind == mesh_cutoff:
        for i in 0..<count:
            let face = bound_face(work, first + (i32)i)
            draft.clear()
            try draft.add(vm_point(work, slot, i, 1, 0), face)
            for k in 0..<segments + 1: try draft.add(vm_point(work, slot, i, 0, k), face)
            if vertex.center_face: try draft.add(vm_point(work, slot, i, 1, 1), face)
            try finish_face(emitting, batch, face, face_patch)
        if vertex.center_face:
            draft.clear()
            for i in 0..<count: try draft.add(vm_point(work, slot, i, 1, 0), bound_face(work, first + (i32)i))
            try finish_face(emitting, batch, draft.faces.items[0], face_patch)
        return
    # The grid: quads ring by ring in each sector, a center face for an odd
    # count (corner i its sector's face).
    if not vertex.hollow_corner:
        for i in 0..<count:
            let face = bound_face(work, first + (i32)i)
            for j in 0..<half:
                for k in 0..<half + (1 if odd else 0):
                    draft.clear()
                    try draft.add(vm_point(work, slot, i, j, k), face)
                    try draft.add(grid_point(work, slot, i, j, k + 1), face)
                    try draft.add(grid_point(work, slot, i, j + 1, k + 1), face)
                    try draft.add(grid_point(work, slot, i, j + 1, k), face)
                    try finish_face(emitting, batch, face, face_patch)
    if odd:
        draft.clear()
        for i in 0..<count: try draft.add(grid_point(work, slot, i, half, half), bound_face(work, first + (i32)i))
        try finish_face(emitting, batch, draft.faces.items[0] if draft.faces.count > 0 else 0, face_patch)

## The output point at grid place (i, j, k), any j and k (canonical).
func grid_point(work: const Bevel*, slot: i32, i: usize, j: usize, k: usize) -> i32:
    let count = (usize)work.vertices.items[(usize)slot].bounds
    let segments = work.settings.segments
    if j <= segments // 2: return vm_point(work, slot, i, j, k)
    let (a, b, c) = canonical(count, segments, i, j, k)
    return vm_point(work, slot, a, b, c)

## Output edges along unbeveled input edges: from the boundary point on the
## edge to its far end (or the boundary point at the far end).
func unbeveled_pairs(work: const Bevel*, emitted: Emitted*) -> !:
    for at in 0..<work.halves.count:
        let item = work.halves.items[at]
        if item.beveled or item.left < 0 or item.left != item.right: continue
        var far = item.other
        let across = far_half(work, (i32)at)
        if across >= 0:
            let other = work.halves.items[(usize)across]
            if other.beveled or other.left != other.right: continue
            far = bound_point(work, other.left)
        try emitted.pair(bound_point(work, item.left), far, item.edge, 0)

## Remove the bevel vertices (no corner uses them any more), renumbering
## the recorded pairs as the builder renumbers its points.
func drop_points(builder: TopologyBuilder*, emitted: Emitted*) -> !:
    try builder.drop_unused_points(renumber = &emitted.pairs)