dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / tests / mesh / field_checks.lucb
## Volumes and SDFs: leaf keys, SDF programs (primitives, booleans, smooth
## blends, placement, modifiers), sampled level sets from SDFs, meshes and
## points, surface nets (closed, outward, on the surface), slices, the
## volume and SDF families in sets, their previews, the codec round trip,
## and every field verb's counts and determinism.
from luce_geocore import geocore, kernel as geocore_kernel
import interop
from luce_std import math
import memory
from io import path
from luce_geocore.geocore import Vector3, Matrix4, Mesh, MeshPrimitives, GeometrySet
from luce_geocore.kernel import Sdf, SdfOp, SparseGrid, GridClass, GridSampler, Volume, Domain, primitive_sdf, combined_sdf, modified_sdf, placed_sdf, release_sdf, sampled_sdf, mesh_level_set, points_level_set, surface_mesh, release_grid, new_volume, add_grid, release_volume, volume_type, sdf_type, set_volume, set_sdf, empty_set, dispose_set, adopt_set, set_mesh, save_geometry, load_geometry, run_set_verb, find_set_verb, leaf_key, key_leaf, sdf_preview, mesh_adopt, VolumeLook, fog_show, fog_show_count
from luce_geocore.core.growing import Growing
func near(a: f64, b: f64, tolerance: f64 = 0.0001) -> bool:
return math.abs(a - b) < tolerance
pub func exercise() -> !:
try saddle()
try keys()
try programs()
try level_sets()
try surfaces()
try sets_and_files()
try verbs()
try looks()
## A small, coarse pass over every kernel and verb, for allocation-failure
## injection (each stage reruns it): SDF programs, sampling, surface nets,
## mesh and point level sets, slices, the families in sets and the codec.
pub func allocations() -> !:
let empty = try adopt_set(try empty_set())
defer empty.release()
let ball = try apply("SDF Sphere", empty.value(), [1.0, 0.0, 0.0, 0.0])
defer ball.release()
let block = try apply("SDF Box", empty.value(), [1.0, 1.0, 1.0, 0.1, 0.8, 0.0, 0.0])
defer block.release()
let carved = try apply("SDF Boolean", ball.value(), [1.0, 0.1], block.value())
defer carved.release()
let hollow = try apply("SDF Modify", carved.value(), [1.0, 0.05])
defer hollow.release()
let meshed = try apply("Convert to Mesh", hollow.value(), [0.25, 0.0, 1.0, 1.0])
defer meshed.release()
let sampled = try apply("SDF to Volume", ball.value(), [0.25, 2.0, 0.0])
defer sampled.release()
let slice = try apply("Volume Slice", sampled.value(), [1.0, 0.5, 4.0, 1.0])
defer slice.release()
let cube = try Mesh.cube(2.0)
defer cube.release()
let cube_set = try GeometrySet.of_mesh(cube)
defer cube_set.release()
let solid = try apply("Mesh to SDF", cube_set.value(), [0.25, 2.0, 1.0])
defer solid.release()
let blobs = try apply("Volume from Points", cube_set.value(), [0.3, 0.25, 2.0, 0.0])
defer blobs.release()
let remeshed = try apply("Convert to Mesh", blobs.value(), [0.0, 0.0, 0.0, 0.0])
defer remeshed.release()
let moved = try hollow.value().transformed(Vector3(1.0, 0.0, 0.0), Vector3(), Vector3(2.0, 2.0, 2.0))
defer moved.release()
let both = try moved.value().merged(solid)
defer both.release()
_ = try both.value().bounds()
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-geocore-fields-small.prism".bytes: try file.push(byte)
_ = try save_geometry(both.value(), (str)file.view(), 1, 1024)
let loaded = try adopt_set(try load_geometry((str)file.view()))
loaded.release()
## The checks once more, reporting.
pub func run() -> !:
try exercise()
print("PASS volumes and SDFs: keys, programs, level sets, surface nets, slices, sets, files, verbs")
## An L-shaped prism: its inner corner has a concave edge and saddle
## vertices, where the nearest face's own normal gives the wrong side.
## Pseudo-normals get every voxel of the band right.
func l_prism() -> interop.Reference[Mesh]!:
let outline: f64[12] = [0.0, 0.0, 2.0, 0.0, 2.0, 1.0, 1.0, 1.0, 1.0, 2.0, 0.0, 2.0]
var points: Vector3[12] = ---
for at in 0..<(usize)6:
points[at] = Vector3(outline[at * 2], outline[at * 2 + 1], 0.0)
points[at + 6] = Vector3(outline[at * 2], outline[at * 2 + 1], 1.0)
let sizes: i64[8] = [6, 6, 4, 4, 4, 4, 4, 4]
var corners: i64[36] = ---
for at in 0..<(usize)6:
corners[at] = (i64)(5 - at)
corners[6 + at] = (i64)(6 + at)
let next = (at + 1) % 6
corners[12 + at * 4] = (i64)at
corners[12 + at * 4 + 1] = (i64)next
corners[12 + at * 4 + 2] = (i64)(6 + next)
corners[12 + at * 4 + 3] = (i64)(6 + at)
return try interop.Reference[Mesh].adopt(try new Mesh(points, sizes, corners) in memory.heap, geocore.mesh_type, memory.heap)
func inside_l(p: Vector3) -> bool:
if p.z <= 0.0 or p.z >= 1.0 or p.x <= 0.0 or p.y <= 0.0: return false
return (p.x < 2.0 and p.y < 1.0) or (p.x < 1.0 and p.y < 2.0)
pub func saddle() -> !:
let mesh = try l_prism()
defer mesh.release()
for voxel in [0.05, 0.07]:
let grid = try mesh_level_set(mesh.value(), voxel, 3.0, "surface")
defer release_grid(grid)
var checked: usize = 0
let leaf_keys = grid.keys.view()
let values = grid.values.view()
for leaf in 0..<leaf_keys.length:
let (lx, ly, lz) = key_leaf(leaf_keys[leaf])
for at in 0..<(usize)512:
let value = (f64)values[leaf * 512 + at]
if math.abs(value) < 0.000001: continue
let p = Vector3((f64)(lx * 8 + (i64)(at & 7)) * voxel, (f64)(ly * 8 + (i64)((at >> 3) & 7)) * voxel, (f64)(lz * 8 + (i64)(at >> 6)) * voxel)
assert((value < 0.0) == inside_l(p))
checked += 1
assert(checked > 10000)
# A 64-segment sphere has about 4,000 triangles against 400 band voxels
# at voxel 0.4, so it takes the BVH path: distances within the
# tessellation's error of the analytic sphere's (it rests on the ground).
let ball = try MeshPrimitives.sphere(1.0, 64)
defer ball.release()
let queried = try mesh_level_set(ball.value(), 0.4, 2.0, "surface")
defer release_grid(queried)
var compared: usize = 0
let ball_keys = queried.keys.view()
for leaf in 0..<ball_keys.length:
let (lx, ly, lz) = key_leaf(ball_keys[leaf])
for at in 0..<(usize)512:
let value = (f64)queried.values.view()[leaf * 512 + at]
let p = Vector3((f64)(lx * 8 + (i64)(at & 7)) * 0.4, (f64)(ly * 8 + (i64)((at >> 3) & 7)) * 0.4, (f64)(lz * 8 + (i64)(at >> 6)) * 0.4)
let exact = p.subtract(Vector3(0.0, 1.0, 0.0)).length() - 1.0
if math.abs(exact) > 0.7: continue
assert(math.abs(value - exact) < 0.01)
compared += 1
assert(compared > 100)
# The concave corner's own voxels: just inside and just outside.
let fine = try mesh_level_set(mesh.value(), 0.05, 3.0, "surface")
defer release_grid(fine)
var sampler = GridSampler.of(fine)
assert(sampler.sample(Vector3(0.95, 0.95, 0.5)) < 0.0 and sampler.sample(Vector3(1.05, 1.05, 0.5)) > 0.0)
assert(sampler.sample(Vector3(1.05, 1.05, 0.95)) > 0.0 and sampler.sample(Vector3(0.95, 0.95, 1.05)) > 0.0)
pub func keys() -> !:
for x in -3..<(i64)3:
let key = leaf_key(x, x * 7, -x * 11)
let (a, b, c) = key_leaf(key)
assert(a == x and b == x * 7 and c == -x * 11)
assert(leaf_key(0, 0, 0) < leaf_key(1, 0, 0) and leaf_key(1, 0, 0) < leaf_key(0, 1, 0))
pub func programs() -> !:
let sphere = try primitive_sdf(SdfOp.sphere, [0.0, 0.0, 0.0, 1.0])
defer release_sdf(sphere)
assert(near(sphere.distance(Vector3()), -1.0) and near(sphere.distance(Vector3(2.0, 0.0, 0.0)), 1.0))
let box = try primitive_sdf(SdfOp.rounded_box, [0.5, 0.0, 0.0, 0.5, 0.5, 0.5, 0.0])
defer release_sdf(box)
assert(near(box.distance(Vector3(0.5, 0.0, 0.0)), -0.5) and near(box.distance(Vector3(2.0, 0.0, 0.0)), 1.0))
# The sphere without the box: the box's side is now outside.
let cut = try combined_sdf(sphere, box, SdfOp.subtract, 0.0)
defer release_sdf(cut)
assert(cut.distance(Vector3(0.5, 0.0, 0.0)) > 0.0 and near(cut.distance(Vector3(-0.5, 0.0, 0.0)), -0.5))
# A smooth union sinks below both at the seam.
let blend = try combined_sdf(sphere, box, SdfOp.smooth_unite, 0.5)
defer release_sdf(blend)
let seam = Vector3(0.9, 0.6, 0.0)
assert(blend.distance(seam) < math.min(sphere.distance(seam), box.distance(seam)))
# Placement: moved, and scaled distances.
let moved = try placed_sdf(sphere, Matrix4.compose(Vector3(3.0, 0.0, 0.0), Vector3(), Vector3(2.0, 2.0, 2.0)))
defer release_sdf(moved)
assert(near(moved.distance(Vector3(3.0, 0.0, 0.0)), -2.0, 0.0001) and near(moved.distance(Vector3(6.0, 0.0, 0.0)), 1.0, 0.0001))
let box_bounds = moved.bounds()
assert(near(box_bounds.minimum.x, 1.0) and near(box_bounds.maximum.x, 5.0))
let shell = try modified_sdf(sphere, SdfOp.shell, 0.1)
defer release_sdf(shell)
assert(near(shell.distance(Vector3()), 0.9) and near(shell.distance(Vector3(1.0, 0.0, 0.0)), -0.1))
pub func level_sets() -> !:
let sphere = try primitive_sdf(SdfOp.sphere, [0.0, 0.0, 0.0, 1.0])
defer release_sdf(sphere)
let grid = try sampled_sdf(sphere, 0.05, 3.0, "surface")
defer release_grid(grid)
assert(grid.leaf_count() > 0 and grid.class == GridClass.level_set and grid.active_count() > 1000)
var sampler = GridSampler.of(grid)
assert(near(sampler.sample(Vector3(1.0, 0.0, 0.0)), 0.0, 0.002) and near(sampler.sample(Vector3(0.0, 1.05, 0.0)), 0.05, 0.002))
# Far outside: the background (the band's distance).
assert(near(sampler.sample(Vector3(5.0, 0.0, 0.0)), 0.15, 0.0001))
# A closed mesh's signed distance (the cube stands on y = 0): inside
# near its faces is negative.
let cube = try Mesh.cube(2.0)
defer cube.release()
let solid = try mesh_level_set(cube.value(), 0.1, 3.0, "surface")
defer release_grid(solid)
var cube_sampler = GridSampler.of(solid)
assert(near(cube_sampler.sample(Vector3(0.9, 1.0, 0.0)), -0.1, 0.01) and near(cube_sampler.sample(Vector3(1.1, 1.2, 0.3)), 0.1, 0.01))
# Spheres around points: -radius at a point.
let points: Vector3[2] = [Vector3(), Vector3(1.0, 0.0, 0.0)]
let blobs = try points_level_set(points, 0.2, 0.02, 3.0, "surface")
defer release_grid(blobs)
var blob_sampler = GridSampler.of(blobs)
assert(near(blob_sampler.sample(Vector3(1.0, 0.0, 0.0)), -0.06, 0.001) and near(blob_sampler.sample(Vector3(0.5, 0.0, 0.0)), 0.06, 0.001))
## Every edge of `mesh` shared by two faces in opposite directions, and
## every face facing away from `inside`.
func closed_and_outward(mesh: interop.Reference[Mesh], inside: Vector3) -> !:
let m = mesh.value()
let counts = try new i64[(usize)(try m.edge_count())] --- in memory.heap
defer free(counts) in memory.heap
for at in 0..<counts.length: counts[at] = 0
for face in 0..<m.face_count():
for corner in 0..<(try m.face_size(face)):
let c = (try m.face_offset(face)) + corner
let edge = try m.corner_edge(c)
counts[(usize)edge] += 1 if (try m.corner_point(c)) == (try m.edge_point(edge, 0)) else -1
assert((try m.face_normal(face)).dot((try m.face_center(face)).subtract(inside)) > 0.0)
for count in counts: assert(count == 0)
pub func surfaces() -> !:
let sphere = try primitive_sdf(SdfOp.sphere, [0.5, 0.0, 0.0, 1.0])
defer release_sdf(sphere)
let grid = try sampled_sdf(sphere, 0.05, 2.0, "surface")
defer release_grid(grid)
let mesh = try mesh_adopt(try surface_mesh(grid, 0.0, sphere))
defer mesh.release()
assert(mesh.value().face_count() > 1000)
let unprojected = try mesh_adopt(try surface_mesh(grid, 0.0, none))
defer unprojected.release()
try closed_and_outward(unprojected, Vector3(0.5, 0.0, 0.0))
for point in mesh.value().point_span():
assert(near(point.vector().add(mesh.value().position_origin()).subtract(Vector3(0.5, 0.0, 0.0)).length(), 1.0, 0.001))
try closed_and_outward(mesh, Vector3(0.5, 0.0, 0.0))
# The same grid gives the same bytes.
let again = try mesh_adopt(try surface_mesh(grid, 0.0, sphere))
defer again.release()
let a = mesh.value().point_span()
let b = again.value().point_span()
assert(a.length == b.length)
for at in 0..<a.length: assert(a[at] == b[at])
# Without projection the vertices stay within a voxel of the surface.
let rough = try mesh_adopt(try surface_mesh(grid, 0.0, none))
defer rough.release()
for point in rough.value().point_span():
assert(near(point.vector().subtract(Vector3(0.5, 0.0, 0.0)).length(), 1.0, 0.05))
# A drag's quick preview is coarser and kept apart; the full preview is
# built once, and then serves quick requests too.
let quick = (try sdf_preview(sphere, true)) else trap("preview")
assert((try sdf_preview(sphere, true)) == quick)
let first = (try sdf_preview(sphere, false)) else trap("preview")
let second = (try sdf_preview(sphere, false)) else trap("preview")
assert(first == second and first.face_count() > quick.face_count() * 4 and quick.face_count() > 0)
assert((try sdf_preview(sphere, true)) == first)
## A set of `sdf` (taken).
func sdf_set(sdf: Sdf*) -> interop.Reference[GeometrySet]!:
let storage = empty_set() catch failure:
release_sdf(sdf)
error(failure.code, failure.message)
storage.put(sdf_type(), (void*)sdf) catch failure:
dispose_set(storage)
error(failure.code, failure.message)
return try adopt_set(storage)
pub func sets_and_files() -> !:
let sphere = try sdf_set(try primitive_sdf(SdfOp.sphere, [0.0, 0.0, 0.0, 1.0]))
defer sphere.release()
let described = try sphere.value().description()
defer described.release()
assert(described.value == "SDF of 1 ops")
# Placement wraps the program; merging two SDFs is their union.
let moved = try sphere.value().transformed(Vector3(2.0, 0.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer moved.release()
let both = try sphere.value().merged(moved)
defer both.release()
let joined = set_sdf(both.value()) else trap("sdf")
assert(near(joined.distance(Vector3(2.0, 0.0, 0.0)), -1.0) and near(joined.distance(Vector3()), -1.0))
# A volume of a sampled grid: bounds, description, placement.
let sampled = try apply("SDF to Volume", both.value(), [0.1, 3.0, 1.0])
defer sampled.release()
let volume = set_volume(sampled.value()) else trap("volume")
assert(volume.grid_count() == 1 and set_sdf(sampled.value()) != none)
let box = try sampled.value().bounds()
assert(box.minimum.x < -1.0 and box.maximum.x > 3.0)
let shifted = try sampled.value().transformed(Vector3(0.0, 1.0, 0.0), Vector3(), Vector3(1.0, 1.0, 1.0))
defer shifted.release()
var sampler = GridSampler.of((set_volume(shifted.value()) else trap("volume")).grid(0))
assert(near(sampler.sample(Vector3(1.0, 1.0, 0.0)), 0.0, 0.01))
# Files: the volume and the SDF come back exactly.
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-geocore-fields.prism".bytes: try file.push(byte)
_ = try save_geometry(shifted.value(), (str)file.view(), 3, 4096)
let loaded = try adopt_set(try load_geometry((str)file.view()))
defer loaded.release()
let x = (set_volume(shifted.value()) else trap("volume")).grid(0)
let y = (set_volume(loaded.value()) else trap("volume")).grid(0)
assert(x.name() == y.name() and x.class == y.class and x.background == y.background and x.transform.translation == y.transform.translation and x.transform.x == y.transform.x)
assert(x.keys.count() == y.keys.count() and x.values.count() == y.values.count())
for at in 0..<x.values.count(): assert(x.values.view()[at] == y.values.view()[at])
for at in 0..<x.masks.count(): assert(x.masks.view()[at] == y.masks.view()[at])
let p = set_sdf(shifted.value()) else trap("sdf")
let q = set_sdf(loaded.value()) else trap("sdf")
assert(p.op_count() == q.op_count() and p.distance(Vector3(0.3, 0.2, 0.1)) == q.distance(Vector3(0.3, 0.2, 0.1)))
## Run set verb `name` on `set` (and `second`).
func apply(name: str, set: const GeometrySet*, numbers: const f64[], second: const GeometrySet*? = none, texts: const str[] = [""]) -> interop.Reference[GeometrySet]!:
let verb = find_set_verb(name) else trap("no such verb")
var output = try run_set_verb(&verb, set, second, "", 0, numbers, texts)
defer output.close()
let made = output.set else trap("no set")
output.set = none
return try adopt_set(made)
pub func verbs() -> !:
let empty = try adopt_set(try empty_set())
defer empty.release()
let ball = try apply("SDF Sphere", empty.value(), [1.0, 0.0, 0.0, 0.0])
defer ball.release()
let block = try apply("SDF Box", empty.value(), [1.0, 1.0, 1.0, 0.1, 0.8, 0.0, 0.0])
defer block.release()
let ring = try apply("SDF Torus", empty.value(), [1.0, 0.25, 0.0, 0.0, 0.0])
defer ring.release()
let pill = try apply("SDF Capsule", empty.value(), [0.25, 1.0, 0.0, 0.0, 0.0])
defer pill.release()
let can = try apply("SDF Cylinder", empty.value(), [0.5, 1.0, 0.0, 0.0, 0.0])
defer can.release()
for shape in [ball, block, ring, pill, can]: assert(set_sdf(shape.value()) != none)
# The ball minus the block, smoothly, then hollowed.
let carved = try apply("SDF Boolean", ball.value(), [1.0, 0.1], block.value())
defer carved.release()
let hollow = try apply("SDF Modify", carved.value(), [1.0, 0.05])
defer hollow.release()
assert((set_sdf(hollow.value()) else trap("sdf")).op_count() == 4)
# Its surface, twice: closed, outward, the same bytes.
let mesh_set = try apply("Convert to Mesh", ball.value(), [0.05, 0.0, 1.0, 0.0])
defer mesh_set.release()
let mesh = (try mesh_set.value().mesh()) else trap("mesh")
defer mesh.release()
assert(set_sdf(mesh_set.value()) == none and mesh.value().face_count() > 1000)
try closed_and_outward(mesh, Vector3())
let twice = try apply("Convert to Mesh", ball.value(), [0.05, 0.0, 1.0, 0.0])
defer twice.release()
let other = (try twice.value().mesh()) else trap("mesh")
defer other.release()
let a = mesh.value().point_span()
let b = other.value().point_span()
assert(a.length == b.length)
for at in 0..<a.length: assert(a[at] == b[at])
# Mesh to SDF, back to a mesh: the cube's surface, closed.
let cube = try Mesh.cube(2.0)
defer cube.release()
let cube_set = try GeometrySet.of_mesh(cube)
defer cube_set.release()
let solid = try apply("Mesh to SDF", cube_set.value(), [0.1, 3.0, 0.0])
defer solid.release()
assert(set_volume(solid.value()) != none and not solid.value().has_mesh())
let remeshed = try apply("Convert to Mesh", solid.value(), [0.0, 0.0, 0.0, 0.0])
defer remeshed.release()
let surface = (try remeshed.value().mesh()) else trap("mesh")
defer surface.release()
try closed_and_outward(surface, Vector3(0.0, 1.0, 0.0))
assert(near(surface.value().bounds().maximum.x, 1.0, 0.1))
# Spheres around the cube's corners.
let blobs = try apply("Volume from Points", cube_set.value(), [0.3, 0.05, 3.0, 0.0])
defer blobs.release()
let blob_mesh = try apply("Convert to Mesh", blobs.value(), [0.0, 0.0, 0.0, 0.0])
defer blob_mesh.release()
let blob_surface = (try blob_mesh.value().mesh()) else trap("mesh")
defer blob_surface.release()
assert(blob_surface.value().face_count() > 8 * 50)
# A slice through the ball: 17×17 points (with value and Cd) beside it.
let slice = try apply("Volume Slice", ball.value(), [1.0, 0.5, 16.0, 1.0])
defer slice.release()
let plane = (try slice.value().mesh()) else trap("mesh")
defer plane.release()
assert(plane.value().point_count() == 17 * 17 and plane.value().face_count() == 16 * 16 and set_sdf(slice.value()) != none)
let values = plane.value().find_attribute("value", 0)
assert(values >= 0 and plane.value().find_attribute("Cd", 0) >= 0)
# The plane's middle point is the ball's center: one inside.
assert(near(try plane.value().attribute_value(values, 8 * 17 + 8), -1.0, 0.001))
## Volume Visualization: a look goes on the grids its group names, each grid
## its own (Houdini's per-primitive volvis attributes), their voxels shared; a
## grid named as an emission, emission color or density field lends its values
## and is not drawn as smoke; a look survives a file.
pub func looks() -> !:
let empty = try adopt_set(try empty_set())
defer empty.release()
let box: f64[11] = [0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0, 0.1, 0.0, 1.0, 1.0]
let one = try apply("Volume", empty.value(), box)
defer one.release()
let two = try apply("Volume", one.value(), box, none, ["heat"])
defer two.release()
let fog = try apply("Volume", two.value(), box, none, ["smoke"])
defer fog.release()
let plain = set_volume(fog.value()) else trap("volume")
assert(plain.grid_count() == 3 and plain.grid(0).look.density == 1.0 and plain.grid(1).look.emission_field() == "")
# Three fog grids, no fields named: three drawings, each its own grid.
assert(fog_show_count(plain) == 3)
# Grid "density" glows from "heat" through a ramp; "smoke" is tinted.
let ramp = "1,3,2, 0,1,0,0,1, 1,0,0,1,1"
let glowing = try apply("Volume Visualization", fog.value(), [4.0, 0.5, 0.6, 0.7, 2.0, 3.0, 1.0, 0.5, 0.0, 1.0, 0.0, 2.0, 0.5], none, ["density", "", " heat ", ramp])
defer glowing.release()
let tinted = try apply("Volume Visualization", glowing.value(), [1.0, 0.2, 0.9, 0.3], none, ["smo*"])
defer tinted.release()
let volume = set_volume(tinted.value()) else trap("volume")
let density = volume.grid(0)
let look = density.look
assert(look.density == 4.0 and look.smoke == Vector3(0.5, 0.6, 0.7) and look.shadow == 2.0 and look.emission == 3.0 and look.step == 0.5)
assert(look.emission_field() == "heat" and look.density_field() == "" and look.emission_low == 0.0 and look.emission_high == 2.0)
assert(look.emission_ramp().length == 13 and look.emission_color_at(0.0) == Vector3(1.0, 0.0, 0.0) and look.emission_color_at(2.0) == Vector3(0.0, 0.0, 1.0))
assert(look.emission_color_at(1.0) == Vector3(0.5, 0.0, 0.5) and look.emission_color_at(9.0) == Vector3(0.0, 0.0, 1.0))
# The voxels are shared; an unnamed grid is the same grid, its look the default.
assert(density.values.id() == plain.grid(0).values.id() and volume.grid(1) == plain.grid(1) and volume.grid(1).look.emission == 0.0)
assert(volume.grid(2).look.smoke == Vector3(0.2, 0.9, 0.3) and volume.grid(2).look.density == 1.0)
# A look on every grid naming heat (heat's own included): heat is a
# field, density draws with it.
let all = try apply("Volume Visualization", two.value(), [1.0], none, ["", "", "heat"])
defer all.release()
let whole = set_volume(all.value()) else trap("volume")
assert(fog_show_count(whole) == 1 and (fog_show(whole, 0) else trap("show")).density == whole.grid(0))
# Heat is density's emission field: two drawings, density with heat, then smoke.
assert(fog_show_count(volume) == 2)
let first = fog_show(volume, 0) else trap("show")
let second = fog_show(volume, 1) else trap("show")
let field = first.emission else trap("emission")
assert(first.styled == density and first.density == density and field == volume.grid(1))
assert(second.styled == volume.grid(2) and second.density == volume.grid(2) and second.emission == none and fog_show(volume, 2) == none)
# Smoke shows heat's values as its density: heat lends them, and no grid
# names smoke, so it still draws (with heat's values).
let lent = try apply("Volume Visualization", tinted.value(), [1.0], none, ["smoke", "heat"])
defer lent.release()
let shown = set_volume(lent.value()) else trap("volume")
assert(fog_show_count(shown) == 2)
let swapped = fog_show(shown, 1) else trap("show")
assert(swapped.styled == shown.grid(2) and swapped.density == shown.grid(1))
# A density field the volume lacks draws nothing for that grid.
let missing = try apply("Volume Visualization", fog.value(), [1.0], none, ["smoke", "nothing"])
defer missing.release()
assert(fog_show_count(set_volume(missing.value()) else trap("volume")) == 2)
# Heat gives density's emission its strength and smoke its color: one
# drawing, both fields lent; without an emission field no color field.
let colored = try apply("Volume Visualization", fog.value(), [1.0, 1.0, 1.0, 1.0, 1.0, 2.0], none, ["density", "", "heat", "", "smoke"])
defer colored.release()
let hued = set_volume(colored.value()) else trap("volume")
let lit = fog_show(hued, 0) else trap("show")
assert(fog_show_count(hued) == 1 and lit.emission == hued.grid(1) and lit.emission_color == hued.grid(2))
assert(hued.grid(0).look.emission_color_field() == "smoke" and not hued.grid(0).look.same(&density.look))
let unlit = try apply("Volume Visualization", fog.value(), [1.0], none, ["density", "", "", "", "smoke"])
defer unlit.release()
let dark = set_volume(unlit.value()) else trap("volume")
assert(fog_show_count(dark) == 3 and (fog_show(dark, 0) else trap("show")).emission_color == none)
# A group naming no grid warns and changes nothing.
let verb = find_set_verb("Volume Visualization") else trap("no such verb")
var output = try run_set_verb(&verb, fog.value(), none, "", 0, [1.0], ["#7"])
defer output.close()
assert(output.warning != "")
# A look survives a file.
var file = Growing[u8]()
defer file.close()
try file.assign(path.temp().bytes)
for byte in "/luce-geocore-looks.prism".bytes: try file.push(byte)
_ = try save_geometry(tinted.value(), (str)file.view(), 1, 1024)
let loaded = try adopt_set(try load_geometry((str)file.view()))
defer loaded.release()
let back = set_volume(loaded.value()) else trap("volume")
let default_look = VolumeLook()
assert(back.grid(0).look.same(&density.look) and back.grid(2).look.same(&volume.grid(2).look) and back.grid(1).look.same(&default_look))
_ = try save_geometry(colored.value(), (str)file.view(), 1, 1024)
let colored_back = try adopt_set(try load_geometry((str)file.view()))
defer colored_back.release()
assert((set_volume(colored_back.value()) else trap("volume")).grid(0).look.same(&hued.grid(0).look))