Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.7

0.7.7 / tests / mesh / bevel_checks.lucb

## PolyBevel against closed forms (POLY-MODELING.md Stage 4). The cube spans
## -1..1 in X and Z and 0..2 in Y: point 6 is (1, 2, 1) with neighbours 2,
## 5 and 7; edges p0-1 and p6-7 are opposite and share no point.
##
## - A cube edge at N segments, shape 0.5: the profile is a polygon with N
##   equal chords on the quarter circle of radius w, so the volume is
##   8 - 2 (w^2 - N/2 w^2 sin(pi / 2N)) and the area follows the same way;
##   both tend to the round edge's as N grows.
## - Shapes: 1 keeps the corner (the volume stays 8), 0.25 is the chamfer
##   (8 - w^2), 0 hollows to the opposite corner (8 - 2w^2).
## - Width types on a 90° edge: Width w is an offset of w / sqrt 2, Depth w
##   one of w sqrt 2, Percent and Absolute slide along the edges beside.
## - The corner where three edges meet: a grid patch whose points lie on the
##   sphere of radius w about the inner corner.
## - Vertex bevel cuts off a tetrahedron (8 - w^3 / 6, one triangle).
## - bevel_weight with Limit Weight scales each edge's width.
## - Clamp overlap stops where the strips meet: every edge beveled, the
##   octahedron of the face centers (4/3).
## - Miters on an L-shaped block, a custom stepped profile, Cutoff.
import interop
from luce_std import math
from luce_geocore.geocore import Mesh, MeshBuilder, MeshPrimitives, MaterialAssignment, Verbs, Vector3
from luce_geocore.kernel import clear_group_cache
from tool_fixtures import made, counts, near, near_point, volume, area, surface

pub func exercise() -> !:
    defer clear_group_cache()
    let cube = try Mesh.cube()
    defer cube.release()
    try segment_checks(cube)
    try shape_checks(cube)
    try width_type_checks(cube)
    try corner_checks(cube)
    try vertex_checks(cube)
    try weight_checks(cube)
    try clamp_checks(cube)
    try custom_checks(cube)
    try cutoff_checks(cube)
    try miter_checks()
    try slide_checks()
    try finishing_checks(cube)
    try refusal_checks(cube)
    try sweep(cube)
    print("PASS PolyBevel closed forms: cube edge by segments (volume, area, the round limit), shapes 0 / 0.25 / 0.5 / 1, width types, the three-edge corner on its sphere, vertex bevel, weights, clamp overlap, a stepped custom profile, cutoff, miters")

## A run's numbers: Width, Segments, Shape, Width Type, Affect, Clamp, Loop
## slide, Profile Type, Miter Outer, Miter Inner, Spread, Intersection,
## Harden, Mark seams, Mark sharp, Face strength, Material, Limit, Angle,
## then the custom profile ramp.
struct Bevel:
    var width: f64 = 0.2
    var segments: f64 = 1.0
    var shape: f64 = 0.5
    var width_type: f64 = 0.0
    var affect: f64 = 0.0
    var clamp: f64 = 1.0
    var loop_slide: f64 = 1.0
    var custom: f64 = 0.0
    var outer: f64 = 0.0
    var inner: f64 = 0.0
    var spread: f64 = 0.1
    var cutoff: f64 = 0.0
    var harden: f64 = 0.0
    var seams: f64 = 0.0
    var sharp: f64 = 0.0
    var strength: f64 = 0.0
    var material: f64 = -1.0
    var limit: f64 = 0.0
    var angle: f64 = 30.0

func numbers(b: Bevel) -> f64[19]:
    return [b.width, b.segments, b.shape, b.width_type, b.affect, b.clamp, b.loop_slide, b.custom, b.outer, b.inner, b.spread, b.cutoff, b.harden, b.seams, b.sharp, b.strength, b.material, b.limit, b.angle]

func run(mesh: interop.Reference[Mesh], group: str, group_type: i64, b: Bevel, selected: i64) -> interop.Reference[Mesh]!:
    let values = numbers(b)
    return try made(mesh, "PolyBevel", group, group_type, values[..<19], selected)

## A run whose selection is not checked.
func loose(mesh: interop.Reference[Mesh], group: str, group_type: i64, b: Bevel) -> interop.Reference[Mesh]!:
    let values = numbers(b)
    let result = try Verbs.run("PolyBevel", mesh, group, group_type, values[..<19])
    defer result.release()
    if result.value().warning().length > 0: print(f"PolyBevel {group}: {result.value().warning()}")
    return try result.value().mesh()

