dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / tests / mesh / dissolve_checks.lucb
## Local edit workspace must match sequential immutable dissolves exactly.
import interop
import memory
from luce_geocore.geocore import Mesh, MeshBuilder, DissolveWorkspace, Vector3, invalid, dissolve_edge
func equal(a: const Mesh*, b: const Mesh*) -> !:
assert(a.point_count() == b.point_count() and a.face_count() == b.face_count())
assert(a.vertex_count() == b.vertex_count() and a.index_count() == b.index_count() and (try a.edge_count()) == (try b.edge_count()))
for at in 0..<a.point_count(): assert((try a.point(at)) == (try b.point(at)))
for face in 0..<a.face_count():
assert((try a.face_size(face)) == (try b.face_size(face)))
assert((try a.face_normal(face)) == (try b.face_normal(face)))
for corner in 0..<(try a.face_size(face)): assert((try a.face_point(face, corner)) == (try b.face_point(face, corner)))
for at in 0..<a.index_count():
let x = a.index(at)
defer x.release()
let y = b.index(at)
defer y.release()
assert((try x.get()) == (try y.get()))
assert(a.attribute_count() == b.attribute_count())
for at in 0..<a.attribute_count():
let name = try a.attribute_name(at)
let domain = try a.attribute_domain(at)
let other = b.find_attribute(name, domain)
assert(other >= 0 and (try a.attribute_width(at)) == (try b.attribute_width(other)))
for element in 0..<(try a.domain_count(domain)):
for component in 0..<(try a.attribute_width(at)):
assert((try a.attribute_value(at, element, component)) == (try b.attribute_value(other, element, component)))
func make(bent: bool, reverse: bool) -> interop.Reference[Mesh]!:
var builder = try MeshBuilder()
defer builder.close()
for row in 0..<3:
for col in 0..<9: _ = try builder.point(Vector3((f64)col, (f64)row, (f64)(row * col) * 0.03 if bent else 0.0))
for row in 0..<2:
for col in 0..<8:
let p = row * 9 + col
let ids = [p, p + 1, p + 10, p + 9]
try builder.face(4)
for at in 0..<(usize)4: try builder.corner(ids[3 - at if reverse else at])
var mesh = try builder.finish()
errdefer mesh.release()
for domain in 0..<4:
let values = try new f64[(usize)(try mesh.value().domain_count(domain))] --- in memory.heap
defer free(values) in memory.heap
for at in 0..<values.length: values[at] = (f64)at + 0.25
let next = try mesh.value().with_attribute("id", domain, 1, values)
mesh.release()
mesh = next
let normals = try new f64[(usize)mesh.value().vertex_count() * 3] --- in memory.heap
defer free(normals) in memory.heap
for at in 0..<normals.length: normals[at] = 1.0 if at % 3 == 2 else 0.0
let shaded = try mesh.value().with_attribute("N", 1, 3, normals)
mesh.release()
mesh = shaded
return mesh
func find(mesh: const Mesh*, a: i64, b: i64) -> i64!:
for edge in 0..<(try mesh.edge_count()):
if (try mesh.edge_point(edge, 0)) == a and (try mesh.edge_point(edge, 1)) == b: return edge
return -1
pub func single(bent: bool = false, reverse: bool = false) -> !:
let source = try make(bent, reverse)
defer source.release()
var work = try DissolveWorkspace(source.value())
defer work.close()
var current = source.clone()
defer current.release()
var accepted: usize = 0
var rejected: usize = 0
for edge in 0..<(try source.value().edge_count()):
let a = try source.value().edge_point(edge, 0)
let b = try source.value().edge_point(edge, 1)
let id = try find(current.value(), a, b)
if id < 0: continue
let next: interop.Reference[Mesh]? = dissolve_edge(current.value(), id) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
recover none
if let result = next:
defer result.release()
try work.dissolve(edge)
let actual = try work.finish()
defer actual.release()
try equal(result.value(), actual.value())
current.release()
current = result.clone()
accepted += 1
else:
var refused = false
work.dissolve(edge) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
refused = true
assert(refused)
let actual = try work.finish()
defer actual.release()
try equal(current.value(), actual.value())
rejected += 1
assert(accepted >= 8 and rejected >= 4)
# Neighbor slots must be reciprocal after all joins; removed faces never
# reappear as a candidate, and boundaries never acquire a phantom neighbor.
for face in 0..<work.face_slots():
if not work.active(face): continue
for side in 0..<(try work.face_size(face)):
let other = try work.neighbor(face, side)
if other < 0: continue
assert(work.active(other))
let edge = try work.face_edge(face, side)
var reciprocal = false
for at in 0..<(try work.face_size(other)):
if (try work.face_edge(other, at)) == edge: reciprocal = (try work.neighbor(other, at)) == face
assert(reciprocal)
pub func exercise() -> !:
for bent in [false, true]:
for reverse in [false, true]: try single(bent, reverse)
try retry()
try boundaries()
## Isolate package allocation failure paths from the comparison oracle's ARC
## clone/root-buffer behavior. Scratch itself holds no managed references.
pub func allocations() -> !:
let source = try make(false, false)
defer source.release()
var work = try DissolveWorkspace(source.value())
defer work.close()
for column in 0..<8:
let edge = try find(source.value(), 9 + column, 10 + column)
assert(edge >= 0)
try work.dissolve(edge)
let result = try work.finish()
defer result.release()
assert(result.value().face_count() == 8)
struct Denied: memory.Allocator:
let upstream: memory.Allocator
pub func allocate(size: usize, alignment: usize) -> u8[]?:
return self.upstream.allocate(size, alignment) if size == 0 else none
pub func resize(block: u8[], size: usize) -> bool:
return false
pub func release(block: u8[]):
self.upstream.release(block)
func restore(previous: memory.Allocator):
memory.heap = previous
func retry() -> !:
let source = try make(true, false)
defer source.release()
var work = try DissolveWorkspace(source.value())
defer work.close()
let edge = try find(source.value(), 9, 10)
let previous = memory.heap
var denied = Denied(previous)
memory.heap = &denied
defer restore(previous)
var rejected = false
work.dissolve(edge) catch failure:
assert(failure.code == memory.exhausted)
rejected = true
memory.heap = previous
assert(rejected and work.face_slots() == source.value().face_count())
let unchanged = try work.finish()
defer unchanged.release()
try equal(source.value(), unchanged.value())
try work.dissolve(edge)
let actual = try work.finish()
defer actual.release()
let expected = try dissolve_edge(source.value(), edge)
defer expected.release()
try equal(expected.value(), actual.value())
func boundaries() -> !:
let source = try make(false, false)
defer source.release()
var work = try DissolveWorkspace(source.value(), 0)
defer work.close()
var rejected = false
work.dissolve(try find(source.value(), 9, 10)) catch failure:
if failure.code == memory.exhausted: error(failure.code, failure.message)
rejected = true
assert(rejected)
let unchanged = try work.finish()
defer unchanged.release()
try equal(source.value(), unchanged.value())
# Nonmanifold incidence and same-direction use must not become false
# neighbor pairs merely because the mutable table stores two incident slots.
let points = [Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), Vector3(0.0, -1.0, 0.0), Vector3(1.0, 1.0, 0.0)]
for nonmanifold in [false, true]:
let sizes = [3, 3, 3]
let corners = [0, 1, 2, 0, 1, 4, 1, 0, 3]
var raw = try Mesh(points, sizes[..<(3 if nonmanifold else (usize)2)], corners[..<(9 if nonmanifold else (usize)6)])
defer raw.close()
var scratch = try DissolveWorkspace(&raw)
defer scratch.close()
rejected = false
scratch.dissolve(try find(&raw, 0, 1)) catch failure:
if failure.code != invalid: error(failure.code, failure.message)
rejected = true
assert(rejected and scratch.face_slots() == raw.face_count())