dymokomi/luce-geocore
Source of release 0.7.7
0.7.7 / 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)