## The total area of every face.
func total_area(mesh: interop.Reference[Mesh]) -> f64!:
    var sum = 0.0
    for face in 0..<mesh.value().face_count(): sum += try area(mesh, face)
    return sum

## A cube edge of N segments against the polygon's closed forms, and the
## round edge they tend to.
func segment_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let round_volume = 8.0 - 2.0 * (w * w - math.pi * w * w / 4.0)
    let round_area = 24.0 - 4.0 * w + math.pi * w - 2.0 * (w * w - math.pi * w * w / 4.0)
    var previous_error = 1.0
    let counts_of: f64[6] = [1.0, 2.0, 3.0, 4.0, 8.0, 16.0]
    for n in counts_of:
        let mesh = try run(cube, "p0-1", 2, Bevel(segments = n), (i64)n)
        defer mesh.release()
        try counts(mesh, 8 - 2 + 2 * ((i64)n + 1), 6 + (i64)n)
        try surface(mesh, true)
        let removed = w * w - n / 2.0 * w * w * math.sin(math.pi / (2.0 * n))
        near(try volume(mesh), 8.0 - 2.0 * removed, 0.00001)
        near(try total_area(mesh), 24.0 - 4.0 * w + 4.0 * n * w * math.sin(math.pi / (4.0 * n)) - 2.0 * removed, 0.00001)
        let deviation = math.abs((try volume(mesh)) - round_volume) + math.abs((try total_area(mesh)) - round_area)
        assert(deviation < previous_error)
        previous_error = deviation
    assert(previous_error < 0.001)

## Shapes at 4 segments (and the square's corner-cut chord at 3).
func shape_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let square = try run(cube, "p0-1", 2, Bevel(segments = 4.0, shape = 1.0), 4)
    defer square.release()
    near(try volume(square), 8.0, 0.00001)
    let chamfer = try run(cube, "p0-1", 2, Bevel(segments = 4.0, shape = 0.25), 4)
    defer chamfer.release()
    near(try volume(chamfer), 8.0 - w * w, 0.00001)
    let hollow = try run(cube, "p0-1", 2, Bevel(segments = 4.0, shape = 0.0), 4)
    defer hollow.release()
    near(try volume(hollow), 8.0 - 2.0 * w * w, 0.00001)
    # Three segments of the square: the middle chord cuts the corner where
    # the legs' points stop, 1 / (1 + sqrt(1/2)) of the way.
    let step = 1.0 / (1.0 + math.sqrt(0.5))
    let cut = try run(cube, "p0-1", 2, Bevel(segments = 3.0, shape = 1.0), 3)
    defer cut.release()
    near(try volume(cut), 8.0 - 2.0 * (1.0 - step) * (1.0 - step) * w * w / 2.0, 0.00001)

## Width types on a 90° edge with one segment: the chamfer's triangle has
## legs of the offset.
func width_type_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let offsets: f64[5] = [w, w / math.sqrt(2.0), w * math.sqrt(2.0), 0.2, 0.3]
    let widths: f64[5] = [w, w, w, 10.0, 0.3]
    for kind in 0..<(usize)5:
        let mesh = try run(cube, "p0-1", 2, Bevel(width = widths[kind], width_type = (f64)kind), 1)
        defer mesh.release()
        near(try volume(mesh), 8.0 - offsets[kind] * offsets[kind], 0.00001)

## The corner where three beveled edges meet: Blender's grid patch (all
## quads, a center triangle for odd segments) on the sphere of radius w
## about the inner corner.
func corner_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let center = Vector3(1.0 - w, 2.0 - w, 1.0 - w)
    let counts_of: f64[4] = [2.0, 3.0, 4.0, 5.0]
    for n in counts_of:
        let half = (i64)n // 2
        let odd = (i64)n % 2
        let patch = 3 * half * (half + odd) + odd
        let mesh = try run(cube, "p6-2 p6-5 p6-7", 2, Bevel(segments = n), 3 * (i64)n + patch)
        defer mesh.release()
        try surface(mesh, true)
        var on_sphere = 0
        for point in 0..<mesh.value().point_count():
            let p = try mesh.value().point(point)
            if p.x > 1.0 - w + 0.000001 and p.y > 2.0 - w + 0.000001 and p.z > 1.0 - w + 0.000001:
                near(p.subtract(center).length(), w, 0.000001)
                on_sphere += 1
        assert(on_sphere > 0)
    # Every edge at 3 segments: the rounded cube, all quads but the corner
    # triangles.
    let all = try run(cube, "", 0, Bevel(segments = 3.0), 12 * 3 + 8 * 7)
    defer all.release()
    try surface(all, true)
    var triangles = 0
    for face in 0..<all.value().face_count():
        let size = try all.value().face_size(face)
        if size == 3: triangles += 1
        else: assert(size == 4)
    assert(triangles == 8)

