Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.5

0.9.5 / tests / mesh_pixels / main.lucb

## Offscreen pixels of the polygon-mesh path (GPU arrays, shader lighting)
## and the ground grid (hidden behind meshes, fading with distance), and
## wires over faces seen square on orthographically:
## it matches the per-vertex path in lit and flat modes, uploads only the
## positions after a Move, and its zebra stripes scale with their count, break
## at a crease (separate normals per face) and flow across a smooth seam.
from luce_gpu import gpu
import interop
import os
from luce_std import math
import memory
from luce_3d import graphics as three
from luce_geocore import geocore
from luce_geocore.geocore import MeshNormals, MeshPrimitives, AttributeKernels, Vector3, Verbs, Subdivision
from luce_3d.graphics import Scene, Mesh, Geometry, Material, Object3D, MeshLambertMaterial, AmbientLight, DirectionalLight, Camera, Renderer, Color, WireRenderer, MeshGeometry, GroundGrid

let width: u32 = 160
let height: u32 = 120

struct View:
    var device: gpu.Device
    var texture: gpu.Texture
    let scene: interop.Reference[Scene]
    let root: interop.Interface[Object3D]
    let camera: interop.Reference[Camera]
    let renderer: interop.Reference[Renderer]
    var shown: interop.Reference[Mesh]?
    var shown_object: interop.Interface[Object3D]?

    func init(device: gpu.Device) -> !:
        var texture = try gpu.Texture.create(device, width, height, gpu.Format.rgba8_linear)
        errdefer texture.destroy()
        let scene = try interop.Reference[Scene].adopt(new Scene() in memory.heap, three.scene_type, memory.heap)
        let ambient = try interop.Reference[AmbientLight].adopt(new AmbientLight(intensity = 0.25) in memory.heap, three.ambient_type, memory.heap)
        defer ambient.release()
        let ambient_object = ambient.as_interface[Object3D](ambient.value())
        defer ambient_object.release()
        try scene.value().add(ambient_object)
        let sun = try interop.Reference[DirectionalLight].adopt(new DirectionalLight(intensity = 0.8, direction = Vector3(3.0, 5.0, 2.0)) in memory.heap, three.directional_type, memory.heap)
        defer sun.release()
        let sun_object = sun.as_interface[Object3D](sun.value())
        defer sun_object.release()
        try scene.value().add(sun_object)
        let camera = try interop.Reference[Camera].adopt(new Camera(40.0, 1.0, 0.1, 100.0) in memory.heap, three.camera_type, memory.heap)
        try camera.value().set_position(Vector3(2.0, 3.0, 4.0))
        try camera.value().look_at(Vector3(0.0, 0.5, 0.0))
        self.device = try device.share()
        self.texture = texture
        self.scene = scene
        self.root = scene.as_interface[Object3D](scene.value())
        self.camera = camera
        self.renderer = try interop.Reference[Renderer].adopt(new Renderer(true) in memory.heap, three.renderer_type, memory.heap)
        self.shown = none
        self.shown_object = none

    ## Show `mesh` through the per-vertex interface (`legacy`) or its GPU arrays.
    func show(mesh: interop.Reference[geocore.Mesh], legacy: bool) -> !:
        self.hide()
        let material = try interop.Reference[MeshLambertMaterial].adopt(new MeshLambertMaterial(gpu.Color(0.8, 0.7, 0.6)) in memory.heap, three.lambert_material_type, memory.heap)
        defer material.release()
        let appearance = material.as_interface[Material](material.value())
        defer appearance.release()
        var object: interop.Reference[Mesh]? = none
        if legacy:
            let wrapped = try interop.Reference[MeshGeometry].adopt(new MeshGeometry(mesh) in memory.heap, three.mesh_geometry_type, memory.heap)
            defer wrapped.release()
            let geometry = wrapped.as_interface[Geometry](wrapped.value())
            defer geometry.release()
            object = try interop.Reference[Mesh].adopt(new Mesh(geometry, appearance) in memory.heap, three.mesh_type, memory.heap)
        else:
            object = try Mesh.of(mesh, appearance)
        let made = object else trap("no object")
        let node = made.as_interface[Object3D](made.value())
        try self.scene.value().add(node)
        self.shown = made
        self.shown_object = node

    func hide():
        if let node = self.shown_object:
            _ = self.scene.value().remove(node) catch failure: recover false
            node.release()
        if let object = self.shown: object.release()
        self.shown = none
        self.shown_object = none

    func draw(image: u8[]) -> !:
        var none_lines: Vector3[]
        try self.draw_lines(image, none_lines)

    ## Draw the scene, then depth-tested `lines` in red, as the viewport draws
    ## its grid after the meshes.
    func draw_lines(image: u8[], lines: const Vector3[]) -> !:
        let recording = try self.texture.frame()
        defer recording.release()
        let target = try recording.value().target()
        defer target.release()
        let result = self.renderer.value().render(self.root, self.camera, target, true)
        defer result.release()
        try result.get()
        if lines.length > 0: try WireRenderer.lines(lines, self.camera, target, gpu.Color(1.0, 0.0, 0.0), 2.0, 0.0)
        _ = try recording.value().present(gpu.Color(0.0, 0.0, 0.0))
        try self.texture.read(image)

    ## Draw the scene, then the ground grid in red (its axes green) on y = 0,
    ## faded out `fade` from the eye.
    func draw_grid(image: u8[], fade: f64) -> !:
        let recording = try self.texture.frame()
        defer recording.release()
        let target = try recording.value().target()
        defer target.release()
        let result = self.renderer.value().render(self.root, self.camera, target, true)
        defer result.release()
        try result.get()
        try GroundGrid.draw(self.camera, target, 0.0, 0.25, gpu.Color(1.0, 0.0, 0.0), gpu.Color(1.0, 0.0, 0.0), gpu.Color(0.0, 1.0, 0.0), fade)
        _ = try recording.value().present(gpu.Color(0.0, 0.0, 0.0))
        try self.texture.read(image)

    func close():
        self.hide()
        self.renderer.release()
        self.camera.release()
        self.root.release()
        self.scene.release()
        self.texture.destroy()
        self.device.destroy()

