dymokomi/luce-geocore
Source of release 0.7.6
0.7.6 / src / script / columns.lucb
# An attribute in edit form: a tuple per element of its domain in a growing array, f32
# for floats, i32 for integers, string-table indices for text and 0/1 for groups. Columns
# are made when a script first reads or writes an attribute by name, from the mesh's own
# attribute when it has one, and become attributes again when the mesh is assembled.
#
# An array attribute (Houdini's f[]@, i[]@, v[]@; `ragged`) keeps each element's items as a
# run in the same float or int pool, found by the element's start and length. Writing a
# longer array appends a new run; the pool is packed when it holds more dead items than
# live ones, and when the column becomes an attribute.
## One attribute being edited.
struct EditColumn:
var label: str
var domain: Domain
## float32, int32, text, or boolean (a group, or a plain boolean attribute).
var kind: DataType
## Components of a tuple (of an item, for an array attribute).
var width: usize
var group: bool
## The tuples (an array attribute's item pool).
var floats: Growing[f32]
var ints: Growing[i32]
var table: TableBuilder
## An array attribute: element e's items are the pool's tuples starts[e] ..<
## starts[e] + lengths[e].
var ragged: bool
var starts: Growing[u32]
var lengths: Growing[u32]
## Items of the pool no element uses any more.
var dead: usize
## An empty column (the caller grows it to its domain's size).
static func make(name: str, domain: Domain, kind: DataType, width: usize, group: bool, ragged: bool = false) -> EditColumn!:
if name.length == 0 or name.length > 64 or name == "P":
error(errors.invalid, "an attribute needs a name of 1..64 bytes other than P")
if width < 1 or width > 4:
error(errors.invalid, "an attribute has 1 to 4 components")
if ragged and ((kind != DataType.float32 and kind != DataType.int32) or (width != 1 and width != 3)):
error(errors.invalid, "array attributes hold f32 or i32 items of 1 or 3 components")
return EditColumn(label = try heap_text(name), domain = domain, kind = kind, width = width, group = group,
floats = Growing[f32](), ints = Growing[i32](), table = TableBuilder(),
ragged = ragged, starts = Growing[u32](), lengths = Growing[u32](), dead = 0)
## Whether its values are floats.
func floating() -> bool:
return self.kind == DataType.float32
## Elements it covers.
func size() -> usize:
if self.ragged: return self.starts.count
return (self.floats.count if self.floating() else self.ints.count) // self.width
## Tuples in the pool (an array attribute's items, dead ones included).
func pooled() -> usize:
return (self.floats.count if self.floating() else self.ints.count) // self.width
## Grow to `elements`, the new ones zero (the empty text; an empty array).
func grow(elements: usize) -> !:
if self.ragged:
try self.starts.extend(elements, 0)
try self.lengths.extend(elements, 0)
return
if self.floating(): try self.floats.extend(elements * self.width, 0.0)
else: try self.ints.extend(elements * self.width, 0 if self.kind != DataType.text else try self.table.intern(""))
## Keep element `old` at `map[old]` when it is 0 or more; `kept` remain.
func compact(map: const i64[], kept: usize):
if self.ragged:
for old in 0..<map.length:
let to = map[old]
if to < 0:
self.dead += (usize)self.lengths.items[old]
continue
self.starts.items[(usize)to] = self.starts.items[old]
self.lengths.items[(usize)to] = self.lengths.items[old]
self.starts.count = kept
self.lengths.count = kept
return
let w = self.width
for old in 0..<map.length:
let to = map[old]
if to < 0: continue
for k in 0..<w:
if self.floating(): self.floats.items[(usize)to * w + k] = self.floats.items[old * w + k]
else: self.ints.items[(usize)to * w + k] = self.ints.items[old * w + k]
if self.floating(): self.floats.count = kept * w
else: self.ints.count = kept * w
## Renumber: new element e takes old element `origin[e]`, or zero (an empty array)
## when it is -1. The text table stays.
func gather(origin: const i32[]) -> !:
if self.ragged:
var starts = Growing[u32]()
errdefer starts.close()
var lengths = Growing[u32]()
errdefer lengths.close()
try starts.extend(origin.length, 0)
try lengths.extend(origin.length, 0)
for at in 0..<origin.length:
if origin[at] < 0: continue
starts.items[at] = self.starts.items[(usize)origin[at]]
lengths.items[at] = self.lengths.items[(usize)origin[at]]
self.starts.close()
self.lengths.close()
self.starts = starts
self.lengths = lengths
# Runs no element points at stay until the next pack.
self.dead = 0
try self.pack()
return
let w = self.width
let zero: i32 = 0 if self.kind != DataType.text else try self.table.intern("")
if self.floating():
var moved = Growing[f32]()
errdefer moved.close()
try moved.extend(origin.length * w, 0.0)
for at in 0..<origin.length:
if origin[at] < 0: continue
for k in 0..<w: moved.items[at * w + k] = self.floats.items[(usize)origin[at] * w + k]
self.floats.close()
self.floats = moved
else:
var moved = Growing[i32]()
errdefer moved.close()
try moved.extend(origin.length * w, zero)
for at in 0..<origin.length:
if origin[at] < 0: continue
for k in 0..<w: moved.items[at * w + k] = self.ints.items[(usize)origin[at] * w + k]
self.ints.close()
self.ints = moved
# mark: Array attributes ============================================================
## Element `element`'s array as pool tuples: (first, count).
func run(element: usize) -> (usize, usize):
return ((usize)self.starts.items[element], (usize)self.lengths.items[element])
## Room for `count` items of element `element`: its own run when that is long
## enough, else a new one at the end of the pool. The first pool tuple.
func place(element: usize, count: usize) -> usize!:
let (first, old) = self.run(element)
if count <= old:
self.lengths.items[element] = (u32)count
self.dead += old - count
return first
let start = self.pooled()
if (start + count) * self.width > 2147483647: error(errors.limit, "an array attribute holds at most 2G values")
if self.floating(): try self.floats.extend((start + count) * self.width, 0.0)
else: try self.ints.extend((start + count) * self.width, 0)
self.starts.items[element] = (u32)start
self.lengths.items[element] = (u32)count
self.dead += old
return start
## Pack the pool when most of it is dead: every run in element order, the dead
## ones gone. Runs a script holds views of move.
func settle_pool() -> !:
if self.dead > 1024 and self.dead * 2 > self.pooled(): try self.pack()
## Every element's run in order, nothing dead.
func pack() -> !:
let w = self.width
var at: usize = 0
if self.floating():
var packed = Growing[f32]()
errdefer packed.close()
for e in 0..<self.starts.count:
let (first, count) = self.run(e)
for v in first * w..<(first + count) * w: try packed.push(self.floats.items[v])
self.starts.items[e] = (u32)at
at += count
self.floats.close()
self.floats = packed
else:
var packed = Growing[i32]()
errdefer packed.close()
for e in 0..<self.starts.count:
let (first, count) = self.run(e)
for v in first * w..<(first + count) * w: try packed.push(self.ints.items[v])
self.starts.items[e] = (u32)at
at += count
self.ints.close()
self.ints = packed
self.dead = 0
# mark: To and from attributes ======================================================
## Fill from `attribute` over `elements` (its values converted to the column's kind).
func load(attribute: const Attribute*, elements: usize) -> !:
try self.grow(elements)
if self.ragged:
var at: usize = 0
for element in 0..<elements:
let count = attribute.item_count(element)
self.starts.items[element] = (u32)at
self.lengths.items[element] = (u32)count
for item in 0..<count:
for k in 0..<self.width:
if self.floating(): try self.floats.push((f32)attribute.item(element, item, k))
else: try self.ints.push((i32)attribute.item(element, item, k))
at += count
return
for element in 0..<elements:
for k in 0..<self.width:
let at = element * self.width + k
if self.kind == DataType.text: self.ints.items[at] = try self.table.intern(attribute.text_at(element))
elif self.floating(): self.floats.items[at] = (f32)attribute.number(element, k)
else: self.ints.items[at] = (i32)attribute.number(element, k)
## The column as an attribute of `elements` elements.
func attribute(elements: usize) -> Attribute!:
try self.grow(elements)
if self.ragged: return try self.ragged_attribute(elements)
if self.kind == DataType.text:
var table = try self.table.finish()
defer table.release()
return try Attribute.text(self.label, self.domain, elements, table, self.ints.items[..<elements])
if self.kind == DataType.boolean:
var made = try Attribute.group(self.label, self.domain, elements)
if not self.group: made.flags = 0
let bits = made.data.span()
for element in 0..<elements:
if self.ints.items[element] != 0: bits[element // 8] |= (u8)1 << (u8)(element % 8)
return made
var made = try Attribute.create(self.label, self.domain, self.kind, self.width, elements)
let bytes = made.data.span()
let count = elements * self.width
if self.floating(): memory.copy(bytes, u8[]((u8*)self.floats.items.data, count * 4), count * 4)
else: memory.copy(bytes, u8[]((u8*)self.ints.items.data, count * 4), count * 4)
return made
## An array attribute: u32 offsets and the items packed in element order.
func ragged_attribute(elements: usize) -> Attribute!:
try self.pack()
let items = self.pooled()
var offsets = try Column[u8].allocate((elements + 1) * 4)
errdefer offsets.release()
let bounds = u32[]((u32*)offsets.span().data, elements + 1)
for e in 0..<elements: bounds[e] = self.starts.items[e]
bounds[elements] = (u32)items
let bytes = items * self.width * 4
var values = try Column[u8].allocate(bytes)
errdefer values.release()
if bytes > 0:
let source = (u8*)self.floats.items.data if self.floating() else (u8*)self.ints.items.data
memory.copy(values.span(), u8[](source, bytes), bytes)
return try Attribute.ragged(self.label, self.domain, self.kind, self.width, offsets.take(), values.take())
func close():
self.floats.close()
self.ints.close()
self.table.close()
self.starts.close()
self.lengths.close()
release_text(self.label)
## The edit kind a stored attribute becomes: float32 for floats, int32 for integers,
## text, and boolean for groups and booleans.
func edit_kind(kind: DataType) -> DataType:
match kind:
.float32, .float64: return DataType.float32
.text: return DataType.text
.boolean: return DataType.boolean
_: return DataType.int32
## A heap copy of `text` (empty text owns nothing).
func heap_text(text: str) -> str!:
if text.length == 0: return ""
with memory.heap:
return try strings.copy(text)
## Give back a heap_text copy.
func release_text(text: str):
if text.length == 0: return
with memory.heap:
strings.release(text)