dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / src / verbs / propagate.lucb
## Carrying attributes and groups through a verb, one column at a time: an
## element with one parent copies it; an interpolated element mixes its
## weighted parents (floats average, normals renormalize, integers, text and
## arrays take the heaviest parent, a group keeps the element only when every
## parent with weight is a member); a new element is zero, empty, not a member.
## Edges continue old edges by corner adjacency (Mesh.edge_parents).
pub func propagate(source: const Mesh*, output: Mesh*, point_parents: const i32[], face_parents: const i32[], corner_parents: const i32[], point_mix: const Mix*, corner_mix: const Mix*) -> !:
var edge_map: i32[]
defer:
if edge_map.length > 0: free(edge_map) in memory.heap
for index in 0..<(usize)source.attribute_count():
let entry = try source.attribute_entry((i64)index)
# Authored normals are stale where topology changed; the derived ones
# take over.
if entry.role == Role.normal and entry.domain != Domain.detail: continue
# Each verb makes its own output selection.
if entry.name() == ".selection": continue
if entry.domain == Domain.edge and edge_map.length == 0:
let representatives = try new i32[corner_parents.length] --- in memory.heap
defer free(representatives) in memory.heap
for at in 0..<corner_parents.length:
representatives[at] = corner_parents[at] if corner_parents[at] >= 0 else -1
edge_map = try edge_parents(source, output, representatives)
try put_attribute(output, try carried(entry, point_parents, face_parents, corner_parents, edge_map, point_mix, corner_mix))
## Mix entry `entry`'s heaviest parent (the first on ties), or -1 for an empty entry.
func heaviest(mix: const Mix*, entry: usize) -> i32:
let first = (usize)mix.offsets.items[entry]
let end = (usize)mix.offsets.items[entry + 1]
if end == first: return -1
var best = first
for at in first..<end:
if mix.weights.items[at] > mix.weights.items[best]: best = at
return (i32)mix.parents.items[best]
func carried(entry: const Attribute*, point_parents: const i32[], face_parents: const i32[], corner_parents: const i32[], edge_map: const i32[], point_mix: const Mix*, corner_mix: const Mix*) -> Attribute!:
match entry.domain:
.point: return try mixed(entry, point_parents, point_mix)
.corner: return try mixed(entry, corner_parents, corner_mix)
.face: return try attribute_ops.remapped(entry, face_parents, face_parents.length)
.edge: return try attribute_ops.remapped(entry, edge_map, edge_map.length)
_: return entry.share()
## `source` over elements taking parents[i] (>= 0), nothing (-1), or mix entry
## -2 - parents[i].
func mixed(source: const Attribute*, parents: const i32[], mix: const Mix*) -> Attribute!:
var direct = try new i32[parents.length] --- in memory.heap
defer free(direct) in memory.heap
var any = false
# An array attribute takes the heaviest parent's array whole (arrays do not average).
let whole = source.storage == Storage.ragged
for at in 0..<parents.length:
direct[at] = parents[at] if parents[at] >= -1 else (heaviest(mix, (usize)(-2 - parents[at])) if whole else -1)
any = any or parents[at] < -1
var result = try attribute_ops.remapped(source, direct, parents.length)
if not any or source.storage == Storage.single or whole: return result
errdefer result.release()
let bytes = try result.data.writable()
# Corners sharing one large mix (a subdivided n-gon's centers) name the
# same entry again and again: its value is worked out once.
var cached: i64 = -1
var cached_values: f64[4]
var cached_write = false
for element in 0..<parents.length:
let code = parents[element]
if code >= -1: continue
let entry = (usize)(-2 - code)
let first = (usize)mix.offsets.items[entry]
let end = (usize)mix.offsets.items[entry + 1]
var values: f64[4]
var write = true
if (i64)entry == cached:
values = cached_values
write = cached_write
else:
match source.kind:
.float32, .float64:
for component in 0..<source.width:
var sum = 0.0
for at in first..<end:
sum += source.number((usize)mix.parents.items[at], component) * (f64)mix.weights.items[at]
values[component] = sum
if source.role == Role.normal and source.width == 3:
let length = math.sqrt(values[0] * values[0] + values[1] * values[1] + values[2] * values[2])
if length > 0.000000001:
for component in 0..<(usize)3: values[component] = values[component] / length
.boolean:
var member = end > first
for at in first..<end:
if mix.weights.items[at] > 0.0 and source.number((usize)mix.parents.items[at], 0) == 0.0: member = false
write = member
_:
# Integers and text: the heaviest parent (the first on ties).
var best = first
for at in first..<end:
if mix.weights.items[at] > mix.weights.items[best]: best = at
let parent = (usize)mix.parents.items[best]
for component in 0..<source.width: values[component] = source.number(parent, component)
if end - first > 4:
cached = (i64)entry
cached_values = values
cached_write = write
if not write: continue
if source.kind == DataType.boolean:
attribute_ops.write_number(bytes, source.kind, element, 1.0)
continue
for component in 0..<source.width:
attribute_ops.write_number(bytes, source.kind, element * source.width + component, values[component])
return result