Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.8

0.7.8 / src / subdivision / refine.lucb

import core.ranges
## One level of positions, in parallel: face points, then edge points, then
## vertex points, by the scheme's rules with USD sharpness. An edge on a
## boundary or on more than two faces is infinitely sharp. A point with a
## corner sharpness, or more than two sharp edges, stays (the corner rule);
## with two, it follows the crease ((e1 + 6v + e2) / 8); a fractional
## sharpness blends the smooth rule toward the sharp one.

struct Level:
    let scheme: Scheme
    let topology: const Topology*
    let positions: const Vector3[]
    let edge_sharpness: const f32[]
    let point_sharpness: const f32[]
    let out: Vector3[]
    ## Only these faces, edges and points (every one when empty).
    let faces: const u32[]
    let edges: const u32[]
    let points: const u32[]

## Level l's positions (and sharpness) to level l + 1's: every element, or
## (with lists) only the listed ones, the rest of `out` left as it is.
pub func refine_positions(scheme: Scheme, topology: const Topology*, positions: const Vector3[], edge_sharpness: const f32[], point_sharpness: const f32[], out: Vector3[], faces: const u32[], edges: const u32[], points: const u32[]):
    var level = Level(scheme, topology, positions, edge_sharpness, point_sharpness, out, faces, edges, points)
    if scheme != Scheme.loop: ranges.each_range(faces.length if faces.length > 0 else topology.faces(), 4096, (void*)&level, face_points)
    ranges.each_range(edges.length if edges.length > 0 else topology.edges(), 4096, (void*)&level, edge_points)
    ranges.each_range(points.length if points.length > 0 else topology.points, 4096, (void*)&level, vertex_points)

## Element `at` of a pass: from the list, or itself.
func element(list: const u32[], at: usize) -> usize:
    return (usize)list[at] if list.length > 0 else at

func face_points(context: void*, first: usize, end: usize, worker: usize):
    let level = (Level*)context
    let topology = level.topology
    let base = topology.points + topology.edges()
    for index in first..<end:
        let face = element(level.faces, index)
        let start = (usize)topology.offsets[face]
        let size = (usize)topology.offsets[face + 1] - start
        var sum = Vector3()
        for at in 0..<size: sum = sum.add(level.positions[(usize)topology.corners[start + at]])
        level.out[base + face] = sum.multiply_scalar(1.0 / (f64)size)

## The sharpness of an edge at this level (boundary and non-manifold: infinite).
func sharpness_of(level: const Level*, edge: usize) -> f32:
    let topology = level.topology
    if topology.edge_corner_offsets[edge + 1] - topology.edge_corner_offsets[edge] != 2: return infinite
    return level.edge_sharpness[edge]

func edge_points(context: void*, first: usize, end: usize, worker: usize):
    let level = (Level*)context
    let topology = level.topology
    let face_base = topology.points + topology.edges()
    for index in first..<end:
        let edge = element(level.edges, index)
        let a = level.positions[(usize)topology.edge_points[edge * 2]]
        let b = level.positions[(usize)topology.edge_points[edge * 2 + 1]]
        let middle = a.add(b).multiply_scalar(0.5)
        let sharpness = (f64)sharpness_of(level, edge)
        if sharpness >= 1.0 or level.scheme == Scheme.bilinear:
            level.out[topology.points + edge] = middle
            continue
        let slot = (usize)topology.edge_corner_offsets[edge]
        let c1 = (usize)topology.edge_corners[slot]
        let c2 = (usize)topology.edge_corners[slot + 1]
        var smooth = middle
        if level.scheme == Scheme.loop:
            # 3/8 of each end, 1/8 of each opposite point.
            let c = level.positions[(usize)topology.corners[topology.next(topology.next(c1))]]
            let d = level.positions[(usize)topology.corners[topology.next(topology.next(c2))]]
            smooth = a.add(b).multiply_scalar(0.375).add(c.add(d).multiply_scalar(0.125))
        else:
            let f1 = level.out[face_base + (usize)topology.corner_faces[c1]]
            let f2 = level.out[face_base + (usize)topology.corner_faces[c2]]
            smooth = a.add(b).add(f1).add(f2).multiply_scalar(0.25)
        level.out[topology.points + edge] = smooth if sharpness <= 0.0 else mix(smooth, middle, sharpness)

func mix(a: Vector3, b: Vector3, t: f64) -> Vector3:
    return a.add(b.subtract(a).multiply_scalar(t))

## Loop's vertex weight for n neighbors.
pub func loop_beta(n: f64) -> f64:
    let c = 0.375 + 0.25 * math.cos(2.0 * math.pi / n)
    return (0.625 - c * c) / n

func vertex_points(context: void*, first: usize, end: usize, worker: usize):
    let level = (Level*)context
    let topology = level.topology
    let face_base = topology.points + topology.edges()
    for index in first..<end:
        let point = element(level.points, index)
        let here = level.positions[point]
        if level.scheme == Scheme.bilinear:
            level.out[point] = here
            continue
        let start = (usize)topology.point_edge_offsets[point]
        let stop = (usize)topology.point_edge_offsets[point + 1]
        let n = (f64)(stop - start)
        var neighbors = Vector3()
        var faces = Vector3()
        var sharp_count: usize = 0
        var sharp_sum = 0.0
        var sharp_ends = Vector3()
        for slot in start..<stop:
            let edge = (usize)topology.point_edges[slot]
            let a = (usize)topology.edge_points[edge * 2]
            let other = level.positions[(usize)topology.edge_points[edge * 2 + 1] if a == point else a]
            neighbors = neighbors.add(other)
            let sharpness = (f64)sharpness_of(level, edge)
            if sharpness > 0.0:
                sharp_count += 1
                sharp_sum += math.min(1.0, sharpness)
                sharp_ends = sharp_ends.add(other)
            if level.scheme != Scheme.loop:
                for at in (usize)topology.edge_corner_offsets[edge]..<(usize)topology.edge_corner_offsets[edge + 1]:
                    faces = faces.add(level.out[face_base + (usize)topology.corner_faces[(usize)topology.edge_corners[at]]])
        if n == 0.0:
            level.out[point] = here
            continue
        # The smooth rule (interior points; sharp ones use it only to blend).
        var smooth = here
        if level.scheme == Scheme.loop:
            let beta = loop_beta(n)
            smooth = here.multiply_scalar(1.0 - n * beta).add(neighbors.multiply_scalar(beta))
        else:
            # Q (face points, each face met twice) + 2R (edge midpoints) + (n - 3)v.
            let q = faces.multiply_scalar(1.0 / (2.0 * n))
            let r = here.add(neighbors.multiply_scalar(1.0 / n)).multiply_scalar(0.5)
            smooth = q.add(r.multiply_scalar(2.0)).add(here.multiply_scalar(n - 3.0)).multiply_scalar(1.0 / n)
        let corner = (f64)level.point_sharpness[point]
        var rule = smooth
        var weight = 0.0
        if corner > 0.0:
            rule = here
            weight = math.min(1.0, corner)
        elif sharp_count > 2:
            rule = here
            weight = sharp_sum / (f64)sharp_count
        elif sharp_count == 2:
            rule = sharp_ends.add(here.multiply_scalar(6.0)).multiply_scalar(0.125)
            weight = sharp_sum / 2.0
        level.out[point] = rule if weight >= 1.0 else mix(smooth, rule, weight)