## Affect Vertices: a corner cut off.
func vertex_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let cut = try run(cube, "6", 1, Bevel(), 1)
    defer cut.release()
    try counts(cut, 10, 7)
    try surface(cut, true)
    near(try volume(cut), 8.0 - w * w * w / 6.0, 0.00001)
    # Affect Vertices names its points by an edge group too.
    let named = try run(cube, "p6-2", 2, Bevel(affect = 2.0), 2)
    defer named.release()
    try counts(named, 12, 8)
    near(try volume(named), 8.0 - 2.0 * w * w * w / 6.0, 0.00001)
    # Two segments: each cut a small grid patch, still closed.
    let rounded = try loose(cube, "", 1, Bevel(segments = 2.0, affect = 2.0))
    defer rounded.release()
    try surface(rounded, true)

## bevel_weight with Limit Weight: each edge's width scaled by its weight,
## edges of weight 0 left.
func weight_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let edges = (usize)(try cube.value().edge_count())
    var weights: f64[12]
    for edge in 0..<edges:
        let a = try cube.value().edge_point((i64)edge, 0)
        let b = try cube.value().edge_point((i64)edge, 1)
        weights[edge] = 0.0
        if (a == 0 and b == 1) or (a == 1 and b == 0): weights[edge] = 1.0
        if (a == 6 and b == 7) or (a == 7 and b == 6): weights[edge] = 0.5
    let weighted = try cube.value().with_attribute("bevel_weight", 4, 1, weights[..<edges], false, true)
    defer weighted.release()
    let mesh = try run(weighted, "", 0, Bevel(limit = 2.0), 2)
    defer mesh.release()
    near(try volume(mesh), 8.0 - w * w - 0.25 * w * w, 0.00001)
    # The same weights from the Bevel Weight verb.
    let full: f64[2] = [1.0, 0.0]
    let half: f64[2] = [0.5, 0.0]
    let first = try made(cube, "Bevel Weight", "p0-1", 2, full[..<2], 1)
    defer first.release()
    let second = try made(first, "Bevel Weight", "p6-7", 2, half[..<2], 1)
    defer second.release()
    let again = try run(second, "", 0, Bevel(limit = 2.0), 2)
    defer again.release()
    near(try volume(again), 8.0 - w * w - 0.25 * w * w, 0.00001)
    # Limit Angle: a cube's edges are 90° apart.
    let sharp = try run(cube, "", 0, Bevel(limit = 1.0, angle = 89.0), 12 + 8)
    defer sharp.release()
    let values = numbers(Bevel(limit = 1.0, angle = 91.0))
    let none_result = try Verbs.run("PolyBevel", cube, "", 0, values[..<19])
    defer none_result.release()
    assert(none_result.value().warning().length > 0)

## Clamp overlap on every edge: past half the face, strips would cross;
## clamped, they stop just short of where they meet, the faces shrunk to
## their centers (the octahedron of the face centers, 4/3).
func clamp_checks(cube: interop.Reference[Mesh]) -> !:
    let clamped = try run(cube, "", 0, Bevel(width = 5.0), 12 + 8)
    defer clamped.release()
    try surface(clamped, true)
    near(try volume(clamped), 4.0 / 3.0, 0.002)
    # Every face faces out.
    for face in 0..<clamped.value().face_count():
        let normal = try clamped.value().face_normal(face)
        let first = try clamped.value().point(try clamped.value().face_point(face, 0))
        assert(normal.dot(first.subtract(Vector3(0.0, 1.0, 0.0))) > 0.0)
    # Without the clamp the strips cross: faces turn inside out.
    let crossed = try loose(cube, "", 0, Bevel(width = 5.0, clamp = 0.0))
    defer crossed.release()
    var inward = 0
    for face in 0..<crossed.value().face_count():
        let normal = try crossed.value().face_normal(face)
        let first = try crossed.value().point(try crossed.value().face_point(face, 0))
        if normal.dot(first.subtract(Vector3(0.0, 1.0, 0.0))) < 0.0: inward += 1
    assert(inward > 0 and math.abs((try volume(crossed)) - 4.0 / 3.0) > 1.0)

