Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.5

0.7.5 / tests / mesh / verb_checks.lucb

## Golden checks of every verb on a 4 by 4 grid (point z*5+x, face z*4+x)
## carrying a corner uv, a face group, an integer face id and a point group:
## element counts, output selections, attribute and group propagation, and
## determinism (the same run gives the same topology and points).
import interop
from luce_std import math
import memory
from verb_run import no_numbers
from luce_geocore.geocore import Mesh, MeshPrimitives, AttributeKernels, Verbs, VerbResult, Vector3, Selection
from luce_geocore.kernel import clear_group_cache, selection_weights

pub func exercise() -> !:
    defer clear_group_cache()
    let mesh = try fixture()
    defer mesh.release()
    try point_verbs(mesh)
    try face_verbs(mesh)
    try topology_verbs(mesh)
    try edit_options(mesh)
    try registry()

func fixture() -> interop.Reference[Mesh]!:
    let grid = try MeshPrimitives.grid(2.0, 4)
    defer grid.release()
    let uv = try AttributeKernels.uv_project(grid, 1.0)
    defer uv.release()
    let top = try uv.value().with_group("top", 2, [12, 13, 14, 15])
    defer top.release()
    let pinned = try top.value().with_group("pinned", 0, [0, 4, 20, 24])
    defer pinned.release()
    var ids: f64[16]
    for face in 0..<(usize)16: ids[face] = (f64)face * 10.0
    return try pinned.value().with_attribute("id", 2, 1, ids, true)

func run(mesh: interop.Reference[Mesh], name: str, group: str, numbers: const f64[], group_type: i64 = 0) -> interop.Reference[VerbResult]!:
    return try Verbs.run(name, mesh, group, group_type, numbers)

func near(a: f64, b: f64):
    assert(math.abs(a - b) < 0.00001)

func point_verbs(mesh: interop.Reference[Mesh]) -> !:
    let lifted = try run(mesh, "Transform Components", "top", [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0])
    defer lifted.release()
    let moved = try lifted.value().mesh()
    defer moved.release()
    let points = try lifted.value().selection()
    defer points.release()
    assert(points.value().domain() == 0 and points.value().count() == 10)
    near((try moved.value().point(24)).y, 1.0)
    near((try moved.value().point(0)).y, 0.0)
    assert(moved.value().corners_id() == mesh.value().corners_id())
    # Rotation about the group's centroid keeps the centroid.
    let turned = try run(mesh, "Transform Components", "*", [0.0, 0.0, 0.0, 0.0, 90.0, 0.0, 1.0, 1.0, 1.0, 0.0])
    defer turned.release()
    let spun = try turned.value().mesh()
    defer spun.release()
    let p = try spun.value().point(22)
    near(math.sqrt(p.x * p.x + p.z * p.z), 1.0)
    near(math.abs(p.x), 1.0)
    let smooth = try run(mesh, "Smooth", "", [1.0, 2.0])
    defer smooth.release()
    let relaxed = try smooth.value().mesh()
    defer relaxed.release()
    assert(relaxed.value().point_count() == 25 and relaxed.value().topology_hash() == mesh.value().topology_hash())
    let peak = try run(mesh, "Peak", "pinned", [0.5])
    defer peak.release()
    let peaked = try peak.value().mesh()
    defer peaked.release()
    near((try peaked.value().point(0)).y, 0.5)
    let flat = try run(mesh, "Flatten", "0-4", [1.0], 1)
    defer flat.release()
    let snap = try run(mesh, "Snap", "*", [0.25])
    defer snap.release()
    let snapped = try snap.value().mesh()
    defer snapped.release()
    near((try snapped.value().point(1)).x, -0.5)
    let noise = try run(mesh, "Mountain", "", [0.2, 3.0])
    defer noise.release()

