Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / tests / mesh / shading_checks.lucb

## Smooth shading normals for meshes without N: hard edges past the cusp
## angle stay hard, smooth surfaces average, and a Move updates only what it
## touched to the same values a fresh mesh computes. Discrete curvature: a
## sphere of radius r has k1 = k2 = 1/r; a plane's interior is flat and its
## boundary reads zero.
from luce_std import math
import memory
from luce_geocore import geocore
from luce_geocore.geocore import Mesh, Vector3, MeshPrimitives, MeshNormals

func same(a: Vector3, b: Vector3):
    assert(a.subtract(b).length() < 0.00001)

pub func exercise() -> !:
    let cube = try Mesh.cube(2.0)
    defer cube.release()
    let c = cube.value()
    for corner in 0..<c.vertex_count():
        same(try c.corner_normal(corner), try c.face_normal(try c.corner_face(corner)))
    let sphere = try MeshPrimitives.sphere(1.0, 24)
    defer sphere.release()
    let s = sphere.value()
    # Away from the poles a smooth corner normal points out from the centre.
    for corner in 0..<s.vertex_count():
        let p = (try s.point(try s.corner_point(corner))).subtract(Vector3(0.0, 1.0, 0.0))
        if math.abs(p.y) < 0.9: assert((try s.corner_normal(corner)).dot(try p.normalized()) > 0.999)
    let moved = try s.moved_points([100, 101, 102], Vector3(0.05, 0.1, 0.0))
    defer moved.release()
    # The moved mesh updated its predecessor's normals; a new mesh computes all.
    let m = moved.value()
    let points = try new Vector3[(usize)m.point_count()] --- in memory.heap
    defer free(points) in memory.heap
    for at in 0..<points.length: points[at] = try m.point((i64)at)
    let sizes = try new i64[(usize)m.face_count()] --- in memory.heap
    defer free(sizes) in memory.heap
    for face in 0..<sizes.length: sizes[face] = try m.face_size((i64)face)
    let corners = try new i64[(usize)m.vertex_count()] --- in memory.heap
    defer free(corners) in memory.heap
    for corner in 0..<corners.length: corners[corner] = try m.corner_point((i64)corner)
    var fresh = try Mesh(points, sizes, corners)
    defer fresh.close()
    for corner in 0..<m.vertex_count():
        same(try m.corner_normal(corner), try fresh.corner_normal(corner))
    try curvature()

func curvature() -> !:
    let sphere = try MeshPrimitives.sphere(2.0, 48)
    defer sphere.release()
    let s = sphere.value()
    for point in 0..<s.point_count():
        let p = (try s.point(point)).subtract(Vector3(0.0, 2.0, 0.0))
        if math.abs(p.y) > 1.6: continue
        let k = try s.point_curvature(point)
        assert(math.abs(k.x - 0.5) < 0.03 and math.abs(k.y - 0.5) < 0.03)
    let plane = try MeshPrimitives.grid(2.0, 4)
    defer plane.release()
    for point in 0..<plane.value().point_count():
        let k = try plane.value().point_curvature(point)
        assert(math.abs(k.x) < 0.000001 and math.abs(k.y) < 0.000001)
    try refreshed()

## A Move keeps authored corner normals away from the moved points and gives
## those around them the new shape's smooth normals.
func refreshed() -> !:
    let sphere = try MeshPrimitives.sphere(1.0, 24)
    defer sphere.release()
    var groups: i64[]
    let authored = try MeshNormals.generate(sphere, groups)
    defer authored.release()
    let a = authored.value()
    let moved = try a.moved_points([100], Vector3(0.0, 0.2, 0.0))
    defer moved.release()
    let m = moved.value()
    let n = m.find_attribute("N", 1)
    assert(n >= 0)
    var kept: usize = 0
    for corner in 0..<m.vertex_count():
        let point = try m.corner_point(corner)
        let now = Vector3(try m.attribute_value(n, corner, 0), try m.attribute_value(n, corner, 1), try m.attribute_value(n, corner, 2))
        let before = try a.corner_normal(corner)
        if (try m.point(point)).subtract(try a.point(point)).length() > 0.0 or (try near_moved(m, point)):
            continue
        same(now, before)
        kept += 1
    assert(kept > 1000)
    # The moved point's corners face along the new surface, not the old.
    let face = try m.corner_face(try first_corner_of(m, 100))
    assert((try m.corner_normal(try first_corner_of(m, 100))).dot(try m.face_normal(face)) > 0.5)

func near_moved(mesh: const Mesh*, point: i64) -> bool!:
    for corner in 0..<mesh.vertex_count():
        if (try mesh.corner_point(corner)) != 100: continue
        let face = try mesh.corner_face(corner)
        for at in 0..<(try mesh.face_size(face)):
            if (try mesh.face_point(face, at)) == point: return true
    return false

func first_corner_of(mesh: const Mesh*, point: i64) -> i64!:
    for corner in 0..<mesh.vertex_count():
        if (try mesh.corner_point(corner)) == point: return corner
    error(geocore.invalid, "point has no corner")