Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.3

0.9.3 / tests / mesh_pixels / main.lucb

## Offscreen pixels of the polygon-mesh path (GPU arrays, shader lighting):
## 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, PerspectiveCamera, Renderer, Color, WireRenderer, MeshGeometry

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[PerspectiveCamera]
    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[PerspectiveCamera].adopt(new PerspectiveCamera(40.0, 1.0, 0.1, 100.0) in memory.heap, three.perspective_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)

    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)
    # 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)

## 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])
    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))

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 picking(&view, cube, image)
    try occlusion(&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; inside-out meshes light on the eye's side; curvature maps; GPU face picking and selection tint")
    return 0