dymokomi/luce-geocore
Source of release 0.7.2
0.7.2 / src / verbs / bevel_profiles.lucb
## PolyBevel's profiles, in parallel per bevel vertex (count, prefix sum,
## fill, as for the corners). Each end of a beveled edge needs the profile
## from one face's offset line to the other's at that vertex: a quadratic
## curve whose control point is the vertex for the round 0.5. Two strips
## whose ends meet the same two points share one profile, reversed, so a
## loop of beveled edges through a vertex stays closed. At the end of a lone
## beveled edge the vertex stays and the strip fans around it: the profile's
## inner points are the vertex.
## One profile of a vertex: its end points and where its points start.
struct Known:
let start: i32
let end: i32
let first: usize
## A profile pass over the vertices (see CornerPass).
struct ProfilePass:
let work: Bevel*
let filling: bool
let corner_points: usize
func place_profiles(work: Bevel*) -> !:
let slots = work.vertex_points.count
let edges = work.topology.edges()
try work.end_profile.fill(edges * 2, 0)
try work.end_reversed.fill(edges * 2, 0)
# Sizes per slot: new points and profile entries.
for slot in 0..<slots + 1:
work.slot_points.items[slot] = 0
work.slot_entries.items[slot] = 0
let corner_points = work.created.count
var counting = ProfilePass(work, false, corner_points)
try parallel.for_each_range(slots, 256, (void*)&counting, plan_profiles)
var points: u32 = 0
var entries: u32 = 0
for slot in 0..<slots + 1:
let point_count = work.slot_points.items[slot]
let entry_count = work.slot_entries.items[slot]
work.slot_points.items[slot] = points
work.slot_entries.items[slot] = entries
points += point_count
entries += entry_count
try work.created.extend(corner_points + (usize)points, NewPoint(Vector3(), -1, -1, 0.0, -1))
try work.point_source.extend(corner_points + (usize)points, -1)
try work.profile_points.fill((usize)entries, -1)
var filling = ProfilePass(work, true, corner_points)
try parallel.for_each_range(slots, 256, (void*)&filling, plan_profiles)
func plan_profiles(context: void*, first: usize, end: usize, worker: usize) -> !:
let pass = (ProfilePass*)context
var known = Growing[Known]()
defer known.close()
for slot in first..<end:
try vertex_profiles(pass, &known, slot)
## The profiles at one vertex: one per distinct pair of end points among
## its beveled edges' ends there.
func vertex_profiles(pass: ProfilePass*, known: Growing[Known]*, slot: usize) -> !:
let work = pass.work
if work.fan_valid.items[slot] == 0: return
let topology = &work.topology
let vertex = work.vertex_points.items[slot]
let n = work.segments
let terminal_end = work.retained.items[slot] == 2
let inner = 0 if terminal_end else n - 1
let entry_base = (usize)work.slot_entries.items[slot]
let point_base = pass.corner_points + (usize)work.slot_points.items[slot]
known.clear()
for at in (usize)topology.point_edge_offsets[(usize)vertex]..<(usize)topology.point_edge_offsets[(usize)vertex + 1]:
let edge = (usize)topology.point_edges[at]
if not work.beveled.get(edge): continue
let first = (usize)topology.edge_corner_offsets[edge]
let c1 = (usize)topology.edge_corners[first]
let c2 = (usize)topology.edge_corners[first + 1]
# At the edge's start (face 1's corner): face 1's last new corner to
# face 2's first; at its end: face 1's first to face 2's last.
let at_start = topology.corners[c1] == vertex
let side: usize = 0 if at_start else 1
let start = last_point(work, c1) if at_start else first_point(work, topology.next(c1))
let end = first_point(work, topology.next(c2)) if at_start else last_point(work, c2)
var found: i64 = -1
var reversed = false
for index in 0..<known.count:
let other = known.items[index]
if (other.start == start and other.end == end) or (other.start == end and other.end == start):
found = (i64)index
reversed = other.start != start
break
if found < 0:
found = (i64)known.count
try known.push(Known(start, end, known.count * (n + 1)))
if pass.filling: fill_profile(work, slot, entry_base + known.count * (n + 1) - (n + 1), point_base + (known.count - 1) * inner, start, end, terminal_end)
if pass.filling:
work.end_profile.items[edge * 2 + side] = (u32)(entry_base + known.items[(usize)found].first)
work.end_reversed.items[edge * 2 + side] = 1 if reversed else 0
if not pass.filling:
work.slot_entries.items[slot] = (u32)(known.count * (n + 1))
work.slot_points.items[slot] = (u32)(known.count * inner)
## Write one profile's points from entry `at`, its new inner points from
## created index `made`.
func fill_profile(work: Bevel*, slot: usize, at: usize, made: usize, start: i32, end: i32, terminal_end: bool):
let n = work.segments
let vertex = work.vertex_points.items[slot]
let a = point_at(work, start)
let b = point_at(work, end)
let middle = a.add(b).multiply_scalar(0.5)
let control = middle.add(point_at(work, vertex).subtract(middle).multiply_scalar(2.0 * work.profile))
work.profile_points.items[at] = start
work.profile_points.items[at + n] = end
for step in 1..<n:
if terminal_end:
work.profile_points.items[at + step] = vertex
continue
let t = (f64)step / (f64)n
let placed = a.multiply_scalar((1.0 - t) * (1.0 - t)).add(control.multiply_scalar(2.0 * t * (1.0 - t))).add(b.multiply_scalar(t * t))
let index = made + step - 1
work.created.items[index] = NewPoint(placed, vertex, -1, 0.0, (i32)slot)
work.profile_points.items[at + step] = (i32)(work.topology.points + index)
## Point `step` (0..segments) of the profile at edge `edge`'s `side` end
## (0 the start, where face 1's corner is), running from face 1's side.
func profile_point(work: const Bevel*, edge: usize, side: usize, step: usize) -> i32:
let first = (usize)work.end_profile.items[edge * 2 + side]
let index = work.segments - step if work.end_reversed.items[edge * 2 + side] == 1 else step
return work.profile_points.items[first + index]