## A custom profile of a step: the strip's points stay on the step's
## corners, and the chamfer's triangle half is cut away.
func custom_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    var values: f64[31]
    let base = numbers(Bevel(segments = 4.0, custom = 1.0))
    for at in 0..<(usize)19: values[at] = base[at]
    # Depth 0 to the middle, then 1: the chord to the middle, up to the
    # corner, down the far leg.
    let step: f64[12] = [1.0, 1.0, 3.0, 0.0, 0.0, 0.0, 0.5, 1.0, 0.0, 1.0, 1.0, 0.0]
    for at in 0..<(usize)12: values[19 + at] = step[at]
    let mesh = try made(cube, "PolyBevel", "p0-1", 2, values[..<31], 4)
    defer mesh.release()
    try surface(mesh, true)
    near(try volume(mesh), 8.0 - 2.0 * 0.25 * w * w, 0.00001)

## Cutoff at the three-edge corner: one face across each strip's end. On a
## cube their bottoms meet at the inner corner, so there is no bottom face;
## a corner whose edges are not square keeps one.
func cutoff_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    let mesh = try run(cube, "p6-2 p6-5 p6-7", 2, Bevel(segments = 3.0, cutoff = 1.0), 3 * 3 + 3)
    defer mesh.release()
    try surface(mesh, true)
    var at_corner = 0
    for point in 0..<mesh.value().point_count():
        if (try mesh.value().point(point)).subtract(Vector3(1.0 - w, 2.0 - w, 1.0 - w)).length() < 0.000001: at_corner += 1
    assert(at_corner == 1)

## An L-shaped block (the L in XZ, 0..1 in Y) with every edge beveled. At
## the top of the inner corner, (1, 1, 1), the two top edges meet round
## 270°: a sharp miter puts their sides' meeting point at (1 - w, 1, 1 - w);
## the arc miter ends both strips square, the strip along +X at x = 1 + w
## and the one along +Z at z = 1 + w, both keeping their full round width
## there, with a circle of radius 2w about (1 + w, 1, 1 + w) between.
func miter_checks() -> !:
    let w = 0.2
    let block = try l_block()
    defer block.release()
    let sharp = try loose(block, "", 0, Bevel(segments = 2.0))
    defer sharp.release()
    try surface(sharp, true)
    assert(try has_point(sharp, Vector3(1.0 - w, 1.0, 1.0 - w)))
    assert(not (try has_point(sharp, Vector3(1.0 + w, 1.0, 1.0 - w))))
    let arc = try loose(block, "", 0, Bevel(segments = 2.0, outer = 2.0))
    defer arc.release()
    try surface(arc, true)
    # The strips end square, top and wall side points in one plane across.
    assert(try has_point(arc, Vector3(1.0 + w, 1.0, 1.0 - w)))
    assert(try has_point(arc, Vector3(1.0 + w, 1.0 - w, 1.0)))
    assert(try has_point(arc, Vector3(1.0 - w, 1.0, 1.0 + w)))
    assert(try has_point(arc, Vector3(1.0, 1.0 - w, 1.0 + w)))
    # The arc: its ends and its middle on the circle of radius 2w.
    let middle = Vector3(1.0 + w - 2.0 * w * math.sqrt(0.5), 1.0, 1.0 + w - 2.0 * w * math.sqrt(0.5))
    assert(try has_point(arc, middle))
    # The end of the strip along +X is its round profile, a quarter circle
    # of radius w about the strip's axis.
    let axis = Vector3(1.0 + w, 1.0 - w, 1.0 - w)
    var on_end = 0
    for point in 0..<arc.value().point_count():
        let p = try arc.value().point(point)
        if math.abs(p.x - (1.0 + w)) < 0.000001 and p.y > 1.0 - w - 0.000001 and p.z > 1.0 - w - 0.000001:
            near(p.subtract(axis).length(), w, 0.000001)
            on_end += 1
    assert(on_end == 3)
    # Inner arcs too: the ring grows, still closed.
    let inner = try loose(block, "", 0, Bevel(segments = 2.0, outer = 2.0, inner = 1.0))
    defer inner.release()
    try surface(inner, true)
    assert(inner.value().point_count() > arc.value().point_count())