func luminance(image: const u8[], x: u32, y: u32) -> i64:
    let at = (usize)((y * width + x) * 4)
    return ((i64)image[at] + (i64)image[at + 1] + (i64)image[at + 2]) // 3

## The GPU-array path draws what the per-vertex path draws, lit and flat,
## within `tolerance` per channel: it lights per fragment, the per-vertex path
## per vertex, which differ across curved faces.
func equivalence(view: View*, mesh: interop.Reference[geocore.Mesh], flat: bool, legacy_image: u8[], image: u8[], tolerance: i64 = 3) -> !:
    view.renderer.value().set_flat(flat)
    try view.show(mesh, true)
    try view.draw(legacy_image)
    try view.show(mesh, false)
    try view.draw(image)
    var covered: usize = 0
    var differing: usize = 0
    for at in 0..<(usize)(width * height):
        let a = legacy_image[at * 4..<at * 4 + 3]
        let b = image[at * 4..<at * 4 + 3]
        if a[0] != 0 or a[1] != 0 or a[2] != 0: covered += 1
        for channel in 0..<(usize)3:
            let difference = (i64)a[channel] - (i64)b[channel]
            if difference > tolerance or difference < -tolerance:
                differing += 1
                break
    assert(covered > 1000)
    assert(differing * 200 < covered)
    view.renderer.value().set_flat(false)