func face_verbs(mesh: interop.Reference[Mesh]) -> !:
    let deleted = try run(mesh, "Delete", "top", [0.0])
    defer deleted.release()
    let rest = try deleted.value().mesh()
    defer rest.release()
    assert(rest.value().face_count() == 12 and rest.value().point_count() == 20)
    assert(rest.value().group_size("top", 2) == 0 and rest.value().find_attribute("uv", 1) >= 0)
    near(try rest.value().attribute_value(rest.value().find_attribute("id", 2), 11), 110.0)
    # A point group deletes every face using its points (Blast).
    let blasted = try run(mesh, "Delete", "pinned", [0.0])
    defer blasted.release()
    let holes = try blasted.value().mesh()
    defer holes.release()
    assert(holes.value().face_count() == 12)
    let kept = try run(mesh, "Delete", "0-1", [1.0])
    defer kept.release()
    let two = try kept.value().mesh()
    defer two.release()
    assert(two.value().face_count() == 2 and two.value().point_count() == 6)
    let reversed = try run(mesh, "Reverse", "0", no_numbers())
    defer reversed.release()
    let flipped = try reversed.value().mesh()
    defer flipped.release()
    assert((try flipped.value().face_point(0, 1)) == (try mesh.value().face_point(0, 2)))
    near((try flipped.value().face_normal(0)).y, -(try mesh.value().face_normal(0)).y)
    let uv = flipped.value().find_attribute("uv", 1)
    near(try flipped.value().attribute_value(uv, 1, 1), try mesh.value().attribute_value(mesh.value().find_attribute("uv", 1), 2, 1))
    let triangles = try run(mesh, "Triangulate", "0-3", no_numbers())
    defer triangles.release()
    let split_faces = try triangles.value().mesh()
    defer split_faces.release()
    let made = try triangles.value().selection()
    defer made.release()
    assert(split_faces.value().face_count() == 20 and made.value().count() == 8)
    let copies = try run(mesh, "Duplicate", "0", [0.5])
    defer copies.release()
    let doubled = try copies.value().mesh()
    defer doubled.release()
    assert(doubled.value().face_count() == 17 and doubled.value().point_count() == 29)
    near((try doubled.value().point(25)).y, 0.5)
    let split = try run(mesh, "Split", "0", no_numbers())
    defer split.release()
    let apart = try split.value().mesh()
    defer apart.release()
    assert(apart.value().face_count() == 16 and apart.value().point_count() == 29)
    let fused = try run(apart, "Fuse", "*", [0.001])
    defer fused.release()
    let together = try fused.value().mesh()
    defer together.release()
    assert(together.value().point_count() == 25 and together.value().face_count() == 16)
    let inset = try run(mesh, "Inset", "5", [0.1])
    defer inset.release()
    let inner = try inset.value().mesh()
    defer inner.release()
    let front = try inset.value().selection()
    defer front.release()
    assert(inner.value().face_count() == 20 and inner.value().point_count() == 29 and front.value().count() == 1 and front.value().contains(5))

func topology_verbs(mesh: interop.Reference[Mesh]) -> !:
    let extruded = try run(mesh, "PolyExtrude", "5", [1.0])
    defer extruded.release()
    let solid = try extruded.value().mesh()
    defer solid.release()
    let front = try extruded.value().selection()
    defer front.release()
    assert(solid.value().face_count() == 20 and solid.value().point_count() == 29)
    assert(front.value().count() == 1 and front.value().contains(5))
    near((try solid.value().face_center(5)).y, 1.0)
    let id = solid.value().find_attribute("id", 2)
    near(try solid.value().attribute_value(id, 16), 50.0)
    # Deterministic: the same run gives the same topology and positions.
    let again = try run(mesh, "PolyExtrude", "5", [1.0])
    defer again.release()
    let twin = try again.value().mesh()
    defer twin.release()
    assert(twin.value().topology_hash() == solid.value().topology_hash())
    for point in 0..<twin.value().point_count():
        let a = try twin.value().point(point)
        let b = try solid.value().point(point)
        assert(a.x == b.x and a.y == b.y and a.z == b.z)
    let subdivided = try run(mesh, "Subdivide", "", [1.0, 0.0])
    defer subdivided.release()
    let fine = try subdivided.value().mesh()
    defer fine.release()
    assert(fine.value().face_count() == 64 and fine.value().point_count() == 81)
    # New corners interpolate the uv of the corners they lie between.
    let uv = fine.value().find_attribute("uv", 1)
    let center = try fine.value().face_offset(0)
    near(try fine.value().attribute_value(uv, center + 2, 0), (try mesh.value().face_center(0)).x)
    assert(fine.value().group_size("top", 2) == 16 and fine.value().group_size("pinned", 0) == 4)
    let smooth = try run(mesh, "Subdivide", "", [2.0, 1.0])
    defer smooth.release()
    let smoother = try smooth.value().mesh()
    defer smoother.release()
    assert(smoother.value().face_count() == 256)
    let cube = try Mesh.cube()
    defer cube.release()
    let rounded = try run(cube, "Subdivide", "", [1.0, 1.0])
    defer rounded.release()
    let catmull = try rounded.value().mesh()
    defer catmull.release()
    near((try catmull.value().point(0)).x, -5.0 / 9.0)
    near((try catmull.value().point(0)).y, 4.0 / 9.0)
    let chamfer = try run(cube, "PolyBevel", "", [0.2, 1.0, 0.5, 1.0])
    defer chamfer.release()
    let chamfered = try chamfer.value().mesh()
    defer chamfered.release()
    assert(chamfered.value().face_count() == 26)
    # A hole, filled back, and an edge dissolved.
    let holed = try run(mesh, "Delete", "5", [0.0])
    defer holed.release()
    let hole = try holed.value().mesh()
    defer hole.release()
    let filled = try run(hole, "Fill", "p6-11-12-7-6", [0.0], 2)
    defer filled.release()
    let capped = try filled.value().mesh()
    defer capped.release()
    assert(capped.value().face_count() == 16)
    let dissolved = try run(mesh, "Dissolve", "p1-6", no_numbers(), 2)
    defer dissolved.release()
    let joined = try dissolved.value().mesh()
    defer joined.release()
    assert(joined.value().face_count() == 15)
    let block = try run(mesh, "Dissolve", "p1-6 p5-6 p6-7 p6-11", no_numbers(), 2)
    defer block.release()
    let quad = try block.value().mesh()
    defer quad.release()
    let joined_face = try block.value().selection()
    defer joined_face.release()
    assert(quad.value().face_count() == 13 and joined_face.value().count() == 1 and (try quad.value().face_size(0)) == 8)
    # Nothing sensible to do passes the input through with a warning.
    let closed = try run(cube, "Fill", "", [0.0])
    defer closed.release()
    let unfilled = try closed.value().mesh()
    defer unfilled.release()
    assert(unfilled.value().face_count() == 6 and closed.value().warning() != "")
    let everything = try run(cube, "Dissolve", "", no_numbers())
    defer everything.release()
    let whole = try everything.value().mesh()
    defer whole.release()
    assert(whole.value().face_count() == 6 and everything.value().warning() != "")
    let flat = try run(cube, "Flatten", "", [1.0])
    defer flat.release()
    let unflattened = try flat.value().mesh()
    defer unflattened.release()
    assert(unflattened.value().points_id() == cube.value().points_id() and flat.value().warning() != "")
    let cleaned = try run(mesh, "Clean", "", no_numbers())
    defer cleaned.release()
    let same = try cleaned.value().mesh()
    defer same.release()
    assert(same.value().point_count() == 25)