## Whether `mesh` has a point at `p`.
func has_point(mesh: interop.Reference[Mesh], p: Vector3) -> bool!:
    for point in 0..<mesh.value().point_count():
        if (try mesh.value().point(point)).subtract(p).length() < 0.000001: return true
    return false

## Loop slide on a sheared grid: the row's boundary points stay on the
## slanted edges across it (the edge loops stay straight), each w from the
## row's line; without it they sit straight across. A crossing column makes
## a pipe of four strips, which stays flat.
func slide_checks() -> !:
    let w = 0.1
    var places: f64[75]
    for z in 0..<(usize)5:
        for x in 0..<(usize)5:
            let at = (z * 5 + x) * 3
            places[at] = (f64)x + 0.5 * (f64)z
            places[at + 1] = 0.0
            places[at + 2] = (f64)z
    let sheared = try grid_of(places[..<75])
    defer sheared.release()
    let slid = try loose(sheared, "p10-11-12-13-14", 2, Bevel(width = w))
    defer slid.release()
    # Interior points 11, 12, 13 at z = 2 go; on each slanted edge through
    # them (direction (0.5, 0, 1)) a point at z = 2 +- w.
    for column in 1..<4:
        let base = Vector3((f64)column + 1.0, 0.0, 2.0)
        let way = Vector3(0.5, 0.0, 1.0)
        assert(try has_point(slid, base.add(way.multiply_scalar(w))))
        assert(try has_point(slid, base.subtract(way.multiply_scalar(w))))
    let straight_across = try loose(sheared, "p10-11-12-13-14", 2, Bevel(width = w, loop_slide = 0.0))
    defer straight_across.release()
    assert(not (try has_point(straight_across, Vector3(3.0, 0.0, 2.0).add(Vector3(0.5, 0.0, 1.0).multiply_scalar(w)))))
    # The pipe: a row and a column crossing at point 12, two segments.
    let grid = try MeshPrimitives.grid(4.0, 4)
    defer grid.release()
    let cross = try loose(grid, "p10-11-12-13-14 p2-7-12-17-22", 2, Bevel(width = 0.2, segments = 2.0))
    defer cross.release()
    try surface(cross, false)
    for point in 0..<cross.value().point_count(): near((try cross.value().point(point)).y, 0.0, 0.000001)

## A grid of quads through 25 points (5 by 5, row-major in z).
func grid_of(places: const f64[]) -> interop.Reference[Mesh]!:
    var builder = try MeshBuilder()
    defer builder.close()
    for at in 0..<(usize)25: _ = try builder.point(Vector3(places[at * 3], places[at * 3 + 1], places[at * 3 + 2]))
    for z in 0..<(i64)4:
        for x in 0..<(i64)4:
            let p = z * 5 + x
            try builder.face(4)
            try builder.corner(p)
            try builder.corner(p + 5)
            try builder.corner(p + 6)
            try builder.corner(p + 1)
    return try builder.finish()

