Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.3

0.7.3 / src / verbs / symmetry.lucb

## Positional symmetry and soft falloff for the Edit engine. A mirror map
## pairs each element with the one at its reflection across an axis plane
## through the origin (within a tolerance scaled to the model), found through
## a PointHash; a group becomes symmetric by adding the
## mirrors of its members. Soft weights fall off with the distance to the
## nearest group point, found through a PointHash of cells one radius wide.

## The tolerance mirrors are matched within: a ten-thousandth of the
## model's size.
pub func mirror_tolerance(mesh: const Mesh*) -> f64:
    let box = mesh.bounds()
    return math.max(0.000000001, box.maximum.subtract(box.minimum).length() * 0.0001)

## Where each element of `domain` sits, in f64: points, face centers, edge
## midpoints.
func element_positions(mesh: const Mesh*, topology: const Topology*, domain: Domain, out: Growing[Vector3]*) -> !:
    let points = mesh.point_span()
    let origin = mesh.position_origin()
    let count = topology.size(domain)
    try out.reserve(count)
    out.count = count
    for at in 0..<count:
        var p = Vector3()
        if domain == Domain.point:
            p = points[at].vector()
        elif domain == Domain.edge:
            p = points[(usize)topology.edge_points[at * 2]].vector().add(points[(usize)topology.edge_points[at * 2 + 1]].vector()).multiply_scalar(0.5)
        else:
            let start = (usize)topology.offsets[at]
            let end = (usize)topology.offsets[at + 1]
            for corner in start..<end: p = p.add(points[(usize)topology.corners[corner]].vector())
            p = p.multiply_scalar(1.0 / (f64)(end - start))
        out.items[at] = p.add(origin)

## Each element's mirror across `axis` (-1 when nothing sits there).
pub func mirror_map(mesh: const Mesh*, domain: Domain, axis: i64, out: Growing[i32]*) -> !:
    let topology = try Topology.of(mesh)
    let tolerance = mirror_tolerance(mesh)
    if domain == Domain.corner:
        var points = Growing[i32]()
        defer points.close()
        try mirror_map(mesh, Domain.point, axis, &points)
        var faces = Growing[i32]()
        defer faces.close()
        try mirror_map(mesh, Domain.face, axis, &faces)
        try out.fill(topology.corners.length, -1)
        for corner in 0..<topology.corners.length:
            let face = faces.items[(usize)topology.corner_faces[corner]]
            let point = points.items[(usize)topology.corners[corner]]
            if face < 0 or point < 0: continue
            for at in (usize)topology.offsets[(usize)face]..<(usize)topology.offsets[(usize)face + 1]:
                if topology.corners[at] == point: out.items[corner] = (i32)at
        return
    var positions = Growing[Vector3]()
    defer positions.close()
    try element_positions(mesh, &topology, domain, &positions)
    var grid = try PointHash.build(positions.view(), tolerance * 4.0)
    defer grid.close()
    try out.fill(positions.count, -1)
    for at in 0..<positions.count:
        out.items[at] = grid.nearest(positions.view(), positions.items[at].reflected((usize)(axis - 1)), tolerance)

## `bits` with the mirror of every member added.
pub func symmetric(mesh: const Mesh*, bits: Bits, domain: Domain, axis: i64) -> BitsBuilder!:
    var result = try BitsBuilder.copy_of(bits)
    errdefer result.close()
    var mirrors = Growing[i32]()
    defer mirrors.close()
    try mirror_map(mesh, domain, axis, &mirrors)
    for word in 0..<bits.words.length:
        var pending = bits.words[word]
        while pending != 0:
            let element = word * 64 + (usize)trailing_zeros(pending)
            pending = pending & (pending - 1)
            let mirror = mirrors.items[element]
            if mirror >= 0: result.set((usize)mirror)
    return result

## Soft weights of every point: 1 in `group`, falloff(1 - d / radius) within
## `radius` of its nearest member, 0 beyond. Falloff 0 linear, 1 quadratic,
## 2 cubic, 3 smooth (Houdini's Edit SOP falloffs).
pub func soft_weights(mesh: const Mesh*, group: Bits, radius: f64, falloff: i64, weights: f32[]) -> !:
    let points = mesh.point_span()
    var members = Growing[Vector3]()
    defer members.close()
    try members.reserve(group.population())
    for word in 0..<group.words.length:
        var pending = group.words[word]
        while pending != 0:
            let point = word * 64 + (usize)trailing_zeros(pending)
            pending = pending & (pending - 1)
            members.items[members.count] = points[point].vector()
            members.count += 1
    var grid = try PointHash.build(members.view(), radius)
    defer grid.close()
    var work = SoftWork(points, group, members.view(), &grid, radius, falloff, weights)
    try parallel.for_each_range(points.length, 4096, (void*)&work, soft_points)

## Soft weights of every point for a selection's components, as Transform
## Components weighs them: the selection's points (with their mirrors across
## `symmetry`, 1..3 for X, Y, Z; 0 none) are the group. The Edit viewport
## tints points by these while the soft radius is on.
pub func selection_weights(mesh: const Mesh*, selection: const Selection*, radius: f64, falloff: i64, symmetry: i64, weights: f32[]) -> !:
    if weights.length != (usize)mesh.point_count(): error(errors.invalid, "soft weights need one slot per point")
    if not (radius > 0.0) or not math.is_finite(radius): error(errors.invalid, "the soft radius must be positive and finite")
    if symmetry < 0 or symmetry > 3: error(errors.invalid, "symmetry is 0 (none) or 1..3 (X, Y, Z)")
    let topology = try Topology.of(mesh)
    var points = try converted(&topology, selection_bits(selection), Domain((u8)selection.domain()), Domain.point, false)
    defer points.close()
    if symmetry > 0:
        var mirrored = try symmetric(mesh, points.view(), Domain.point, symmetry)
        defer mirrored.close()
        try soft_weights(mesh, mirrored.view(), radius, falloff, weights)
        return
    try soft_weights(mesh, points.view(), radius, falloff, weights)

struct SoftWork:
    let points: const Float3[]
    let group: Bits
    let members: const Vector3[]
    let grid: const PointHash*
    let radius: f64
    let falloff: i64
    let weights: f32[]

func soft_points(context: void*, first: usize, end: usize, worker: usize):
    let work = (SoftWork*)context
    for point in first..<end:
        if work.group.get(point):
            work.weights[point] = 1.0
            continue
        let p = work.points[point].vector()
        let nearest = work.grid.nearest(work.members, p, work.radius)
        if nearest < 0:
            work.weights[point] = 0.0
            continue
        let t = 1.0 - work.members[(usize)nearest].subtract(p).length() / work.radius
        var weight = t
        if work.falloff == 1: weight = t * t
        elif work.falloff == 2: weight = t * t * t
        elif work.falloff == 3: weight = t * t * (3.0 - 2.0 * t)
        work.weights[point] = (f32)math.max(0.0, math.min(1.0, weight))