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