Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.8

0.7.8 / src / subdivision / limit.lucb

## The limit surface at the final level's points, in parallel: where each
## point converges and its limit normal, which zebra and curvature shading
## read. A smooth interior point takes the scheme's limit position and the
## cross product of its two limit tangents (Catmull-Clark: Halstead et al.'s
## masks over the ring of edge and diagonal neighbors; Loop: cosine and
## sine masks over the neighbors). A crease point converges to
## (e1 + 4v + e2) / 6, a corner stays; their normals, and bilinear ones,
## average the faces around them.

struct LimitWork:
    let scheme: Scheme
    let topology: const Topology*
    let positions: const Vector3[]
    let edge_sharpness: const f32[]
    let point_sharpness: const f32[]
    let out_positions: Vector3[]
    let out_normals: Vector3[]
    ## Only these points (every one when empty); with a list the outputs are
    ## compact (entry i for point points[i]).
    let points: const u32[]

pub func limit_surface(scheme: Scheme, topology: const Topology*, positions: const Vector3[], edge_sharpness: const f32[], point_sharpness: const f32[], out_positions: Vector3[], out_normals: Vector3[], points: const u32[]):
    var work = LimitWork(scheme, topology, positions, edge_sharpness, point_sharpness, out_positions, out_normals, points)
    ranges.each_range(points.length if points.length > 0 else topology.points, 2048, (void*)&work, limit_points)

## The area-weighted normal of the faces around `point` (each met through
## both of its edges there, which doubles every weight alike).
func face_average(work: const LimitWork*, point: usize) -> Vector3:
    let topology = work.topology
    var sum = Vector3()
    for slot in (usize)topology.point_edge_offsets[point]..<(usize)topology.point_edge_offsets[point + 1]:
        let edge = (usize)topology.point_edges[slot]
        for at in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
            let face = (usize)topology.corner_faces[(usize)topology.edge_corners[at]]
            let start = (usize)topology.offsets[face]
            let size = (usize)topology.offsets[face + 1] - start
            var normal = Vector3()
            for index in 0..<size:
                let p = work.positions[(usize)topology.corners[start + index]]
                let q = work.positions[(usize)topology.corners[start + (index + 1) % size]]
                normal = normal.add(p.cross(q))
            sum = sum.add(normal)
    return sum

func direction_of(value: Vector3) -> Vector3:
    let length = value.length()
    return value.multiply_scalar(1.0 / length) if length > 0.0 else Vector3(0.0, 1.0, 0.0)

