Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.4

0.7.4 / tests / script / api.lucb

## The script API's geometry calls: building, editing, attributes, groups, the other
## families and whole-set operations, checked against geocore's own builders.
import strings
from luce_std import files
from luce_geocore.script import Geometry, Domain3, AttributeKind, Float3, Cook, CookRun
from luce_geocore.script_host import geocore_requirement
from luce_geocore.geocore import MeshBuilder, Vector3

## Where a test may write files (luc test gives each program a scratch HOME).
pub func scratch(name: str, buffer: u8[]) -> str!:
    let home = try files.home_directory()
    defer home.release()
    return try strings.format(buffer, f"{home.value}/{name}")

## 10k points and quads made by add_point/add_polygon match MeshBuilder's mesh.
pub func building() -> !:
    var g = try Geometry.empty()
    defer g.close()
    var builder = try MeshBuilder()
    defer builder.close()
    let side: i64 = 100
    for row in 0..<side:
        for column in 0..<side:
            let p: f32[4] = [(f32)column * 0.1, 0.0, (f32)row * 0.1, 0.0]
            assert(try g.add_point(p) == row * side + column)
            _ = try builder.point(Vector3((f64)p[0], 0.0, (f64)p[2]))
    for row in 0..<side - 1:
        for column in 0..<side - 1:
            let a = row * side + column
            let quad: i64[4] = [a, a + side, a + side + 1, a + 1]
            _ = try g.add_polygon(quad)
            try builder.face(4)
            for corner in quad: try builder.corner(corner)
    let expected = try builder.finish()
    defer expected.release()
    let mesh = try expected.get()
    assert(g.point_count() == mesh.point_count())
    assert(g.prim_count() == mesh.face_count())
    _ = try g.bounds()
    assert(g.point_count() == 10000)
    assert(g.prim_count() == 9801)
    assert(g.vertex_count() == 9801 * 4)
    assert(try g.prim_point(9800, 2) == mesh.face_point(9800, 2))
    let p = try g.position(4321)
    let q = try mesh.point(4321)
    assert(p[0] == (f32)q.x and p[2] == (f32)q.z)
    print("ok    script: 10k points and quads match MeshBuilder")

## Attributes of every kind survive assembly and a .prism round trip.
pub func attributes() -> !:
    var g = try Geometry.grid(2.0, 4)
    defer g.close()
    for point in 0..<g.point_count():
        try g.set_point_f32(point, "mass", (f32)point * 0.5)
        try g.set_i32(Domain3.point, point, "id", (i32)point * 3)
    for prim in 0..<g.prim_count():
        try g.set_vec3(Domain3.prim, prim, "Cd", [1.0, (f32)prim / 16.0, 0.25, 0.0])
        try g.set_text(Domain3.prim, prim, "name", "even" if prim % 2 == 0 else "odd")
    try g.set_f32(Domain3.vertex, 5, "weight", 2.5)
    try g.set_detail_f64("scale", 4.5)
    try g.set_detail_vec3("up", [0.0, 1.0, 0.0, 0.0])
    try g.set_detail_text("source", "a test")
    try g.add_attribute("empty", Domain3.point, AttributeKind.float32, 2)
    var buffer: u8[512]
    let path = try scratch("attributes.prism", buffer)
    try g.save(path)
    var back = try Geometry.load(path)
    defer back.close()
    assert(back.point_count() == 25 and back.prim_count() == 16)
    assert(try back.point_f32(7, "mass") == 3.5)
    assert(try back.value_i32(Domain3.point, 7, "id") == 21)
    let color = try back.value_vec3(Domain3.prim, 8, "Cd")
    assert(color[1] == 0.5 and color[2] == 0.25)
    assert(try back.value_text(Domain3.prim, 3, "name") == "odd")
    assert(try back.value_f32(Domain3.vertex, 5, "weight") == 2.5)
    assert(try back.value_f32(Domain3.vertex, 6, "weight") == 0.0)
    assert(try back.detail_f64("scale") == 4.5)
    assert((try back.detail_vec3("up"))[1] == 1.0)
    assert(try back.detail_text("source") == "a test")
    assert(back.has_attribute("empty", Domain3.point))
    assert(not back.has_attribute("missing", Domain3.point))
    # Bulk spans write in place.
    let positions = try back.positions()
    for at in 0..<positions.length: positions[at].y = 1.0
    let masses = try back.point_f32s("mass")
    masses[0] = 9.0
    let colors = try back.point_vec3s("Cd")
    colors[1] = Float3(x = 1.0, y = 0.0, z = 0.0)
    _ = try back.bounds()
    assert((try back.position(12))[1] == 1.0)
    assert(try back.point_f32(0, "mass") == 9.0)
    assert((try back.point_vec3(1, "Cd"))[0] == 1.0)
    # A span outlives a flush (a verb, bounds, a save): writes through it count.
    let held = try back.positions()
    _ = try back.bounds()
    held[0].y = 7.0
    _ = try back.bounds()
    assert((try back.bounds()).maximum.y == 7.0)
    print("ok    script: attributes of every kind round trip")

