dymokomi/luce-3d
Source of release 0.9.1
0.9.1 / 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
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)
let reversing = try Verbs.run("Reverse", cube, "", 0, [0.0])
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!:
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