Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.6

0.11.6 / 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)