## The Edit engine's options: symmetry, soft falloff, and a kept selection.
func edit_options(mesh: interop.Reference[Mesh]) -> !:
    let up: f64[15] = [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
    let mirrored = try Verbs.run("Transform Components", mesh, "0", 1, up, 1)
    defer mirrored.release()
    let both = try mirrored.value().mesh()
    defer both.release()
    near((try both.value().point(0)).y, 1.0)
    near((try both.value().point(4)).y, 1.0)
    near((try both.value().point(2)).y, 0.0)
    let points = try mirrored.value().selection()
    defer points.release()
    assert(points.value().count() == 2)
    var soft: f64[15] = up
    soft[13] = 0.6
    let falloff = try Verbs.run("Transform Components", mesh, "12", 1, soft)
    defer falloff.release()
    let smooth = try falloff.value().mesh()
    defer smooth.release()
    near((try smooth.value().point(12)).y, 1.0)
    # Linear falloff (Falloff 0): the weight at 0.5 of a 0.6 radius.
    near((try smooth.value().point(7)).y, 1.0 - 0.5 / 0.6)
    near((try smooth.value().point(0)).y, 0.0)
    try tint_weights(mesh)
    let kept = try Verbs.run("PolyExtrude", mesh, "5", 3, [1.0], 0, true)
    defer kept.release()
    let carried = try kept.value().selection()
    defer carried.release()
    assert(carried.value().domain() == 2 and carried.value().count() == 5 and carried.value().contains(5))
    let result = try kept.value().mesh()
    defer result.release()
    assert(result.value().find_attribute(".carried", 2) < 0)

## The viewport's soft tint: face 5's points (6 7 11 12) weigh 1; point 13,
## 0.5 beyond point 12, weighs 1 - 0.5 / 0.6 (linear); the corner is out of
## reach. Symmetry across X adds the mirrored points (8 and 13 weigh 1).
func tint_weights(mesh: interop.Reference[Mesh]) -> !:
    let face = try Selection.of(mesh, "5", 2)
    defer face.release()
    let weights = try new f32[25] --- in memory.heap
    defer free(weights) in memory.heap
    try selection_weights(try mesh.get(), try face.get(), 0.6, 0, 0, weights)
    near((f64)weights[12], 1.0)
    near((f64)weights[6], 1.0)
    assert(math.abs((f64)weights[13] - (1.0 - 0.5 / 0.6)) < 0.0001)
    near((f64)weights[0], 0.0)
    try selection_weights(try mesh.get(), try face.get(), 0.6, 0, 1, weights)
    near((f64)weights[8], 1.0)
    near((f64)weights[13], 1.0)

func registry() -> !:
    assert(Verbs.count() >= 19 and Verbs.index_of("PolyExtrude") >= 0 and Verbs.index_of("nothing") == -1)
    let transform = Verbs.index_of("Transform Components")
    assert(Verbs.parm_count(transform) == 7 and Verbs.parm_components(transform, 0) == 3 and Verbs.parm_kind(transform, 3) == 4)
    assert(Verbs.domain(Verbs.index_of("Fill")) == 4 and not Verbs.changes_topology(transform))