func limit_points(context: void*, first: usize, end: usize, worker: usize):
    let work = (LimitWork*)context
    let topology = work.topology
    var ring: i32[128]
    var diagonals: i32[128]
    for at in first..<end:
        let point = element(work.points, at)
        let out = at if work.points.length > 0 else point
        let here = work.positions[point]
        work.out_positions[out] = here
        if work.scheme == Scheme.bilinear:
            work.out_normals[out] = direction_of(face_average(work, point))
            continue
        let start = (usize)topology.point_edge_offsets[point]
        let stop = (usize)topology.point_edge_offsets[point + 1]
        let n = stop - start
        if n == 0: continue
        var sharp_count: usize = 0
        var sharp_ends = Vector3()
        for slot in start..<stop:
            let edge = (usize)topology.point_edges[slot]
            let boundary = topology.edge_corner_offsets[edge + 1] - topology.edge_corner_offsets[edge] != 2
            if boundary or work.edge_sharpness[edge] > 0.0:
                sharp_count += 1
                let a = (usize)topology.edge_points[edge * 2]
                sharp_ends = sharp_ends.add(work.positions[(usize)topology.edge_points[edge * 2 + 1] if a == point else a])
        if work.point_sharpness[point] > 0.0 or sharp_count > 2:
            work.out_normals[out] = direction_of(face_average(work, point))
            continue
        if sharp_count == 2:
            work.out_positions[out] = sharp_ends.add(here.multiply_scalar(4.0)).multiply_scalar(1.0 / 6.0)
            work.out_normals[out] = direction_of(face_average(work, point))
            continue
        # Smooth: the ring in rotation order (a closed fan of quads or triangles).
        if n > 128 or not fan(topology, point, n, ring[..<n], diagonals[..<n], work.scheme == Scheme.loop):
            work.out_normals[out] = direction_of(face_average(work, point))
            continue
        let count = (f64)n
        let turn = 2.0 * math.pi / count
        # cos and sin of turn * i by rotation (two trig calls a point).
        let step_cos = math.cos(turn)
        let step_sin = math.sin(turn)
        var cosines: f64[129]
        var sines: f64[129]
        cosines[0] = 1.0
        sines[0] = 0.0
        for i in 0..<n:
            cosines[i + 1] = cosines[i] * step_cos - sines[i] * step_sin
            sines[i + 1] = sines[i] * step_cos + cosines[i] * step_sin
        var tangent_u = Vector3()
        var tangent_v = Vector3()
        if work.scheme == Scheme.loop:
            let beta = loop_beta(count)
            let omega = 1.0 / (3.0 / (8.0 * beta) + count)
            var sum = Vector3()
            for i in 0..<n:
                let q = work.positions[(usize)ring[i]]
                sum = sum.add(q)
                tangent_u = tangent_u.add(q.multiply_scalar(cosines[i]))
                tangent_v = tangent_v.add(q.multiply_scalar(sines[i]))
            work.out_positions[out] = here.multiply_scalar(1.0 - count * omega).add(sum.multiply_scalar(omega))
        else:
            var edges = Vector3()
            var faces = Vector3()
            let a_n = 1.0 + step_cos + math.cos(turn * 0.5) * math.sqrt(2.0 * (9.0 + step_cos))
            for i in 0..<n:
                let e = work.positions[(usize)ring[i]]
                let f = work.positions[(usize)diagonals[i]]
                edges = edges.add(e)
                faces = faces.add(f)
                let c0 = cosines[i]
                let c1 = cosines[i + 1]
                let s0 = sines[i]
                let s1 = sines[i + 1]
                tangent_u = tangent_u.add(e.multiply_scalar(a_n * c0)).add(f.multiply_scalar(c0 + c1))
                tangent_v = tangent_v.add(e.multiply_scalar(a_n * s0)).add(f.multiply_scalar(s0 + s1))
            work.out_positions[out] = here.multiply_scalar(count * count).add(edges.multiply_scalar(4.0)).add(faces).multiply_scalar(1.0 / (count * (count + 5.0)))
        # Face 1 of the fan winds v, ring[1], ..., ring[0]: its normal orients
        # the limit normal.
        let facing = work.positions[(usize)ring[1]].subtract(here).cross(work.positions[(usize)ring[0]].subtract(here))
        var normal = tangent_u.cross(tangent_v)
        if normal.dot(facing) < 0.0: normal = normal.multiply_scalar(-1.0)
        work.out_normals[out] = direction_of(normal) if normal.length() > 0.0 else direction_of(face_average(work, point))

## The closed fan of `point`: `ring[i]` the neighbor along edge i and
## `diagonals[i]` the point across the face between edges i and i + 1
## (quads; triangles have none). False when the faces around it are not one
## closed fan of quads (triangles for Loop).
func fan(topology: const Topology*, point: usize, n: usize, ring: i32[], diagonals: i32[], triangles: bool) -> bool:
    var start: i64 = -1
    let edge = (usize)topology.point_edges[(usize)topology.point_edge_offsets[point]]
    for at in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
        let corner = (usize)topology.edge_corners[at]
        if (usize)topology.corners[corner] == point: start = (i64)corner
    if start < 0: return false
    let size: i32 = 3 if triangles else 4
    var corner = (usize)start
    for i in 0..<n:
        let face = (usize)topology.corner_faces[corner]
        if topology.offsets[face + 1] - topology.offsets[face] != size: return false
        let next = topology.next(corner)
        ring[i] = topology.corners[next]
        if not triangles: diagonals[i] = topology.corners[topology.next(next)]
        let across = topology.twin(corner)
        if across < 0: return false
        corner = topology.next((usize)across)
        if (usize)topology.corners[corner] != point: return false
        if i + 1 < n and corner == (usize)start: return false
    if corner != (usize)start: return false
    # The diagonal between edges i and i + 1 is in face i + 1 (next(next)
    # of its corner); face i's is between edge i - 1 and edge i.
    if not triangles:
        let first = diagonals[0]
        for i in 0..<n - 1: diagonals[i] = diagonals[i + 1]
        diagonals[n - 1] = first
    return true