dymokomi/luce-geocore
Source of release 0.7.1
0.7.1 / src / geometries / polygon / edits.lucb
## Operators that publish new meshes: remapping through parent maps, position
## edits, placement and merging. Position edits copy the positions once, share
## the topology, its caches, the triangles and every attribute, recompute only
## the faces around moved points, and refit the spatial index.
extend Mesh:
## All operators publish new meshes. Parent maps are output-to-input indices;
## -1 means a genuinely new element (zero-valued attributes). Empty maps mean
## unchanged indexing, valid only when domain cardinality is unchanged. Edge
## attributes follow their corners. The result is precise when this mesh
## is, or when `precise` asks.
pub func remapped(points: const Vector3[], sizes: const i64[], corners: const i64[],
point_parents: const i64[], face_parents: const i64[], corner_parents: const i64[], preserve_normals: bool = false, display: const i64[]? = none, precise: bool = false) -> interop.Reference[Mesh]!:
try validate_map(point_parents, points.length, self.positions.count())
try validate_map(face_parents, sizes.length, self.offsets.count() - 1)
try validate_map(corner_parents, corners.length, self.corners.count())
let result = try make_mesh(points, sizes, corners, display, precise or self.is_precise())
errdefer result.release()
let output = result.value()
var unchanged_geometry = points.length == self.positions.count() and sizes.length == self.offsets.count() - 1 and corners.length == self.corners.count()
if unchanged_geometry and not preserve_normals:
let old_offsets = self.offsets.view()
let old_corners = self.corners.view()
for at in 0..<points.length:
let old = self.point_at(at)
unchanged_geometry = unchanged_geometry and points[at].x == old.x and points[at].y == old.y and points[at].z == old.z
for at in 0..<sizes.length:
unchanged_geometry = unchanged_geometry and sizes[at] == (i64)(old_offsets[at + 1] - old_offsets[at])
for at in 0..<corners.length:
unchanged_geometry = unchanged_geometry and corners[at] == (i64)old_corners[at]
let pp = try narrowed(point_parents)
defer free(pp) in memory.heap
let fp = try narrowed(face_parents)
defer free(fp) in memory.heap
let cp = try narrowed(corner_parents)
defer free(cp) in memory.heap
try self.transfer_attributes(output, pp, fp, cp, unchanged_geometry or preserve_normals)
return result
## Put every attribute of this mesh on `output` through the parent maps
## (empty: unchanged indexing); edge attributes follow `edge_parents_of`.
## An authored N is dropped unless `keep_normals`: after an arbitrary edit
## the derived normals are right and the old ones stale.
func transfer_attributes(output: Mesh*, point_parents: const i32[], face_parents: const i32[], corner_parents: const i32[], keep_normals: bool) -> !:
var edge_map: i32[]
defer:
if edge_map.length > 0: free(edge_map) in memory.heap
for index in 0..<self.attributes.count():
let entry = self.attributes.entry(index)
if entry.name() == "N" and not keep_normals:
continue
if entry.domain == Domain.edge and edge_map.length == 0 and corner_parents.length > 0:
edge_map = try self.edge_parents_of(output, corner_parents)
let parents = point_parents if entry.domain == Domain.point else (corner_parents if entry.domain == Domain.corner else (edge_map if entry.domain == Domain.edge else face_parents))
try output.attributes.put(try attribute_ops.remapped(entry, parents, (try output.domain_size(entry.domain))))
## The old edge each of `output`'s edges continues, or -1 for a new edge.
## An output corner and the next one in its face continue an old edge when
## their parents are neighbours in an old face (in either direction): the
## bottom of an extrusion wall continues its old edge, while the wall's
## sides, whose ends share one parent, are new.
func edge_parents_of(output: const Mesh*, corner_parents: const i32[]) -> i32[]!:
let new_edges = (try output.edge_arrays()).1
let old_edges = (try self.edge_arrays()).1
let old_faces = try self.corner_faces()
let old_offsets = self.offsets.view()
let offsets = output.offsets.view()
let parents = try new i32[(usize)(try output.edge_count())] --- in memory.heap
for at in 0..<parents.length: parents[at] = -1
for face in 0..<offsets.length - 1:
let start = (usize)offsets[face]
let end = (usize)offsets[face + 1]
for corner in start..<end:
let edge = (usize)new_edges[corner]
if parents[edge] >= 0: continue
let a = corner_parents[corner]
let b = corner_parents[corner + 1 if corner + 1 < end else start]
if a < 0 or b < 0 or a == b: continue
let old_face = (usize)old_faces[(usize)a]
if old_face != (usize)old_faces[(usize)b]: continue
let old_start = old_offsets[old_face]
let size = old_offsets[old_face + 1] - old_start
if old_start + (a - old_start + 1) % size == b:
parents[edge] = old_edges[(usize)a]
elif old_start + (b - old_start + 1) % size == a:
parents[edge] = old_edges[(usize)b]
return parents
## Position-only edits keep this mesh's topology, its caches and its
## triangle indices, recomputing moved faces' normals and the bounds. The
## spatial index refits lazily on the first query. Authored normals ("N")
## around the moved points take the new shape's smooth normals; the rest
## keep theirs (normal_refresh.lucb).
pub func with_positions(points: const Vector3[]) -> interop.Reference[Mesh]!:
if points.length != self.positions.count(): error(errors.invalid, "a position edit keeps the point count")
if self.is_precise(): return try self.rebuilt(points, false)
let previous = self.positions.view()
var fresh = try Column[Float3].allocate(points.length)
defer fresh.release()
let output = fresh.span()
for at in 0..<points.length:
if not points[at].is_finite(): error(errors.invalid, "mesh points must be finite and bounded to 1e6")
output[at] = Float3.of(points[at].subtract(self.origin))
let moved = try changed_points(previous, output)
defer free(moved) in memory.heap
return try self.repositioned(fresh, self.origin, moved, false)
pub func moved_points(selection: const i64[], delta: Vector3) -> interop.Reference[Mesh]!:
if not delta.is_finite():
error(errors.invalid, "point displacement must be finite")
let count = self.positions.count()
let marked = try new bool[count] --- in memory.heap
defer free(marked) in memory.heap
memory.set(u8[]((u8*)marked.data, count), 0)
var unique: usize = 0
for index in selection:
try checked(index, count)
if not marked[(usize)index]:
marked[(usize)index] = true
unique += 1
if self.is_precise():
let points = try self.world_points(Matrix4())
defer free(points) in memory.heap
for point in 0..<count:
if marked[point]: points[point] = points[point].add(delta)
return try self.rebuilt(points, false)
var fresh = self.positions.share()
defer fresh.release()
let output = try fresh.writable()
let moved = try new u32[unique] --- in memory.heap
defer free(moved) in memory.heap
var written: usize = 0
for point in 0..<count:
if not marked[point]: continue
let next = Float3.of(output[point].vector().add(delta))
if next.x != output[point].x or next.y != output[point].y or next.z != output[point].z:
output[point] = next
moved[written] = (u32)point
written += 1
return try self.repositioned(fresh, self.origin, moved[..<written], false)
## Share `fresh` (positions relative to `origin`) whose points `moved`
## changed; the caller keeps its own reference. `rigid` promises an orientation-preserving affine map: no
## triangle folds and shading normals stay valid.
func repositioned(fresh: Column[Float3], origin: Vector3, moved: const u32[], rigid: bool) -> interop.Reference[Mesh]!:
# Once filled, the storage belongs to adopt, which disposes it on failure.
return try adopt_storage(try self.repositioned_storage(fresh, origin, moved, rigid))
func repositioned_storage(fresh: Column[Float3], origin: Vector3, moved: const u32[], rigid: bool) -> Mesh*!:
var owned = fresh.share()
if moved.length == 0 and origin == self.origin:
owned.release()
return try self.snapshot_storage()
errdefer owned.release()
let incidence = try self.incidence()
let shape = position_edit.Shape(self.positions.view(), owned.view(), origin, self.offsets.view(), self.corners.view(), self.triangles.view(), incidence.0, incidence.1)
var edit = try position_edit.reposition(&shape, self.normals, moved, rigid)
errdefer edit.close()
var attributes = try self.attributes.shared()
errdefer attributes.close()
if not rigid:
let surface = Surface(owned.view(), self.offsets.view(), self.corners.view(), edit.normals.view(), incidence.0, incidence.1)
try refresh_normals(&attributes, &surface, moved)
let reuse_triangles = edit.triangles.is_empty()
let queries = try QueryCache.after(self.queries)
errdefer release_query(queries)
let shading = try ShadingCache.after(self.shading, moved)
errdefer release_shading(shading)
let storage = try new Mesh[1] --- in memory.heap
storage[0] = self.shared_columns()
# Record provenance: caches keyed on the old positions update in place.
owned.set_parent(self.positions.id())
if moved.length > 0 and moved.length < owned.count():
owned.set_changed((usize)min_of(moved), (usize)max_of(moved) + 1)
storage[0].positions.release()
storage[0].positions = owned
storage[0].origin = origin
storage[0].normals.release()
storage[0].normals = edit.normals
if not reuse_triangles:
storage[0].triangles.release()
storage[0].triangles = edit.triangles
storage[0].extent = edit.extent
storage[0].attributes = attributes
storage[0].queries = queries
storage[0].shading = shading
_ = self.topology.users.add(1, .relaxed)
return storage.data
## A display mesh: `fresh` positions (relative to this mesh's origin, the
## caller keeping its reference) whose points `moved` changed, with this
## mesh's triangles and every other column shared. Face normals of the
## faces around `moved` are recomputed; a face that collapses keeps a zero
## normal instead of failing (a subdivided limit surface may pinch).
func displayed_storage(fresh: Column[Float3], moved: const u32[]) -> Mesh*!:
var owned = fresh.share()
errdefer owned.release()
let incidence = try self.incidence()
var normals = self.normals.share()
errdefer normals.release()
let output = try normals.writable()
let faces = self.offsets.count() - 1
var touched = try BitsBuilder.zeros(faces)
defer touched.close()
for point in moved:
for at in (usize)incidence.0[(usize)point]..<(usize)incidence.0[(usize)point + 1]: touched.set((usize)incidence.1[at])
var work = DisplayNormals(owned.view(), self.offsets.view(), self.corners.view(), touched.view(), output)
parallel.parallel_for(faces, 4096, display_normals, (void*)&work)
var attributes = try self.attributes.shared()
errdefer attributes.close()
let queries = try QueryCache.after(self.queries)
errdefer release_query(queries)
let shading = try ShadingCache.after(self.shading, moved)
errdefer release_shading(shading)
let extent = try position_edit.bounds_of(owned.view(), self.origin)
let storage = try new Mesh[1] --- in memory.heap
storage[0] = self.shared_columns()
owned.set_parent(self.positions.id())
if moved.length > 0 and moved.length < owned.count():
owned.set_changed((usize)min_of(moved), (usize)max_of(moved) + 1)
storage[0].positions.release()
storage[0].positions = owned
storage[0].normals.release()
storage[0].normals = normals
storage[0].extent = extent
storage[0].attributes = attributes
storage[0].queries = queries
storage[0].shading = shading
_ = self.topology.users.add(1, .relaxed)
return storage.data
pub func transformed(translation: Vector3, rotation: Vector3, scale: Vector3) -> interop.Reference[Mesh]!:
if not translation.is_finite() or not rotation.is_finite() or not scale.is_finite() or math.abs(scale.x) < 0.000001 or math.abs(scale.y) < 0.000001 or math.abs(scale.z) < 0.000001:
error(errors.invalid, "mesh transform must be finite and nonsingular")
let matrix = Matrix4.compose(translation, rotation, scale)
return try self.placed(matrix)
## Affine placement preserves attributes and inverse-transposes normals.
pub func placed(matrix: Matrix4) -> interop.Reference[Mesh]!:
if not matrix.is_finite() or math.abs(matrix.determinant()) < 0.000000000001:
error(errors.invalid, "mesh placement must be finite and nonsingular")
# Without a reflection, placement is a position-only edit: topology and
# triangles are shared, and no triangle can fold. The origin moves with
# the mesh, so positions only take the linear part.
if matrix.determinant() > 0.0 and self.is_precise():
let points = try self.world_points(matrix)
defer free(points) in memory.heap
let result = try self.rebuilt(points, true)
errdefer result.release()
try position_edit.transform_normals(&result.value().attributes, matrix)
return result
if matrix.determinant() > 0.0:
let origin = matrix.transform_point(self.origin)
let previous = self.positions.view()
var fresh = try Column[Float3].allocate(previous.length)
defer fresh.release()
let output = fresh.span()
for at in 0..<previous.length:
output[at] = Float3.of(matrix.transform_direction(previous[at].vector()))
let moved = try new u32[previous.length] --- in memory.heap
defer free(moved) in memory.heap
for at in 0..<moved.length: moved[at] = (u32)at
let placed_mesh = try self.repositioned(fresh, origin, moved, true)
errdefer placed_mesh.release()
try position_edit.transform_normals(&placed_mesh.value().attributes, matrix)
return placed_mesh
# Reversing corners preserves outward normals under a reflection.
let points = try self.world_points(matrix)
defer free(points) in memory.heap
let old_corners = self.corners.view()
let offsets = self.offsets.view()
let faces = offsets.length - 1
let sizes = try new i64[faces] --- in memory.heap
defer free(sizes) in memory.heap
let corners = try new i64[old_corners.length] --- in memory.heap
defer free(corners) in memory.heap
let parents = try new i64[old_corners.length] --- in memory.heap
defer free(parents) in memory.heap
for face in 0..<faces:
let start = (usize)offsets[face]
let count = (usize)offsets[face + 1] - start
sizes[face] = (i64)count
for at in 0..<count:
corners[start + at] = (i64)old_corners[start + count - 1 - at]
parents[start + at] = (i64)(start + count - 1 - at)
var unchanged: i64[]
let old_triangles = self.triangles.view()
let display = try new i64[old_triangles.length] --- in memory.heap
defer free(display) in memory.heap
for triangle in 0..<display.length // 3:
for at in 0..<(usize)3:
let old = (usize)old_triangles[triangle * 3 + (2 - at)]
display[triangle * 3 + at] = parents[old]
let result = try self.remapped(points, sizes, corners, unchanged, unchanged, parents, true, display)
errdefer result.release()
try position_edit.transform_normals(&result.value().attributes, matrix)
return result
## Every point placed by `matrix`, in f64; the caller frees them.
func world_points(matrix: Matrix4) -> Vector3[]!:
let points = try new Vector3[self.positions.count()] --- in memory.heap
for at in 0..<points.length:
points[at] = matrix.transform_point(self.point_at(at))
return points
## This topology over new `points`, rebuilt through `remapped`: the
## position edit of a precise mesh, whose f64 points need a full
## construction. The triangles are kept unless one of them folds.
func rebuilt(points: const Vector3[], preserve_normals: bool) -> interop.Reference[Mesh]!:
let offsets = self.offsets.view()
let old_corners = self.corners.view()
let old_triangles = self.triangles.view()
let sizes = try new i64[offsets.length - 1] --- in memory.heap
defer free(sizes) in memory.heap
for face in 0..<sizes.length: sizes[face] = (i64)(offsets[face + 1] - offsets[face])
let corners = try new i64[old_corners.length] --- in memory.heap
defer free(corners) in memory.heap
for at in 0..<corners.length: corners[at] = (i64)old_corners[at]
let display = try new i64[old_triangles.length] --- in memory.heap
defer free(display) in memory.heap
for at in 0..<display.length: display[at] = (i64)old_triangles[at]
var unchanged: i64[]
let kept: interop.Reference[Mesh]? = self.remapped(points, sizes, corners, unchanged, unchanged, unchanged, preserve_normals, display) catch failure:
if failure.code != errors.invalid: error(failure.code, failure.message)
recover none
if let result = kept: return result
return try self.remapped(points, sizes, corners, unchanged, unchanged, unchanged, preserve_normals)
## This mesh's points and faces, then `other`'s (see concatenated).
pub func merged(other: interop.Reference[Mesh]) -> interop.Reference[Mesh]!:
let parts: MeshPart[2] = [MeshPart(&self, Matrix4()), MeshPart(try other.get(), Matrix4())]
return try concatenated(parts)
## A parent map in i32 (the caller frees it); empty stays empty.
func narrowed(parents: const i64[]) -> i32[]!:
let result = try new i32[parents.length] --- in memory.heap
for at in 0..<parents.length: result[at] = (i32)parents[at]
return result
## The points whose stored positions differ between `previous` and `next`.
## The caller frees the list.
func changed_points(previous: const Float3[], next: const Float3[]) -> u32[]!:
var count: usize = 0
for at in 0..<next.length:
let a = previous[at]
let b = next[at]
if a.x != b.x or a.y != b.y or a.z != b.z: count += 1
let moved = try new u32[count] --- in memory.heap
var written: usize = 0
for at in 0..<next.length:
let a = previous[at]
let b = next[at]
if a.x != b.x or a.y != b.y or a.z != b.z:
moved[written] = (u32)at
written += 1
return moved
func min_of(values: const u32[]) -> u32:
var least = values[0]
for value in values: least = value if value < least else least
return least
func max_of(values: const u32[]) -> u32:
var most = values[0]
for value in values: most = value if value > most else most
return most
struct DisplayNormals:
let positions: const Float3[]
let offsets: const i32[]
let corners: const i32[]
let touched: Bits
let normals: Float3[]
func display_normals(context: void*?, first: usize, end: usize):
let work = (DisplayNormals*)(context else return)
for face in first..<end:
if not work.touched.get(face): continue
let start = (usize)work.offsets[face]
let size = (usize)work.offsets[face + 1] - start
var normal = Vector3()
for at in 0..<size:
let p = work.positions[(usize)work.corners[start + at]].vector()
let q = work.positions[(usize)work.corners[start + (at + 1) % size]].vector()
normal = normal.add(p.cross(q))
let length = normal.length()
work.normals[face] = Float3.of(normal.multiply_scalar(1.0 / length) if length > 0.0 else Vector3())