## GPU picking finds the face a ray through the pixel finds, and nothing off
## the mesh; a second pick over the same view reuses the id image.
func picking(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[]) -> !:
    let eye = Vector3(2.0, 3.0, 4.0)
    let aim = Vector3(0.0, 0.75, 0.0)
    try view.camera.value().set_position(eye)
    try view.camera.value().look_at(aim)
    try view.show(cube, false)
    try view.draw(image)
    let renderer = view.renderer.value()
    let face = try renderer.pick_face(cube, view.camera, (f64)width * 0.5, (f64)height * 0.5, (f64)width, (f64)height)
    assert(face >= 0 and face == (try cube.value().ray_face(eye, try aim.subtract(eye).normalized())))
    assert((try renderer.pick_face(cube, view.camera, 1.0, 1.0, (f64)width, (f64)height)) == -1)
    assert((try renderer.pick_face(cube, view.camera, (f64)width * 0.5, (f64)height * 0.5, (f64)width, (f64)height)) == face)
    # A box over the whole view selects from the same id image what shows:
    # 3 faces, 9 edges and 7 corners of the cube, and through the depth all.
    let shown: i64[3] = [3, 9, 7]
    let every: i64[3] = [6, 12, 8]
    let domains: i64[3] = [2, 4, 0]
    for at in 0..<(usize)3:
        let empty = try geocore.Selection.empty(cube, domains[at])
        defer empty.release()
        let seen = try renderer.select_box(cube, view.camera, empty, 0.0, 0.0, (f64)width, (f64)height, (f64)width, (f64)height, 0)
        defer seen.release()
        assert(seen.value().count() == shown[at])
        let through = try renderer.select_box(cube, view.camera, empty, 0.0, 0.0, (f64)width, (f64)height, (f64)width, (f64)height, 0, false)
        defer through.release()
        assert(through.value().count() == every[at])
    # The picked face, selected: the renderer tints it from one bit per face.
    let at = (usize)((height // 2 * width + width // 2) * 4)
    try renderer.set_face_selection(cube, [face], Color(1.0, 0.0, 0.0), 1.0)
    try view.draw(image)
    assert(image[at] > 200 and image[at + 1] < 40 and image[at + 2] < 40)
    var none_faces: i64[]
    try renderer.set_face_selection(cube, none_faces)
    try view.draw(image)
    assert(image[at + 1] > 60)
    try view.camera.value().set_position(Vector3(0.0, 1.0, 5.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))

## An inside-out mesh (every face reversed) lights like the outward one: the
## side facing the eye is shaded.
func two_sided(view: View*, cube: interop.Reference[geocore.Mesh], outward: u8[], image: u8[]) -> !:
    try view.show(cube, false)
    try view.draw(outward)
    var nothing: f64[]
    let reversing = try Verbs.run("Reverse", cube, "", 0, nothing)
    defer reversing.release()
    let reversed = try reversing.value().mesh()
    defer reversed.release()
    try view.show(reversed, false)
    try view.draw(image)
    var covered: usize = 0
    var differing: usize = 0
    for at in 0..<(usize)(width * height):
        if outward[at * 4] != 0: covered += 1
        let difference = (i64)outward[at * 4] - (i64)image[at * 4]
        if difference > 3 or difference < -3: differing += 1
    assert(covered > 1000 and differing * 200 < covered)

## Lines drawn after the meshes (the viewport's grid) are hidden behind them.
func occlusion(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[]) -> !:
    var lines: Vector3[6] = ---
    for at in 0..<(usize)3:
        let y = 0.5 + (f64)at * 0.25
        lines[at * 2] = Vector3(-3.0, y, -2.0)
        lines[at * 2 + 1] = Vector3(3.0, y, -2.0)
    view.hide()
    try view.draw_lines(image, lines)
    let alone = red_pixels(image)
    try view.show(cube, false)
    try view.draw_lines(image, lines)
    let behind = red_pixels(image)
    assert(alone > 100 and behind * 4 < alone * 3)

## The ground grid: lines below the horizon only, its axes in their own color,
## hidden behind a mesh in front (depth tested, after the meshes), and fading
## with distance: faded out sooner, the far half of the view shows less of it.
func ground_grid(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[]) -> !:
    try view.camera.value().set_position(Vector3(2.0, 3.0, 4.0))
    try view.camera.value().look_at(Vector3(0.0, 0.5, 0.0))
    view.hide()
    try view.draw_grid(image, 30.0)
    let alone = grid_pixels(image)
    var green: usize = 0
    for at in 0..<(usize)(width * height):
        if image[at * 4 + 1] > 100 and image[at * 4] < 60: green += 1
    let far = upper_red(image)
    try view.draw_grid(image, 6.0)
    let faded = upper_red(image)
    try view.show(cube, false)
    try view.draw_grid(image, 30.0)
    let behind = grid_pixels(image)
    if not (alone > 300 and green > 20 and behind * 10 < alone * 9 and far > 0 and faded * 2 < far):
        print(f"ground grid: {alone} red pixels, {green} green, {behind} behind a cube, the far half's red {far}, faded sooner {faded}")
        assert(false)

## The ground grid behind a cube that stands above the ground, seen from
## above in perspective with the editor's clip planes (near a hundredth of
## the distance, far twenty times it): the grid lies wholly behind the cube,
## so not one of the cube's pixels changes when the grid is drawn.
func grid_behind_raised(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[], alone: u8[]) -> !:
    # The cube stands on the ground; raised, its underside is 1.5 above it.
    let raised = try cube.value().transformed(Vector3(0.0, 1.5, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
    defer raised.release()
    let camera = view.camera.value()
    let target = Vector3(0.0, 2.25, 0.0)
    let eye = Vector3(2.0, 4.0, 4.0)
    let distance = eye.subtract(target).length()
    try camera.set_projection(40.0, distance * 0.01, math.max(500.0, distance * 20.0))
    try camera.set_position(eye)
    try camera.look_at(target)
    try view.show(raised, false)
    try view.draw(alone)
    try view.draw_grid(image, distance * 18.0)
    var covered: usize = 0
    var changed: usize = 0
    for at in 0..<(usize)(width * height):
        let lit = alone[at * 4] > 20 or alone[at * 4 + 1] > 20
        if not lit: continue
        covered += 1
        if image[at * 4] != alone[at * 4] or image[at * 4 + 1] != alone[at * 4 + 1] or image[at * 4 + 2] != alone[at * 4 + 2]: changed += 1
    try camera.set_projection(40.0, 0.1, 100.0)
    if not (covered > 500 and changed == 0):
        print(f"grid behind a raised cube: {changed} of its {covered} pixels changed")
        assert(false)

## Wires on faces seen square on through an orthographic camera, its eye far
## back and its depth range long, as the editor's orthographic views stand:
## the faces' depth slope is zero, so only the lines' own depth bias (the
## same share of the depth range as in perspective) lifts them over the
## face, and it does: the cube's edges (green) and a line drawn across its
## front face (red) show whole.
func square_on_wires(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[]) -> !:
    let camera = view.camera.value()
    let half = 1.2
    let reach = half * 400.0
    try camera.set_projection(40.0, reach * 0.0001, reach * 2.0)
    try camera.set_orthographic(half)
    try camera.set_position(Vector3(0.0, 0.75, reach))
    try camera.look_at(Vector3(0.0, 0.75, 0.0))
    try view.show(cube, false)
    let renderer = view.renderer.value()
    try renderer.set_edges(1.0, Color(0.0, 1.0, 0.0))
    try renderer.set_wire_overlay(1.0)
    let recording = try view.texture.frame()
    let drawn = try recording.value().target()
    let result = renderer.render(view.root, view.camera, drawn, true)
    try result.get()
    result.release()
    let across: Vector3[2] = [Vector3(-0.6, 0.75, 0.75), Vector3(0.6, 0.75, 0.75)]
    try WireRenderer.lines(across, view.camera, drawn, gpu.Color(1.0, 0.0, 0.0), 2.0)
    drawn.release()
    _ = try recording.value().present(gpu.Color(0.0, 0.0, 0.0))
    recording.release()
    try view.texture.read(image)
    try renderer.set_edges(0.0, Color(0.0, 0.0, 0.0))
    try renderer.set_wire_overlay(0.0)
    try camera.set_orthographic(0.0)
    try camera.set_projection(40.0, 0.1, 100.0)
    try camera.set_position(Vector3(2.0, 3.0, 4.0))
    try camera.look_at(Vector3(0.0, 0.5, 0.0))
    # The front face (the cube stands on the ground) spans rows 23 to 97
    # and columns 43 to 117 (the view is 2.4 tall).
    var green: usize = 0
    var red: usize = 0
    for at in 0..<(usize)(width * height):
        let r = image[at * 4]
        let g = image[at * 4 + 1]
        if g > 200 and r < 60: green += 1
        if r > 200 and g < 60: red += 1
    if not (green > 250 and red > 100):
        print(f"square-on wires: {green} edge pixels, {red} line pixels")
        assert(false)

## The red of the image's upper half, where the plane is farthest.
func upper_red(image: const u8[]) -> i64:
    var sum: i64 = 0
    for at in 0..<(usize)(width * height // 2): sum += (i64)image[at * 4]
    return sum

## Pixels a red line covers at least in part.
func grid_pixels(image: const u8[]) -> usize:
    var count: usize = 0
    for at in 0..<(usize)(width * height):
        if image[at * 4] > 50 and (i64)image[at * 4 + 1] * 2 < (i64)image[at * 4]: count += 1
    return count

## A subdivided cube draws its limit surface: rounder, so it covers fewer
## pixels than the cage, and the same pixels as its display mesh drawn
## directly.
func subdivided(view: View*, cube: interop.Reference[geocore.Mesh], image: u8[], direct: u8[]) -> !:
    try view.show(cube, false)
    try view.draw(direct)
    var cage_covered: usize = 0
    for at in 0..<(usize)(width * height):
        if direct[at * 4] != 0: cage_covered += 1
    let marking = try Verbs.run("Subdivision", cube, "", 0, [1.0, 2.0, 3.0, 1.0])
    defer marking.release()
    let marked = try marking.value().mesh()
    defer marked.release()
    try view.show(marked, false)
    try view.draw(image)
    var covered: usize = 0
    for at in 0..<(usize)(width * height):
        if image[at * 4] != 0: covered += 1
    assert(covered > 1000 and covered * 20 < cage_covered * 19)
    # Picking hits what is shown: a pixel inside the cage's silhouette but
    # off the smooth surface misses; one on it names a cage face, which the
    # selection tint then covers.
    let renderer = view.renderer.value()
    var outside: i64 = -1
    for at in 0..<(usize)(width * height):
        if direct[at * 4] != 0 and image[at * 4] == 0:
            outside = (i64)at
            break
    assert(outside >= 0)
    let ox = (f64)(outside % (i64)width) + 0.5
    let oy = (f64)(outside // (i64)width) + 0.5
    assert((try renderer.pick_face(marked, view.camera, ox, oy, (f64)width, (f64)height)) == -1)
    assert((try renderer.pick_face(cube, view.camera, ox, oy, (f64)width, (f64)height)) >= 0)
    let face = try renderer.pick_face(marked, view.camera, (f64)width * 0.5, (f64)height * 0.5, (f64)width, (f64)height)
    assert(face >= 0 and face < 6)
    let center = (usize)((height // 2 * width + width // 2) * 4)
    try renderer.set_face_selection(marked, [face], Color(1.0, 0.0, 0.0), 1.0)
    try view.draw(direct)
    assert(direct[center] > 200 and direct[center + 1] < 40)
    var nothing: i64[]
    try renderer.set_face_selection(marked, nothing)
    try view.draw(image)
    let display = try Subdivision.display(marked)
    defer display.release()
    try view.show(display, false)
    try view.draw(direct)
    var differing: usize = 0
    for at in 0..<(usize)(width * height):
        let difference = (i64)image[at * 4] - (i64)direct[at * 4]
        if difference > 3 or difference < -3: differing += 1
    assert(differing * 200 < covered)

func red_pixels(image: const u8[]) -> usize:
    var count: usize = 0
    for at in 0..<(usize)(width * height):
        if image[at * 4] > 200 and image[at * 4 + 1] < 60 and image[at * 4 + 2] < 60: count += 1
    return count

## Dark-to-light and light-to-dark changes along row `y` between x0 and x1.
func transitions(image: const u8[], y: u32, x0: u32, x1: u32) -> usize:
    var count: usize = 0
    var previous = luminance(image, x0, y) > 127
    for x in x0 + 1..<x1:
        let light = luminance(image, x, y) > 127
        if light != previous: count += 1
        previous = light
    return count

## Rows where the image steps between columns `seam` - 1 and `seam` + 1 while
## each side is flat: a break at the seam, not a stripe edge crossing it.
func seam_breaks(image: const u8[], seam: u32, y0: u32, y1: u32) -> usize:
    var breaks: usize = 0
    for y in y0..<y1:
        let far_left = luminance(image, seam - 3, y)
        let left = luminance(image, seam - 1, y)
        let right = luminance(image, seam + 1, y)
        let far_right = luminance(image, seam + 3, y)
        let step = left - right > 100 or right - left > 100
        if step and far_left - left < 40 and left - far_left < 40 and right - far_right < 40 and far_right - right < 40: breaks += 1
    return breaks

## A roof: two quads meeting at a ridge along z at x = 0.
func roof() -> interop.Reference[geocore.Mesh]!:
    let points: Vector3[6] = [Vector3(-1.0, 0.0, -1.0), Vector3(0.0, 0.35, -1.0), Vector3(0.0, 0.35, 1.0), Vector3(-1.0, 0.0, 1.0), Vector3(1.0, 0.0, -1.0), Vector3(1.0, 0.0, 1.0)]
    let sizes: i64[2] = [4, 4]
    let corners: i64[8] = [0, 3, 2, 1, 1, 2, 5, 4]
    return try interop.Reference[geocore.Mesh].adopt(new geocore.Mesh(points, sizes, corners) in memory.heap, geocore.mesh_type, memory.heap)

func zebra(view: View*, image: u8[]) -> !:
    # A cylinder with smooth normals, seen from the side: twice the stripes,
    # twice the bands.
    try view.camera.value().set_position(Vector3(0.0, 1.0, 6.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))
    let cylinder = try MeshPrimitives.cylinder(1.0, 2.0, 64)
    defer cylinder.release()
    let smooth = try AttributeKernels.normals(cylinder, 0)
    defer smooth.release()
    try view.show(smooth, false)
    try view.renderer.value().set_shading(2, 6.0, 0.5, Vector3(0.0, 1.0, 0.0))
    try view.draw(image)
    let few = transitions(image, height // 2, 45, 115)
    try view.renderer.value().set_shading(2, 12.0, 0.5, Vector3(0.0, 1.0, 0.0))
    try view.draw(image)
    let many = transitions(image, height // 2, 45, 115)
    assert(few >= 3 and many >= few * 3 // 2 and many <= few * 3)
    # A crease (a normal per face) breaks the stripes at the ridge; point
    # normals shared across it keep them flowing. (Without N the 39-degree
    # ridge is within the cusp angle, so it would shade smooth.)
    try view.camera.value().set_position(Vector3(0.0, 3.0, 0.3))
    try view.camera.value().look_at(Vector3(0.0, 0.0, 0.0))
    try view.renderer.value().set_shading(2, 24.0, 0.5, Vector3(1.0, 0.0, 1.0), planar = true)
    let ridge = try roof()
    defer ridge.release()
    let creased = try AttributeKernels.normals(ridge, 2)
    defer creased.release()
    try view.show(creased, false)
    try view.draw(image)
    let broken = seam_breaks(image, width // 2, height // 2 - 40, height // 2 + 40)
    let blended = try AttributeKernels.normals(ridge, 0)
    defer blended.release()
    try view.show(blended, false)
    try view.draw(image)
    let flowing = seam_breaks(image, width // 2, height // 2 - 40, height // 2 + 40)
    assert(broken >= 10 and flowing * 4 <= broken)
    # A sphere: stripes change smoothly, with no one-pixel hard jumps.
    try view.camera.value().set_position(Vector3(0.0, 1.0, 5.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))
    let sphere = try MeshPrimitives.sphere(1.0, 48)
    defer sphere.release()
    let round = try AttributeKernels.normals(sphere, 0)
    defer round.release()
    try view.show(round, false)
    try view.renderer.value().set_shading(2, 12.0, 0.5, Vector3(0.0, 1.0, 0.0))
    try view.draw(image)
    var jumps: usize = 0
    var inside: usize = 0
    var dark = false
    var light = false
    for y in 30..<(u32)90:
        for x in 50..<(u32)110:
            let a = luminance(image, x, y)
            dark = dark or a < 40
            light = light or a > 215
            inside += 1
            let b = luminance(image, x + 1, y)
            if a - b > 200 or b - a > 200: jumps += 1
    assert(dark and light and jumps * 50 < inside)
    try view.renderer.value().set_shading(0)

## The curvature map: a sphere bends one way everywhere (red at the automatic
## range); a flat grid reads zero (green); a fixed range ten times its
## curvature fades the sphere towards green.
func curvature_map(view: View*, image: u8[]) -> !:
    try view.camera.value().set_position(Vector3(0.0, 1.0, 5.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))
    let sphere = try MeshPrimitives.sphere(1.0, 48)
    defer sphere.release()
    try view.show(sphere, false)
    try view.renderer.value().set_shading(6)
    try view.renderer.value().set_curvature(0)
    try view.draw(image)
    let at = (usize)((height // 2 * width + width // 2) * 4)
    assert(image[at] > 150 and image[at + 1] < 100)
    try view.renderer.value().set_curvature(0, 10.0)
    try view.draw(image)
    assert(image[at + 1] > image[at])
    # The radius band: a unit sphere is tighter than 2 (magenta), flatter
    # than 0.5 (grey).
    try view.renderer.value().set_curvature(0, 0.0, 2.0, 0.0)
    try view.draw(image)
    assert(image[at] > 150 and image[at + 1] < 120 and image[at + 2] > 150)
    try view.renderer.value().set_curvature(0, 0.0, 0.0, 0.5)
    try view.draw(image)
    assert(math.abs((f64)image[at] - (f64)image[at + 1]) < 8.0 and math.abs((f64)image[at + 1] - (f64)image[at + 2]) < 8.0)
    try view.renderer.value().set_curvature(0)
    let grid = try MeshPrimitives.grid(4.0, 8)
    defer grid.release()
    try view.camera.value().set_position(Vector3(0.0, 4.0, 0.5))
    try view.camera.value().look_at(Vector3(0.0, 0.0, 0.0))
    try view.show(grid, false)
    try view.renderer.value().set_curvature(0)
    try view.draw(image)
    assert(image[at + 1] > 150 and image[at] < 100 and image[at + 2] < 100)
    try view.renderer.value().set_shading(0)
    try view.camera.value().set_position(Vector3(0.0, 1.0, 5.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))

## Draft shading: the sphere's middle faces the camera; pulled toward the
## camera it has all the draft (green), pulled up none (yellow, within the
## angle asked for), pulled away it faces backwards (red).
func draft_map(view: View*, image: u8[]) -> !:
    try view.camera.value().set_position(Vector3(0.0, 1.0, 5.0))
    try view.camera.value().look_at(Vector3(0.0, 1.0, 0.0))
    let sphere = try MeshPrimitives.sphere(1.0, 48)
    defer sphere.release()
    try view.show(sphere, false)
    let at = (usize)((height // 2 * width + width // 2) * 4)
    try view.renderer.value().set_draft(3.0)
    try view.renderer.value().set_shading(7, axis = Vector3(0.0, 0.0, 1.0))
    try view.draw(image)
    assert(image[at + 1] > 150 and image[at] < 120 and image[at + 2] < 120)
    try view.renderer.value().set_shading(7, axis = Vector3(0.0, 1.0, 0.0))
    try view.draw(image)
    assert(image[at] > 150 and image[at + 1] > 120 and image[at + 2] < 100)
    try view.renderer.value().set_shading(7, axis = Vector3(0.0, 0.0, -1.0))
    try view.draw(image)
    assert(image[at] > 150 and image[at + 1] < 100 and image[at + 2] < 100)
    try view.renderer.value().set_shading(0)

pub func main(arguments: str[]) -> i32!:
    # Metal's validation, read when the device is made
    try os.set_env("MTL_DEBUG_LAYER", "1")
    var device = gpu.Device.open() catch failure:
        if failure.code == gpu.unavailable:
            print("skip: no GPU device")
            return 0
        error(failure.code, failure.message)
    defer device.destroy()
    var view = try View(device)
    defer view.close()
    let legacy_image = try new u8[(usize)(width * height * 4)] --- in memory.heap
    defer free(legacy_image) in memory.heap
    let image = try new u8[(usize)(width * height * 4)] --- in memory.heap
    defer free(image) in memory.heap
    let cube = try geocore.Mesh.cube(1.5)
    defer cube.release()
    try equivalence(&view, cube, false, legacy_image, image)
    try equivalence(&view, cube, true, legacy_image, image)
    let sphere = try MeshPrimitives.sphere(1.0, 24)
    defer sphere.release()
    var groups: i64[]
    let smooth = try MeshNormals.generate(sphere, groups)
    defer smooth.release()
    let colored = try AttributeKernels.filled(smooth, "Cd", 0, [0.9, 0.3, 0.2], false, true, 5.0)
    defer colored.release()
    try equivalence(&view, colored, false, legacy_image, image, 24)
    # A moved mesh uploads its positions and normals only.
    let before = view.renderer.value().uploads()
    let bytes = view.renderer.value().uploaded_bytes()
    let moved = try colored.value().moved_points([130, 131, 132], Vector3(0.0, 0.1, 0.0))
    defer moved.release()
    try view.show(moved, false)
    try view.draw(image)
    assert(view.renderer.value().uploads() == before + 2)
    # Only the moved neighbourhood uploads, and it draws what a whole upload
    # would (the per-vertex path over the moved mesh).
    assert(view.renderer.value().uploaded_bytes() - bytes < (colored.value().point_count() + colored.value().vertex_count()) * 12 // 4)
    try equivalence(&view, moved, false, legacy_image, image, 24)
    try zebra(&view, image)
    try curvature_map(&view, image)
    try draft_map(&view, image)
    try picking(&view, cube, image)
    try occlusion(&view, cube, image)
    try ground_grid(&view, cube, image)
    try grid_behind_raised(&view, cube, image, legacy_image)
    try square_on_wires(&view, cube, image)
    try two_sided(&view, cube, legacy_image, image)
    try subdivided(&view, cube, image, legacy_image)
    print("ok mesh pixels: GPU arrays match the per-vertex path; Move uploads positions and normals; zebra stripes scale, break at creases and flow; lines drawn after meshes are occluded; the grid hides behind a raised cube; wires on faces seen square on orthographically show; inside-out meshes light on the eye's side; curvature maps and their radius band; draft against a pull direction; GPU face picking and selection tint")
    return 0