Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / tests / mesh / precision_checks.lucb

## Precise meshes keep f64 points through construction, builders, derived
## meshes and position edits; ordinary meshes store f32 relative to an origin.
from luce_geocore import geocore
from luce_geocore.geocore import Vector3, Matrix4, MeshBuilder, Mesh
from verb_run import verb_mesh, no_numbers

pub func exercise() -> !:
    # A 1e-12 sliver 3 units from zero: below f32 spacing, exact in f64.
    let points = [Vector3(3.0, 3.0, 3.0), Vector3(4.0, 3.0, 3.0), Vector3(4.0, 3.0 + 1e-12, 3.0), Vector3(3.0, 3.0 + 1e-12, 3.0)]
    var builder = try MeshBuilder(precise = true)
    defer builder.close()
    for p in points: _ = try builder.point(p)
    try builder.face(4)
    for id in [0, 1, 2, 3]: try builder.corner(id)
    let mesh = try builder.finish()
    defer mesh.release()
    assert(mesh.value().is_precise())
    for at in 0..<4: assert((try mesh.value().point(at)) == points[(usize)at])
    # The f32 positions cannot hold the sliver: an ordinary mesh keeps the
    # face without an area (a zero normal).
    var ordinary = try Mesh(points, [4], [0, 1, 2, 3])
    defer ordinary.close()
    let flat = try ordinary.face_normal(0)
    assert(ordinary.face_count() == 1 and flat.x == 0.0 and flat.y == 0.0 and flat.z == 0.0)
    # Derived meshes stay precise.
    let reversed = try verb_mesh("Reverse", mesh, "0", 3, no_numbers())
    defer reversed.release()
    assert(reversed.value().is_precise() and (try reversed.value().point(2)) == points[2])
    let moved = try mesh.value().moved_points([2, 3], Vector3(0.0, 1e-12, 0.0))
    defer moved.release()
    assert((try moved.value().point(2)).y == 3.0 + 2e-12 and (try moved.value().point(0)) == points[0])
    let placed = try mesh.value().placed(Matrix4.compose(Vector3(1.0, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0)))
    defer placed.release()
    assert((try placed.value().point(3)) == Vector3(4.0, 3.0 + 1e-12, 3.0))
    let merged = try mesh.value().merged(mesh)
    defer merged.release()
    assert(merged.value().is_precise() and (try merged.value().point(6)) == points[2])
    # Publishing drops the f64 points and keeps the rest.
    let display = try mesh.value().without_precision()
    defer display.release()
    assert(not display.value().is_precise() and display.value().face_count() == 1)
    # Far from zero, an ordinary mesh keeps f32 precision relative to itself.
    let far = [Vector3(90000.0, 0.0, 0.0), Vector3(90000.001, 0.0, 0.0), Vector3(90000.0, 0.001, 0.0)]
    var nearby = try Mesh(far, [3], [0, 1, 2])
    defer nearby.close()
    assert((try nearby.point(1)).subtract(far[1]).length() < 1e-9)