dymokomi/luce-geocore
Source of release 0.7.8
0.7.8 / src / code / inputs.lucb
# The geometries a snippet reads (`k.input(0)`, `k.input(1)`) for one cook, and what each
# builds on first use: its topology, its point-to-primitive incidence, its vertex tables,
# its spatial index and a point grid; and, before the run, the group expansions, surface
# distance fields and winding-number tree the snippet's calls name. Builtins reach them
# through the run's context.
## One input: its mesh (none when the input is empty) and what was built for it.
struct Source:
var mesh: const Mesh*?
## The whole input (its volumes and SDF), none for an unconnected one.
var set: const GeometrySet*?
var lock: sync.Mutex
var failed: @bool
var topology_ready: @bool
var topology: Topology?
var incidence_ready: @bool
var incidence_offsets: const i32[]
var incidence_faces: const i32[]
var queries_ready: @bool
var index: const TriangleIndex*?
var grid_ready: @bool
var grid: PointGrid
## Vertices (corners) by point, ascending, and the mesh's corner and edge tables.
var vertices_ready: @bool
var point_corner_offsets: i32[]
var point_corners: i32[]
var corner_faces: const i32[]
var corner_edges: const i32[]
var edge_corner_offsets: const i32[]
var edge_corners: const i32[]
## Built before the run (`prepare_named`): groups, distance fields, the winding tree.
var group_sets: collections.List[GroupSet]
var fields: collections.List[SurfaceField]
var winding: WindingTree
func close():
self.grid.close()
if self.point_corner_offsets.length > 0: free(self.point_corner_offsets) in memory.heap
if self.point_corners.length > 0: free(self.point_corners) in memory.heap
for set in self.group_sets.items(): set.close()
self.group_sets.destroy()
for field in self.fields.items(): field.close()
self.fields.destroy()
self.winding.close()
func points() -> usize:
let mesh = self.mesh else return 0
return (usize)mesh.point_count()
func prims() -> usize:
let mesh = self.mesh else return 0
return (usize)mesh.face_count()
## Point `index`'s world position.
func position(index: usize) -> Vector3:
let mesh = self.mesh else return Vector3()
return mesh.point_span()[index].vector().add(mesh.position_origin())
## The topology, built on first use (false when it could not be).
func with_topology() -> bool:
if self.topology_ready.load(.acquire):
return not self.failed.load(.acquire)
self.lock.lock()
defer self.lock.unlock()
if not self.topology_ready.load(.acquire):
if let mesh = self.mesh:
self.topology = Topology.of(mesh) catch failure:
_ = failure
self.failed.store(true, .release)
recover none
self.topology_ready.store(true, .release)
return not self.failed.load(.acquire)
## The primitives around each point, built on first use.
func with_incidence() -> bool:
if self.incidence_ready.load(.acquire):
return not self.failed.load(.acquire)
self.lock.lock()
defer self.lock.unlock()
if not self.incidence_ready.load(.acquire):
if let mesh = self.mesh:
let spans = mesh.point_face_span() catch failure:
_ = failure
self.failed.store(true, .release)
recover (no_ints(), no_ints())
self.incidence_offsets = spans.0
self.incidence_faces = spans.1
self.incidence_ready.store(true, .release)
return not self.failed.load(.acquire)
## The spatial index of the faces, built on first use.
func with_queries() -> bool:
if self.queries_ready.load(.acquire):
return not self.failed.load(.acquire)
self.lock.lock()
defer self.lock.unlock()
if not self.queries_ready.load(.acquire):
if let mesh = self.mesh:
self.index = mesh.query_index() catch failure:
_ = failure
self.failed.store(true, .release)
recover none
self.queries_ready.store(true, .release)
return not self.failed.load(.acquire)
## The vertex tables, built on first use: each point's corners in ascending order,
## and the mesh's corner-to-face, corner-to-edge and edge-to-corner tables.
func with_vertices() -> bool:
if self.vertices_ready.load(.acquire):
return not self.failed.load(.acquire)
self.lock.lock()
defer self.lock.unlock()
if not self.vertices_ready.load(.acquire):
if let mesh = self.mesh:
self.build_vertices(mesh) catch failure:
_ = failure
self.failed.store(true, .release)
self.vertices_ready.store(true, .release)
return not self.failed.load(.acquire)
func build_vertices(mesh: const Mesh*) -> !:
self.corner_faces = try mesh.corner_face_span()
self.corner_edges = try mesh.corner_edge_span()
let (offsets, corners) = try mesh.edge_corner_span()
self.edge_corner_offsets = offsets
self.edge_corners = corners
let points = (usize)mesh.point_count()
let corner_points = mesh.corner_span()
self.point_corner_offsets = try new i32[points + 1] in memory.heap
self.point_corners = try new i32[corner_points.length] --- in memory.heap
for point in corner_points: self.point_corner_offsets[(usize)point + 1] += 1
for at in 0..<points: self.point_corner_offsets[at + 1] += self.point_corner_offsets[at]
var filled = try new i32[points] in memory.heap
defer free(filled) in memory.heap
for (corner, point) in corner_points.indexed():
let p = (usize)point
self.point_corners[(usize)self.point_corner_offsets[p] + (usize)filled[p]] = (i32)corner
filled[p] += 1
## The point grid, built on first use.
func with_grid() -> bool:
if self.grid_ready.load(.acquire):
return not self.failed.load(.acquire)
self.lock.lock()
defer self.lock.unlock()
if not self.grid_ready.load(.acquire):
if let mesh = self.mesh:
self.grid.build(mesh) catch failure:
_ = failure
self.failed.store(true, .release)
self.grid_ready.store(true, .release)
return not self.failed.load(.acquire)
func no_ints() -> const i32[]:
var none_given: const i32[]
return none_given
## A cook's state for its builtins: the inputs and the queued edits.
struct CookState:
var first: Source
var second: Source
var edits: Edits
var ramps: Ramps
var clouds: Clouds
var log: Log
var values: ValueStore
var sh: ShValues
## The program running (literal texts are its call sites' texts).
var program: const Program*?
func close():
self.first.close()
self.second.close()
self.edits.close()
self.ramps.close()
self.clouds.close()
self.log.close()
self.values.close()
self.sh.close()
## The builtins that need each structure, by what they need.
let grid_users: str[5] = ["nearpoint", "nearpoints", "pcopen", "pcfind", "pcfind_radius"]
let index_users: str[4] = ["xyzdist", "closest_prim", "closest_uv", "intersect"]
let topology_users: str[2] = ["neighbor_count", "neighbor"]
let incidence_users: str[2] = ["point_prim_count", "point_prim"]
let vertex_users: str[21] = ["vertex_prim", "vertex_point", "vertex_next", "vertex_prev", "prim_vertex", "prim_vertex_count", "point_vertex_count", "point_vertex", "hedge_next", "hedge_prev", "hedge_src_point", "hedge_dst_point", "hedge_prim", "hedge_equiv_count", "point_hedge", "prim_hedge", "poly_neighbor_count", "poly_neighbor", "computenormal", "primarclen", "curvearclen"]
## Build, on the cook's thread before the run, what `program`'s calls may need of each
## input: built inside the run, one worker builds while the others wait on the lock.
## A structure that fails here fails again lazily, as a fault on the lanes asking for it.
func prepare_sources(state: CookState*, program: const Program*):
for handle: i64 in 0..<2:
let source = &state.first if handle == 0 else &state.second
if source.mesh == none: continue
if calls_any(program, grid_users, handle): _ = source.with_grid()
if calls_any(program, index_users, handle): _ = source.with_queries()
if calls_any(program, topology_users, handle): _ = source.with_topology()
if calls_any(program, incidence_users, handle): _ = source.with_incidence()
if calls_any(program, vertex_users, handle): _ = source.with_vertices()
if calls_any(program, ["minpos"], handle): _ = source.with_queries()
func calls_any(program: const Program*, names: const str[], handle: i64) -> bool:
for name in names:
if program.may_pass(name, 0, handle): return true
return false
## The cook state of a builtin call (trap-free: an absent context reads as no state).
func state_of(call: const engine.Call*) -> CookState*?:
let context = call.run_context else return none
return (CookState*)context
## The input lane `lane` names (argument 0 of every Geometry method), or none for a
## number other than 0 or 1.
func source_at(state: CookState*, call: const engine.Call*, lane: usize) -> Source*?:
let index = call.i64_argument(0)[lane]
if index == 0: return &state.first
if index == 1: return &state.second
return none