## Harden normals, Mark sharp, Face strength and Material.
func finishing_checks(cube: interop.Reference[Mesh]) -> !:
    let w = 0.2
    # Harden: the strip's corners at its side on the top face (y = 2) take
    # the top's normal; on the side face (z = 1), that face's.
    let hard = try run(cube, "p6-7", 2, Bevel(segments = 3.0, harden = 1.0), 3)
    defer hard.release()
    let normals = hard.value().find_attribute("N", 1)
    assert(normals >= 0)
    var checked = 0
    for face in 6..<hard.value().face_count():
        for at in 0..<(try hard.value().face_size(face)):
            let corner = (try hard.value().face_offset(face)) + at
            let p = try hard.value().point(try hard.value().face_point(face, at))
            let n = Vector3(try hard.value().attribute_value(normals, corner, 0), try hard.value().attribute_value(normals, corner, 1), try hard.value().attribute_value(normals, corner, 2))
            if math.abs(p.y - 2.0) < 0.000001:
                near_point(n, Vector3(0.0, 1.0, 0.0), 0.0001)
                checked += 1
            if math.abs(p.z - 1.0) < 0.000001:
                near_point(n, Vector3(0.0, 0.0, 1.0), 0.0001)
                checked += 1
    assert(checked == 4)
    # Mark sharp: edges 6-2 and 6-7 sharp, 6-5 not; beveled together the
    # sharp line runs on round the corner patch, so no sharp line ends
    # near the corner.
    let edges = (usize)(try cube.value().edge_count())
    var marks: f64[12]
    for edge in 0..<edges:
        let a = try cube.value().edge_point((i64)edge, 0)
        let b = try cube.value().edge_point((i64)edge, 1)
        marks[edge] = 1.0 if (a == 6 or b == 6) and (a == 2 or b == 2 or a == 7 or b == 7) else 0.0
    let marked = try cube.value().with_attribute("sharp", 4, 1, marks[..<edges], true)
    defer marked.release()
    let unmarked_run = try run(marked, "p6-2 p6-5 p6-7", 2, Bevel(segments = 2.0), 6 + 3)
    defer unmarked_run.release()
    assert(try sharp_ends_near(unmarked_run, Vector3(1.0, 2.0, 1.0), 3.0 * w) > 0)
    let continued = try run(marked, "p6-2 p6-5 p6-7", 2, Bevel(segments = 2.0, sharp = 1.0), 6 + 3)
    defer continued.release()
    assert(try sharp_ends_near(continued, Vector3(1.0, 2.0, 1.0), 3.0 * w) == 0)
    # Face strength New: patches 1, strips 2, the rest untouched.
    let strong = try run(cube, "p6-2 p6-5 p6-7", 2, Bevel(segments = 2.0, strength = 1.0), 6 + 3)
    defer strong.release()
    let strength = strong.value().find_attribute("face_strength", 2)
    assert(strength >= 0)
    var tally: i64[4] = [0, 0, 0, 0]
    for face in 0..<strong.value().face_count(): tally[(usize)(try strong.value().attribute_value(strength, face))] += 1
    assert(tally[0] == 6 and tally[1] == 3 and tally[2] == 6)
    # Material 0: the new faces take the material used first (face 0's).
    let painted = try MaterialAssignment.faces(cube, "0", "material", "/red")
    defer painted.release()
    let both = try MaterialAssignment.faces(painted, "1-5", "material", "/blue")
    defer both.release()
    let dressed = try run(both, "p6-7", 2, Bevel(material = 0.0), 1)
    defer dressed.release()
    let material = dressed.value().find_attribute("material", 2)
    let red = try dressed.value().attribute_value(material, 0)
    assert(try dressed.value().attribute_value(material, dressed.value().face_count() - 1) == red)
    assert(try dressed.value().attribute_value(material, 1) != red)

## How many points within `reach` of `p` touch exactly one sharp edge.
func sharp_ends_near(mesh: interop.Reference[Mesh], p: Vector3, reach: f64) -> i64!:
    let sharp = mesh.value().find_attribute("sharp", 4)
    assert(sharp >= 0)
    let points = mesh.value().point_count()
    var touches: i64[256]
    for at in 0..<(usize)256: touches[at] = 0
    for edge in 0..<(try mesh.value().edge_count()):
        if (try mesh.value().attribute_value(sharp, edge)) == 0.0: continue
        touches[(usize)(try mesh.value().edge_point(edge, 0))] += 1
        touches[(usize)(try mesh.value().edge_point(edge, 1))] += 1
    var ends = 0
    for point in 0..<points:
        if touches[(usize)point] == 1 and (try mesh.value().point(point)).subtract(p).length() < reach: ends += 1
    return ends

## Every combination of the options on closed shapes (a cube, the L block,
## a cylinder with n-gon caps, a sphere with triangle fans at its poles, a
## torus) stays a closed surface with every face outward (positive
## volume). The round and chamfer shapes never fold: those runs warn of
## nothing. (A square cut-off point of odd segments, or Cutoff with Percent
## widths round the L's inner corner, can fold faces flat; those runs pass
## the input through with a warning, as any verb does.)
func sweep(cube: interop.Reference[Mesh]) -> !:
    let block = try l_block()
    defer block.release()
    let cylinder = try MeshPrimitives.cylinder(1.0, 2.0, 8)
    defer cylinder.release()
    let sphere = try MeshPrimitives.sphere(1.0, 8)
    defer sphere.release()
    let torus = try MeshPrimitives.torus(1.0, 0.3, 8)
    defer torus.release()
    let shapes: f64[5] = [0.0, 0.25, 0.5, 0.8, 1.0]
    for segments in 1..<6:
        for shape in shapes:
            for kind in 0..<5:
                let width = 10.0 if kind == 3 else 0.1
                let options = Bevel(width = width, segments = (f64)segments, shape = shape, width_type = (f64)kind, outer = (f64)(segments % 3), inner = (f64)(segments % 2), cutoff = 1.0 if shape == 0.8 else 0.0)
                let plain = shape == 0.25 or shape == 0.5
                try closed_run(cube, options, plain)
                try closed_run(block, options, plain)
                try closed_run(cylinder, options, plain)
                try closed_run(sphere, options, plain)
                try closed_run(torus, options, plain)
                var vertices = options
                vertices.affect = 2.0
                try closed_run(cube, vertices, plain)
                try closed_run(cylinder, vertices, plain)
    # A custom profile everywhere (its default round ramp).
    for segments in 1..<6:
        try closed_run(cube, Bevel(segments = (f64)segments, custom = 1.0), true)
        try closed_run(block, Bevel(segments = (f64)segments, custom = 1.0, outer = 2.0), true)
        try closed_run(torus, Bevel(segments = (f64)segments, custom = 1.0), true)

