Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.4

0.9.4 / src / meshing / seam_conform.lucb

## Conform a fallback face to the shared layout without re-solving its UV trim.
## Additional seam vertices become real polygon corners, not independent points
## overlaid on a coarse edge. This avoids forcing fans into a valid base mesh.

struct Span:
    var a: i64 = -1
    var b: i64 = -1
    var edge: usize = 0
    var first: usize = 0
    var last: usize = 0

## Insert every additional shared-edge sample into its containing polygon edge.
## Input faces must have been meshed with Samples.baseline, not independently.
pub func conform_seams(mesh: MeshBuilder*, face: BrepFace, samples: const Samples[], first_face: usize, first_corner: usize) -> !:
    var count: usize = 0
    for use in face.uses: count += samples[edge_index(use)].baseline.length
    let spans = try new Span[count * 2 + 1] --- in memory.heap
    defer free(spans) in memory.heap
    for at in 0..<spans.length: spans[at] = Span()
    for use in face.uses:
        let edge = edge_index(use)
        let fine = samples[edge].ids
        let base = samples[edge].baseline
        var start: usize = 0
        for at in 0..<base.length - 1:
            var end = start + 1
            while end < fine.length and fine[end] != base[at + 1]: end += 1
            if end == fine.length: error(invalid, "shared seam is missing a baseline station")
            if end > start + 1:
                let a = base[at] if base[at] < base[at + 1] else base[at + 1]
                let b = base[at + 1] if base[at] < base[at + 1] else base[at]
                let slot = find(spans, a, b)
                spans[slot] = Span(a, b, edge, start, end)
            start = end
    let sizes = try new i64[mesh.nf - first_face] --- in memory.heap
    defer free(sizes) in memory.heap
    let corners = try new i64[mesh.nc - first_corner] --- in memory.heap
    defer free(corners) in memory.heap
    memory.copy(sizes, mesh.sizes[first_face..<mesh.nf], sizes.length)
    memory.copy(corners, mesh.corners[first_corner..<mesh.nc], corners.length)
    mesh.nf = first_face
    mesh.nc = first_corner
    var offset: usize = 0
    for size in sizes:
        var total = size
        for at in 0..<(usize)size:
            let a = corners[offset + at]
            let b = corners[offset + (at + 1) % (usize)size]
            let span = spans[find(spans, a if a < b else b, b if a < b else a)]
            if span.a >= 0: total += (i64)(span.last - span.first - 1)
        try mesh.face(total)
        for at in 0..<(usize)size:
            let a = corners[offset + at]
            let b = corners[offset + (at + 1) % (usize)size]
            try mesh.corner(a)
            let span = spans[find(spans, a if a < b else b, b if a < b else a)]
            if span.a < 0: continue
            let fine = samples[span.edge].ids
            let forward = a == fine[span.first]
            for extra in 1..<span.last - span.first:
                try mesh.corner(fine[span.first + extra if forward else span.last - extra])
        offset += (usize)size

func find(spans: const Span[], a: i64, b: i64) -> usize:
    var slot = ((usize)a * 73856093 + (usize)b * 19349663) % spans.length
    while spans[slot].a >= 0 and (spans[slot].a != a or spans[slot].b != b): slot = (slot + 1) % spans.length
    return slot