Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.1

0.7.1 / tests / 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))