dymokomi/luce-geocore
Source of release 0.7.6
0.7.6 / src / script / mesh_edit.lucb
# A mesh's edit form: its positions, polygon offsets and corners in growing arrays, each
# element's parent in the mesh it was opened from (-1 for a new one), and the columns of
# the attributes the script touched. Assembling keeps everything else the source carried:
# when nothing was added or removed, the source's topology and attributes are shared and
# only moved positions and edited columns change; otherwise the attributes follow their
# elements through the parents, new elements taking zero. A polygon whose own point list
# changes is kept aside until a reshape or the assembly settles them all (vertices.lucb).
## A mesh being edited.
struct MeshEdit:
## A share of the mesh it was opened from.
var source: Mesh*?
var origin: Vector3
var positions: Growing[Float3]
## Polygon `f` owns corners offsets[f]..<offsets[f + 1].
var offsets: Growing[i32]
var corners: Growing[i32]
var point_parents: Growing[i32]
var face_parents: Growing[i32]
var corner_parents: Growing[i32]
## Whether elements were added or removed.
var reshaped: bool
## Whether positions may have changed.
var moved: bool
## Whether it changed since the set's mesh was last assembled from it, and
## whether writable spans of it are out (then it may change at any time).
var dirty: bool
var spans: bool
var columns: Growing[EditColumn]
## Polygons whose point lists were rewritten (vertices.lucb).
var rewrites: Rewrites
## The edit form of `source` (none: an empty mesh).
static func open(source: const Mesh*?) -> MeshEdit!:
var made = MeshEdit(source = none, origin = Vector3(), positions = Growing[Float3](), offsets = Growing[i32](), corners = Growing[i32](),
point_parents = Growing[i32](), face_parents = Growing[i32](), corner_parents = Growing[i32](), reshaped = false, moved = false, dirty = false, spans = false,
columns = Growing[EditColumn](), rewrites = Rewrites.empty())
errdefer made.close()
try made.offsets.push(0)
let mesh = source else return made
made.source = try mesh_share(mesh)
made.origin = mesh.position_origin()
try made.positions.assign(mesh.point_span())
try made.offsets.assign(mesh.offset_span())
try made.corners.assign(mesh.corner_span())
try identity(&made.point_parents, made.positions.count)
try identity(&made.face_parents, made.face_count())
try identity(&made.corner_parents, made.corners.count)
return made
func face_count() -> usize:
return self.offsets.count - 1
## Elements of `domain` now.
func domain_size(domain: Domain) -> usize:
match domain:
.point: return self.positions.count
.corner: return self.vertex_total()
.face: return self.face_count()
_: return 1
func check_point(point: i64) -> !:
if point < 0 or (usize)point >= self.positions.count: error(errors.invalid, "the point does not exist")
func check_prim(prim: i64) -> !:
if prim < 0 or (usize)prim >= self.face_count(): error(errors.invalid, "the primitive does not exist")
func add_point(position: f32[4]) -> i64!:
if self.positions.count >= 8388608: error(errors.limit, "a mesh holds at most 8M points")
try self.positions.push(Float3.of(vec3(position).subtract(self.origin)))
try self.point_parents.push(-1)
self.reshaped = true
return (i64)self.positions.count - 1
func add_polygon(points: const i64[]) -> i64!:
if points.length < 3: error(errors.invalid, "a polygon needs at least 3 points")
for point in points: try self.check_point(point)
try self.corners.reserve(self.corners.count + points.length)
for point in points:
try self.corners.push((i32)point)
try self.corner_parents.push(-1)
try self.offsets.push((i32)self.corners.count)
try self.face_parents.push(-1)
try self.rewrites.added()
self.reshaped = true
return (i64)self.face_count() - 1
func position(point: i64) -> f32[4]!:
try self.check_point(point)
return vec4(self.positions.items[(usize)point].vector().add(self.origin))
func set_position(point: i64, position: f32[4]) -> !:
try self.check_point(point)
self.positions.items[(usize)point] = Float3.of(vec3(position).subtract(self.origin))
self.moved = true
func prim_size(prim: i64) -> i64!:
return (i64)(try self.prim_points(prim)).length
func prim_point(prim: i64, index: i64) -> i64!:
let points = try self.prim_points(prim)
if index < 0 or index >= (i64)points.length: error(errors.invalid, "the polygon has no such vertex")
return (i64)points[(usize)index]
## Polygon `prim`'s point numbers in order: its rewritten list when it has one.
func prim_points(prim: i64) -> const i32[]!:
try self.check_prim(prim)
if let rewritten = self.rewrites.list(prim): return rewritten
return self.corners.items[(usize)self.offsets.items[(usize)prim]..<(usize)self.offsets.items[(usize)prim + 1]]
## Remove `numbers` of `domain` (points or prims), renumbering what stays.
func remove(numbers: const i64[], domain: Domain3, points_too: bool) -> !:
try self.settle()
let points = self.positions.count
let faces = self.face_count()
let point_map = try new i64[points] in memory.heap
defer free(point_map) in memory.heap
let face_map = try new i64[faces] in memory.heap
defer free(face_map) in memory.heap
for n in numbers:
if domain == Domain3.point:
try self.check_point(n)
point_map[(usize)n] = -1
else:
try self.check_prim(n)
face_map[(usize)n] = -1
# A polygon losing a point goes; with points_too, a removed polygon's points go
# unless a kept polygon uses them.
for f in 0..<faces:
for c in (usize)self.offsets.items[f]..<(usize)self.offsets.items[f + 1]:
if point_map[(usize)self.corners.items[c]] < 0: face_map[f] = -1
if points_too:
for f in 0..<faces:
if face_map[f] >= 0: continue
for c in (usize)self.offsets.items[f]..<(usize)self.offsets.items[f + 1]: point_map[(usize)self.corners.items[c]] = -1
for f in 0..<faces:
if face_map[f] < 0: continue
for c in (usize)self.offsets.items[f]..<(usize)self.offsets.items[f + 1]: point_map[(usize)self.corners.items[c]] = 0
let kept_points = renumber(point_map)
let kept_faces = renumber(face_map)
# Corners follow their polygons.
let corner_map = try new i64[self.corners.count] in memory.heap
defer free(corner_map) in memory.heap
var corner_at: usize = 0
for f in 0..<faces:
for c in (usize)self.offsets.items[f]..<(usize)self.offsets.items[f + 1]:
corner_map[c] = -1 if face_map[f] < 0 else (i64)corner_at
if face_map[f] >= 0: corner_at += 1
for index in 0..<self.columns.count:
let column = &self.columns.items[index]
match column.domain:
.point: column.compact(point_map, kept_points)
.corner: column.compact(corner_map, corner_at)
.face: column.compact(face_map, kept_faces)
_: continue
# The arrays themselves, in place.
for old in 0..<points:
let to = point_map[old]
if to < 0: continue
self.positions.items[(usize)to] = self.positions.items[old]
self.point_parents.items[(usize)to] = self.point_parents.items[old]
self.positions.count = kept_points
self.point_parents.count = kept_points
var face_at: usize = 0
var written: usize = 0
for f in 0..<faces:
let start = (usize)self.offsets.items[f]
let end = (usize)self.offsets.items[f + 1]
if face_map[f] < 0: continue
self.face_parents.items[face_at] = self.face_parents.items[f]
self.offsets.items[face_at] = (i32)written
for c in start..<end:
self.corners.items[written] = (i32)point_map[(usize)self.corners.items[c]]
self.corner_parents.items[written] = self.corner_parents.items[c]
written += 1
face_at += 1
self.offsets.items[face_at] = (i32)written
self.offsets.count = face_at + 1
self.face_parents.count = face_at
self.corners.count = written
self.corner_parents.count = written
self.reshaped = true
## The column for `name` on `domain`: found, loaded from the source, or (when `make`)
## new with `kind` and `width`; none when missing and not made.
## An array attribute (`ragged`) is made with `width` 1 or 3 for f32 or i32 items.
func column(name: str, domain: Domain, kind: DataType, width: usize, make: bool, group: bool = false, ragged: bool = false) -> EditColumn*?!:
# Vertex columns follow the corners, so rewritten polygons settle first.
if domain == Domain.corner: try self.settle()
for index in 0..<self.columns.count:
let found = &self.columns.items[index]
if found.domain == domain and found.label == name:
try found.grow(self.domain_size(domain))
return found
var made: EditColumn? = none
if let mesh = self.source:
let at = mesh.find_attribute(name, (i64)(u8)domain)
if at >= 0:
let entry = try mesh.attribute_entry(at)
var loaded = try EditColumn.make(name, domain, edit_kind(entry.kind), entry.width, entry.is_group(), entry.is_ragged())
errdefer loaded.close()
try loaded.load(entry, try mesh.domain_size(domain))
# Elements added since opening start at zero.
try self.carry(&loaded, domain)
made = loaded
if made == none:
if not make: return none
made = try EditColumn.make(name, domain, kind, width, group, ragged)
var column = made else trap("a column was neither found nor made")
try column.grow(self.domain_size(domain))
self.columns.push(column) catch failure:
column.close()
error(failure.code, failure.message)
return &self.columns.items[self.columns.count - 1]
## A column loaded from the source in its order, put in the current one through the
## parents (the source's numbering is gone once elements were removed).
func carry(column: EditColumn*, domain: Domain) -> !:
if not self.reshaped: return
try column.gather(self.point_parents.view() if domain == Domain.point else (self.corner_parents.view() if domain == Domain.corner else self.face_parents.view()))
## The assembled mesh (the caller owns it).
func finish() -> Mesh*!:
try self.settle()
let made = try self.assemble()
errdefer mesh_dispose(made)
for index in 0..<self.columns.count:
let column = &self.columns.items[index]
remove_attribute(made, column.label, column.domain)
try put_attribute(made, try column.attribute(self.domain_size(column.domain)))
return made
func assemble() -> Mesh*!:
if let source = self.source:
if not self.reshaped:
if not self.moved: return try mesh_share(source)
var fresh = try Column[Float3].copy_of(self.positions.view())
defer fresh.release()
var changed = Growing[u32]()
defer changed.close()
let old = source.point_span()
for at in 0..<old.length:
let a = old[at]
let b = self.positions.items[at]
if a.x != b.x or a.y != b.y or a.z != b.z: try changed.push((u32)at)
if changed.count == 0: return try mesh_share(source)
return try moved_storage(source, fresh, changed.view())
# A polygon kept from the source keeps its triangles; a new one is triangulated.
var entries: usize = 0
for f in 0..<self.face_count(): entries += ((usize)(self.offsets.items[f + 1] - self.offsets.items[f]) - 2) * 3
var triangles = try Column[i32].allocate(entries)
errdefer triangles.release()
let out = triangles.span()
var old_offsets: const i32[]
var old_triangles: const i32[]
var source_corners: const i32[]
if let source = self.source:
old_offsets = source.offset_span()
old_triangles = source.triangle_span()
source_corners = source.corner_span()
var at: usize = 0
for f in 0..<self.face_count():
let start = (usize)self.offsets.items[f]
let size = (usize)(self.offsets.items[f + 1] - self.offsets.items[f])
let parent = self.face_parents.items[f]
if parent >= 0 and same_corners(old_offsets, source_corners, parent, self.corners.items[start..<start + size]):
let old_start = (usize)old_offsets[(usize)parent]
let base = (old_start - (usize)parent * 2) * 3
for entry in 0..<(size - 2) * 3: out[at + entry] = old_triangles[base + entry] - (i32)old_start + (i32)start
else:
for entry in 0..<(size - 2) * 3: out[at + entry] = -1
at += (size - 2) * 3
var positions = try Column[Float3].copy_of(self.positions.view())
errdefer positions.release()
var offsets = try Column[i32].copy_of(self.offsets.view())
errdefer offsets.release()
var corners = try Column[i32].copy_of(self.corners.view())
errdefer corners.release()
let made = try assembled(positions.take(), self.origin, offsets.take(), corners.take(), triangles.take(), Column[Float3](), Column[Vector3]())
errdefer mesh_dispose(made)
if let source = self.source:
try transfer_attributes(source, made, self.point_parents.view(), self.face_parents.view(), self.corner_parents.view(), true)
return made
func close():
if let source = self.source: mesh_dispose(source)
self.source = none
self.positions.close()
self.offsets.close()
self.corners.close()
self.point_parents.close()
self.face_parents.close()
self.corner_parents.close()
for index in 0..<self.columns.count: self.columns.items[index].close()
self.columns.close()
self.rewrites.close()
## Whether polygon `parent` of the source (its `offsets` and `corners`) runs through
## `points` in the same order: then its triangles still fit.
func same_corners(offsets: const i32[], corners: const i32[], parent: i32, points: const i32[]) -> bool:
let start = (usize)offsets[(usize)parent]
if (usize)offsets[(usize)parent + 1] - start != points.length: return false
for at in 0..<points.length:
if corners[start + at] != points[at]: return false
return true
## 0..<count into `out`.
func identity(out: Growing[i32]*, count: usize) -> !:
try out.reserve(count)
for at in 0..<count: out.items[at] = (i32)at
out.count = count
## Number the entries that are not -1 in order; how many there are.
func renumber(map: i64[]) -> usize:
var next: usize = 0
for at in 0..<map.length:
if map[at] < 0: continue
map[at] = (i64)next
next += 1
return next