dymokomi/luced-3d
Source of release 0.11.4
0.11.4 / tests / editor / geometry_tests.luc
from luce_geocore.geocore import Mesh, Verbs
from luce_3d.graphics import Vector3
from luce_std import math
pub func near(a: float, b: float):
if math.abs(a - b) >= 0.000001: print(f"near failed: actual={a}, expected={b}")
assert(math.abs(a - b) < 0.000001)
## The mesh verb `name` makes (group type: 0 guess, 1 points, 2 edges,
## 3 faces), and its warning.
pub func verb(name: str, mesh: Mesh, group: str, group_type: int, numbers: list[float]) -> Mesh!:
return Verbs.run(name, mesh, group, group_type, numbers).mesh()
pub func verb_warning(name: str, mesh: Mesh, group: str, group_type: int, numbers: list[float]) -> str!:
return Verbs.run(name, mesh, group, group_type, numbers).warning()
pub func manifold(mesh: Mesh) -> unit!:
let counts: list[int] = []
let directions: list[int] = []
for edge in 0..<(mesh.edge_count()):
counts.append(0)
directions.append(0)
for face in 0..<mesh.face_count():
for at in 0..<mesh.face_size(face):
let edge = mesh.face_edge(face,at)
let a = mesh.edge_point(edge,0)
let b = mesh.edge_point(edge,1)
let p = mesh.face_point(face,at)
let q = mesh.face_point(face,(at+1)%mesh.face_size(face))
assert((p == a and q == b) or (p == b and q == a))
counts[edge] += 1
directions[edge] += 1 if p == a else -1
for edge in 0..<(mesh.edge_count()): assert(counts[edge] == 2 and directions[edge] == 0)
for triangle in 0..<mesh.index_count() // 3:
let a = mesh.vertex(mesh.index(triangle * 3))
let b = mesh.vertex(mesh.index(triangle * 3 + 1))
let c = mesh.vertex(mesh.index(triangle * 3 + 2))
if b.position.subtract(a.position).cross(c.position.subtract(a.position)).dot(a.normal) <= 0.0:
print(f"invalid display triangle {triangle}: {a.position.x},{a.position.y},{a.position.z}; {b.position.x},{b.position.y},{b.position.z}; {c.position.x},{c.position.y},{c.position.z}; normal {a.normal.x},{a.normal.y},{a.normal.z}")
assert(false)
pub func geometry_tests() -> unit!:
compaction_normals()
let cube = Mesh.cube()
assert(cube.point_count() == 8 and cube.face_count() == 6 and (cube.edge_count()) == 12)
assert(cube.vertex_count() == 24 and cube.index_count() == 36)
manifold(cube)
assert(cube.ray_face(Vector3(0.0, 5.0, 0.0), Vector3(0.0, -1.0, 0.0)) == 2)
near(cube.ray_distance(Vector3(0.0, 5.0, 0.0), Vector3(0.0, -1.0, 0.0)), 3.0)
assert(cube.ray_face(Vector3(8.0, 5.0, 0.0), Vector3(0.0, -1.0, 0.0)) == -1)
let extruded = verb("PolyExtrude", cube, "2", 3, [0.5])
assert(extruded.point_count() == 12 and extruded.face_count() == 10 and (extruded.edge_count()) == 20)
near(extruded.bounds().maximum.y, 2.5)
near(cube.bounds().maximum.y, 2.0)
manifold(extruded)
let again = verb("PolyExtrude", extruded, "2", 3, [0.5])
assert(again.face_count() == 14)
near(again.bounds().maximum.y, 3.0)
manifold(again)
# Adjacent faces share six boundary edges, not eight separate walls.
let region = verb("PolyExtrude", cube, "2 4", 3, [0.5])
assert(region.face_count() == 12 and region.point_count() == 14)
manifold(region)
let transformed = cube.transformed(Vector3(4.0, 0.0, 0.0), Vector3(), Vector3(-2.0, 1.0, 1.0))
near(transformed.bounds().minimum.x, 2.0)
near(transformed.bounds().maximum.x, 6.0)
manifold(transformed)
let merged = cube.merged(transformed)
assert(merged.point_count() == 16 and merged.face_count() == 12)
manifold(merged)
let moved = cube.moved_points([2, 3, 6, 7], Vector3(0.0, 1.0, 0.0))
near(moved.bounds().maximum.y, 3.0)
near(cube.bounds().maximum.y, 2.0)
manifold(moved)
# Nothing to extrude, or a flat extrusion: the input passes with a warning.
assert(verb_warning("PolyExtrude", cube, "100", 3, [1.0]) != "")
assert(verb_warning("PolyExtrude", cube, "2", 3, [0.0]) != "")
var rejected = false
_ = cube.transformed(Vector3(), Vector3(), Vector3(0.0, 1.0, 1.0)) catch failure:
rejected = true
assert(rejected)
# A concave face must not render or pick across its notch.
let concave = Mesh([Vector3(0.0, 0.0, 0.0), Vector3(2.0, 0.0, 0.0), Vector3(2.0, 2.0, 0.0), Vector3(1.0, 0.5, 0.0), Vector3(0.0, 2.0, 0.0)], [5], [0, 1, 2, 3, 4])
assert(concave.index_count() == 9)
assert(concave.ray_face(Vector3(1.0, 1.5, 2.0), Vector3(0.0, 0.0, -1.0)) == -1)
near(concave.ray_distance(Vector3(0.2, 0.2, 2.0), Vector3(0.0, 0.0, -1.0)), 2.0)
# Collinear trim corners must survive triangulation, independent of units.
for scale in [1.0,0.00001]:
let points = [Vector3(),Vector3(scale,0.0,0.0),Vector3(scale,scale,0.0),Vector3(scale*0.5,scale,0.0),Vector3(0.0,scale,0.0)]
let polygon = Mesh(points,[5],[0,1,2,3,4])
assert(polygon.index_count() == 9 and (polygon.edge_count()) == 5)
var area = 0.0
for at in 0..<3:
let a = polygon.vertex(polygon.index(at*3)).position
let b = polygon.vertex(polygon.index(at*3+1)).position
let c = polygon.vertex(polygon.index(at*3+2)).position
let twice = b.subtract(a).cross(c.subtract(a)).z
assert(twice > 0.0)
area += twice*0.5
near(area/(scale*scale),1.0)
print("PASS polygon topology, region extrusion, winding, immutable transforms, merge and ray picking")
## Index-only compaction must not invalidate authored CAD/import shading.
func compaction_normals() -> unit!:
let source = Mesh([Vector3(9.0,9.0,9.0),Vector3(),Vector3(1.0,0.0,0.0),Vector3(1.0,1.0,0.0),Vector3(0.0,1.0,0.0),Vector3(-9.0,-9.0,-9.0)],[4],[1,2,3,4])
let values = [0.0,0.6,0.8, 0.6,0.0,0.8, 0.0,-0.6,0.8, -0.6,0.0,0.8]
let authored = source.with_attribute("N",1,3,values).with_attribute("tag",0,1,[10.0,11.0,12.0,13.0,14.0,15.0])
for compacted in [authored.compacted(),authored.compacted().compacted()]:
assert(compacted.point_count() == 4 and compacted.face_count() == 1)
let normal = compacted.find_attribute("N",1)
assert(normal >= 0)
for corner in 0..<4:
assert(compacted.vertex(corner).normal.subtract(authored.vertex(corner).normal).length() == 0.0)
for axis in 0..<3: assert(compacted.attribute_value(normal,corner,axis) == values[corner*3+axis])
assert(compacted.attribute_value(compacted.find_attribute("tag",0),corner,0) == float(11+corner))
for index in 0..<authored.index_count(): assert(compacted.index(index) == authored.index(index))
# A Move refreshes authored normals around the moved points: here the
# whole quad, whose corners now face along the moved surface.
let moved = authored.moved_points([2],Vector3(0.0,0.0,0.5))
assert(moved.find_attribute("N",1) >= 0)
for corner in 0..<4: assert(moved.vertex(corner).normal.dot(moved.face_normal(0)) > 0.99)
let two = Mesh([Vector3(),Vector3(1.0,0.0,0.0),Vector3(1.0,1.0,0.0),Vector3(0.0,1.0,0.0)],[3,3],[0,1,2,0,2,3]).with_attribute("N",1,3,[0.6,0.0,0.8,0.6,0.0,0.8,0.6,0.0,0.8,0.0,0.6,0.8,0.0,0.6,0.8,0.0,0.6,0.8])
for selected in [0,1]:
let part = two.without_faces([1-selected])
assert(part.find_attribute("N",1) >= 0)
for corner in 0..<3: assert(part.vertex(corner).normal.subtract(two.vertex(selected*3+corner).normal).length() == 0.0)
assert(verb("Reverse",two,"0",3,[]).find_attribute("N",1) < 0)