## Bevel every edge (or point) of `mesh`: the result is closed and faces
## out; with `quiet`, the run warns of nothing.
func closed_run(mesh: interop.Reference[Mesh], options: Bevel, quiet: bool) -> !:
    let values = numbers(options)
    let attempt = try Verbs.run("PolyBevel", mesh, "", 0, values[..<19])
    defer attempt.release()
    if quiet and attempt.value().warning().length > 0:
        print(f"warned: segments {options.segments} shape {options.shape} type {options.width_type} affect {options.affect} outer {options.outer} inner {options.inner} custom {options.custom}: {attempt.value().warning()}")
        assert(false)
    let result = try attempt.value().mesh()
    defer result.release()
    try surface(result, true)
    assert(try volume(result) > 0.0)

## A boundary edge is skipped with a warning; an edge of three faces
## refuses the run.
func refusal_checks(cube: interop.Reference[Mesh]) -> !:
    let grid = try MeshPrimitives.grid(2.0, 4)
    defer grid.release()
    let values = numbers(Bevel())
    let border = try Verbs.run("PolyBevel", grid, "p0-1", 2, values[..<19])
    defer border.release()
    assert(border.value().warning().length > 0)
    var builder = try MeshBuilder()
    defer builder.close()
    let fin: f64[18] = [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0]
    for at in 0..<(usize)6: _ = try builder.point(Vector3(fin[at * 3], fin[at * 3 + 1], fin[at * 3 + 2]))
    let quads: i64[12] = [0, 2, 3, 1, 1, 4, 0, 0, 0, 5, 1, 1]
    try builder.face(4)
    for at in 0..<(usize)4: try builder.corner(quads[at])
    try builder.face(3)
    try builder.corner(0)
    try builder.corner(1)
    try builder.corner(4)
    try builder.face(3)
    try builder.corner(1)
    try builder.corner(0)
    try builder.corner(5)
    let fins = try builder.finish()
    defer fins.release()
    assert(refuses(fins, "p0-1", values[..<19]))

## Whether Bevel refuses to run on `mesh`'s `group`, saying why.
func refuses(mesh: interop.Reference[Mesh], group: str, values: const f64[]) -> bool:
    let attempt = Verbs.run("PolyBevel", mesh, group, 2, values) catch failure:
        return failure.message.length > 0
    attempt.release()
    return false

## The L: (0,0) (2,0) (2,1) (1,1) (1,2) (0,2) in XZ, from y 0 to 1.
func l_block() -> interop.Reference[Mesh]!:
    let outline: f64[12] = [0.0, 0.0, 2.0, 0.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 0.0, 2.0]
    var builder = try MeshBuilder()
    defer builder.close()
    for level in 0..<(usize)2:
        for at in 0..<(usize)6: _ = try builder.point(Vector3(outline[at * 2], (f64)level, outline[at * 2 + 1]))
    # Bottom (facing down), top (facing up), the walls.
    try builder.face(6)
    for at in 0..<(i64)6: try builder.corner(at)
    try builder.face(6)
    for at in 0..<(i64)6: try builder.corner(6 + 5 - at)
    for at in 0..<(i64)6:
        let next_at = (at + 1) % 6
        try builder.face(4)
        try builder.corner(at)
        try builder.corner(6 + at)
        try builder.corner(6 + next_at)
        try builder.corner(next_at)
    return try builder.finish()