## Removing points takes their polygons; attributes follow their elements; new
## elements start at zero.
pub func reshaping() -> !:
    var g = try Geometry.grid(2.0, 2)
    defer g.close()
    for point in 0..<g.point_count(): try g.set_point_f32(point, "n", (f32)point)
    _ = try g.bounds()
    # The center point (4) is on every quad.
    let center: i64[1] = [4]
    try g.remove_points(center)
    assert(g.point_count() == 8 and g.prim_count() == 0)
    assert(try g.point_f32(4, "n") == 5.0)
    let a = try g.add_point([0.0, 1.0, 0.0, 0.0])
    let triangle: i64[3] = [0, 1, a]
    _ = try g.add_polygon(triangle)
    _ = try g.bounds()
    assert(g.point_count() == 9 and g.prim_count() == 1)
    assert(try g.point_f32(7, "n") == 8.0)
    assert(try g.point_f32(8, "n") == 0.0)
    # Removing a polygon keeps its points unless asked.
    var h = try Geometry.grid(2.0, 2)
    defer h.close()
    let first: i64[1] = [0]
    try h.remove_prims(first)
    assert(h.prim_count() == 3 and h.point_count() == 9)
    try h.remove_prims(first, remove_points = true)
    assert(h.prim_count() == 2 and h.point_count() == 7)
    print("ok    script: removals renumber and attributes follow")

## Groups are flagged attributes downstream verbs find by name.
pub func grouping() -> !:
    var g = try Geometry.grid(2.0, 4)
    defer g.close()
    for prim in 0..<g.prim_count():
        if prim < 4: try g.add_to_group(Domain3.prim, "top", prim)
    try g.add_to_group(Domain3.point, "corner", 0)
    assert(try g.in_group(Domain3.prim, "top", 2))
    assert(not try g.in_group(Domain3.prim, "top", 5))
    assert(try g.group_size(Domain3.prim, "top") == 4)
    var buffer: u8[512]
    let path = try scratch("groups.prism", buffer)
    try g.save(path)
    var back = try Geometry.load(path)
    defer back.close()
    assert(try back.group_size(Domain3.prim, "top") == 4)
    assert(try back.in_group(Domain3.point, "corner", 0))
    print("ok    script: groups")

## Curves, the point cloud, detail, instances, merge and transform.
pub func families() -> !:
    var g = try Geometry.empty()
    defer g.close()
    let line: f32[3][4] = [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]]
    assert(try g.add_polyline(line) == 0)
    let control: f32[6][4] = [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [2.0, 1.0, 0.0, 0.0], [3.0, 0.0, 0.0, 0.0], [4.0, 1.0, 0.0, 0.0], [5.0, 0.0, 0.0, 0.0]]
    assert(try g.add_curve(control, degree = 5) == 1)
    _ = try g.bounds()
    assert(g.curve_count() == 2)
    _ = try g.add_polyline(line, closed = true)
    _ = try g.bounds()
    assert(g.curve_count() == 3)
    var cloud = try Geometry.empty()
    defer cloud.close()
    for i in 0..<100:
        let point = try cloud.add_point([(f32)i, 0.0, 0.0, 0.0])
        try cloud.set_point_f32(point, "pscale", 0.5)
    try cloud.make_cloud()
    assert(cloud.cloud_count() == 100 and cloud.point_count() == 0)
    assert((try cloud.cloud_position(42))[0] == 42.0)
    assert(try cloud.cloud_value(3, "pscale") == 0.5)
    var box = try Geometry.cube(1.0)
    defer box.close()
    var scene = try Geometry.empty()
    defer scene.close()
    for i in 0..<3: try scene.add_instance(&box, [(f32)i * 2.0, 0.0, 0.0, 0.0], [0.0, 45.0, 0.0, 0.0])
    assert(scene.instance_count() == 3)
    var merged = try Geometry.grid(2.0, 2)
    defer merged.close()
    try merged.merge(&box)
    assert(merged.point_count() == 17 and merged.prim_count() == 10)
    try merged.transform([0.0, 5.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0])
    assert((try merged.bounds()).minimum.y > 4.0)
    print("ok    script: curves, clouds, instances, merge and transform")

## Inputs are read-only.
pub func locking() -> !:
    var run = try CookRun.blank(try Geometry.empty())
    defer run.close()
    let k = run.cook()
    let input = try k.input(0)
    var refused = false
    _ = input.add_point([0.0, 0.0, 0.0, 0.0]) catch failure:
        refused = true
        recover 0
    assert(refused)
    print("ok    script: inputs are read-only")

## The package's own version satisfies the requirement Script tools name: the
## same minor series, at or past its first patch. Releases bump only the version.
pub func version() -> !:
    let manifest = try files.read_text("package.prisma")
    defer manifest.release()
    let key = "str version = \""
    let at = strings.find(manifest.value, key) else trap("package.prisma names no version")
    let rest = (str)manifest.value.bytes[at + key.length..]
    let close = strings.find(rest, "\"") else trap("package.prisma's version is unclosed")
    let own = (str)rest.bytes[0..<close]
    let floor = (str)geocore_requirement.bytes[1..]
    let (own_series, own_patch) = strings.split_last(own, ".") else trap("package.prisma's version has no patch")
    let (series, first) = strings.split_last(floor, ".") else trap("the requirement has no patch")
    assert(strings.starts_with(geocore_requirement, "^") and own_series == series)
    assert((strings.parse_u64(own_patch) else 0) >= (strings.parse_u64(first) else 0))
    print("ok    script: package.prisma's version satisfies geocore_requirement")