Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-cad

Source of release 0.9.2

0.9.2 / src / meshing / patch_grid.lucb

## Meshes of a model's independent patches (faces without B-rep edges):
## a B-spline patch's uniform grid over its trim rectangle, and a planar
## polygon refined to an edge size.

## A B-spline patch over knot rectangle u0..u1 x v0..v1 as a grid of
## `segments` x `segments` quads (1..64), its points exact.
pub func nurbs_grid(points: const Vector3[], weights: const f64[], nu: i64, nv: i64, du: i64, dv: i64, ku: const f64[], kv: const f64[],
                    u0: f64, u1: f64, v0: f64, v1: f64, segments: i64 = 16) -> interop.Reference[Mesh]!:
    try NurbsSurface.check(points, weights, nu, nv, du, dv, ku, kv)
    try NurbsSurface.check_region(ku, kv, nu, nv, du, dv, u0, u1, v0, v1)
    if segments < 1 or segments > 64: error(invalid, "NURBS tessellation segments must be 1..64")
    var mesh = try MeshBuilder(precise = true)
    defer mesh.close()
    for iu in 0..<segments + 1:
        let u = u0 + (u1 - u0) * (f64)iu / (f64)segments
        for iv in 0..<segments + 1:
            let v = v0 + (v1 - v0) * (f64)iv / (f64)segments
            _ = try mesh.point(try NurbsSurface.sample_checked(points, weights, nu, nv, du, dv, ku, kv, u, v))
    for iu in 0..<segments:
        for iv in 0..<segments:
            let a = iu * (segments + 1) + iv
            try mesh.face(4)
            try mesh.corner(a)
            try mesh.corner(a + segments + 1)
            try mesh.corner(a + segments + 2)
            try mesh.corner(a + 1)
    return try mesh.finish()

## A planar polygon's quads, its edges cut to at most `spacing`.

pub func planar_grid(points: const Vector3[], spacing: f64) -> interop.Reference[Mesh]!:
    let boundary = try new Vector3[4096] --- in memory.heap
    defer free(boundary) in memory.heap
    var count: usize = 0
    var normal = Vector3()
    for at in 0..<points.length:
        let a = points[at]
        let b = points[(at + 1) % points.length]
        normal = normal.add(a.subtract(points[0]).cross(b.subtract(points[0])))
        let intervals = math.max(1.0, math.ceil(b.subtract(a).length() / spacing))
        if intervals > 256.0 or (f64)count + intervals > 4096.0:
            error(invalid, "edge size exceeds planar patch sampling budget; increase it")
        for step in 0..<(usize)intervals:
            boundary[count] = a.add(b.subtract(a).multiply_scalar((f64)step / intervals))
            count += 1
    let sizes = [(i64)count]
    return try TrimPolygon.quadrangulate(boundary[..<count], sizes, try normal.normalized(), spacing)