dymokomi/luce-geocore
Source of release 0.7.7
0.7.7 / tests / mesh / instance_checks.lucb
## Instances: prototypes once, instances as rows of one shared column. A
## share keeps the rows (the same column id) and shares each prototype; so
## do path filters; saving writes each prototype once. Row attributes (a
## `path` per row) survive shares, filters, saves, appends and joins.
from luce_geocore import geocore, kernel as geocore_kernel
import interop
from luce_std import math
import memory
from io import path
from luce_geocore.geocore import Vector3, Mesh, GeometrySet
from luce_geocore.kernel import Instances, Placement, Attribute, Domain, TableBuilder, empty_set, dispose_set, adopt_set, instances_component, new_instances, save_geometry, load_geometry
from luce_geocore.core.growing import Growing
import strings
pub func exercise() -> !:
let cube = try Mesh.cube(1.0)
defer cube.release()
let cube_set = try GeometrySet.of_mesh(cube)
defer cube_set.release()
# 10,000 instances of two prototypes, built before the set takes them
# (a set drops an empty component).
let raised = try cube_set.value().transformed(Vector3(0.0, 5.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer raised.release()
let instances = try new_instances()
fill(instances, cube_set.value(), raised.value()) catch failure:
let close = instances_component().close
close((void*)instances)
error(failure.code, failure.message)
let storage = empty_set() catch failure:
let close = instances_component().close
close((void*)instances)
error(failure.code, failure.message)
storage.put(instances_component(), (void*)instances) catch failure:
dispose_set(storage)
error(failure.code, failure.message)
let set = try adopt_set(storage)
defer set.release()
assert(instances.count() == 10000 and instances.prototype_count() == 2)
# A share: the same rows, prototypes shared anew.
let copy = try adopt_set(try set.value().storage())
defer copy.release()
let shared = (const Instances*)(copy.value().find(instances_component()) else trap("instances"))
assert(shared.rows_id() == instances.rows_id() and shared.count() == 10000 and shared.prototype_count() == 2)
assert(shared.prototype(0) != instances.prototype(0))
assert(copy.value().instance_count() == 10000 and not (try copy.value().instance_visible(3)) and (try copy.value().instance_translation(7)).x == 7.0)
assert(shared.row_text("path", 7) == "/row7" and (try copy.value().instance_path(9999)) == "/row9999")
# Filters keep the rows too; the realized mesh has every instance.
let kept = try copy.value().blasted("*", true)
defer kept.release()
let filtered = (const Instances*)(kept.value().find(instances_component()) else trap("instances"))
assert(filtered.rows_id() == instances.rows_id() and filtered.row_text("path", 42) == "/row42")
let realized = try copy.value().realized()
defer realized.release()
assert(realized.value().face_count() == 60000)
# Saved once per prototype, and loaded back row for row.
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-geocore-instances.prism".bytes: try file.push(byte)
_ = try save_geometry(set.value(), (str)file.view(), 1, 268435456)
let loaded = try adopt_set(try load_geometry((str)file.view()))
defer loaded.release()
let back = (const Instances*)(loaded.value().find(instances_component()) else trap("instances"))
assert(back.count() == 10000 and back.prototype_count() == 2)
for at in 0..<(usize)10000:
let a = instances.row(at)
let b = back.row(at)
assert(a.prototype == b.prototype and a.visible == b.visible and a.translation == b.translation)
assert(back.row_text("path", 1234) == "/row1234")
# A row added later has an empty path; a join keeps both sides' paths.
let grown = try set.value().with_instance(cube_set, Vector3(), Vector3(), Vector3(1.0, 1.0, 1.0))
defer grown.release()
assert((try grown.value().instance_path(10000)) == "" and (try grown.value().instance_path(5)) == "/row5")
let joined = try grown.value().merged(set)
defer joined.release()
assert(joined.value().instance_count() == 20001 and (try joined.value().instance_path(10006)) == "/row5")
func fill(instances: Instances*, a: const GeometrySet*, b: const GeometrySet*) -> !:
let first = try instances.add_prototype(try a.storage())
let second = try instances.add_prototype(try b.storage())
for at in 0..<(usize)10000:
let placement = Placement.compose(Vector3((f64)at, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
try instances.add_instance(first if at % 2 == 0 else second, &placement, at % 3 != 0)
# Each row's path.
var table = TableBuilder()
defer table.close()
let values = try new i32[10000] --- in memory.heap
defer free(values) in memory.heap
for at in 0..<(usize)10000:
var text: u8[32] = ---
values[at] = try table.intern(try strings.format(text, f"/row{at}"))
var column = try table.finish()
defer column.release()
try instances.put_attribute(try Attribute.text("path", Domain.point, 10000, column, values))