dymokomi/luce-geocore
Source of release 0.7.4
0.7.4 / tests / code / support.lucb
## Helpers for the Code checks: grids as sets, running a snippet, reading results.
import interop
import memory
from luce_std import math
from luce_geocore import geocore, kernel as geocore_kernel
from luce_geocore.geocore import Mesh, MeshPrimitives, GeometrySet, Vector3
pub let points_mode: i64 = 1
pub let vertices_mode: i64 = 2
pub let primitives_mode: i64 = 3
pub let detail_mode: i64 = 0
pub let numbers_mode: i64 = 4
## A set holding a grid of `divisions` squared faces.
pub func grid_set(divisions: i64) -> interop.Reference[GeometrySet]!:
return try GeometrySet.of_mesh(try MeshPrimitives.grid(2.0, divisions))
## A set holding a flat grid of `side` by `side` points (any size, unlike the primitive).
pub func big_grid_set(side: usize) -> interop.Reference[GeometrySet]!:
let points = try new Vector3[side * side] --- in memory.heap
defer free(points) in memory.heap
let faces = (side - 1) * (side - 1)
let sizes = try new i64[faces] in memory.heap
defer free(sizes) in memory.heap
let corners = try new i64[faces * 4] in memory.heap
defer free(corners) in memory.heap
for row in 0..<side:
for column in 0..<side:
points[row * side + column] = Vector3((f64)column / (f64)(side - 1) * 2.0 - 1.0, 0.0, (f64)row / (f64)(side - 1) * 2.0 - 1.0)
for row in 0..<side - 1:
for column in 0..<side - 1:
let face = row * (side - 1) + column
sizes[face] = 4
let first = (i64)(row * side + column)
corners[face * 4] = first
corners[face * 4 + 1] = first + (i64)side
corners[face * 4 + 2] = first + (i64)side + 1
corners[face * 4 + 3] = first + 1
let storage = try new Mesh[1] --- in memory.heap
storage[0] = Mesh(points, sizes, corners) catch failure:
free(storage) in memory.heap
error(failure.code, failure.message)
return try GeometrySet.of_mesh(try geocore_kernel.mesh_adopt(storage.data))
## A closed unit sphere around the origin, faces outward: `segments` around and `rows`
## from pole to pole (triangles at the poles, quads between), any size.
pub func closed_sphere(segments: usize, rows: usize) -> interop.Reference[GeometrySet]!:
let count = 2 + (rows - 1) * segments
let points = try new Vector3[count] --- in memory.heap
defer free(points) in memory.heap
let faces = segments * rows
let sizes = try new i64[faces] in memory.heap
defer free(sizes) in memory.heap
let corners = try new i64[faces * 4] in memory.heap
defer free(corners) in memory.heap
let bottom = (i64)(count - 1)
points[0] = Vector3(0.0, 1.0, 0.0)
points[count - 1] = Vector3(0.0, -1.0, 0.0)
for ring in 1..<rows:
let theta = (f64)ring * math.pi / (f64)rows
for s in 0..<segments:
let phi = (f64)s * 2.0 * math.pi / (f64)segments
points[1 + (ring - 1) * segments + s] = Vector3(math.sin(theta) * math.cos(phi), math.cos(theta), math.sin(theta) * math.sin(phi))
var face: usize = 0
var at: usize = 0
for s in 0..<segments:
let next = (s + 1) % segments
sizes[face] = 3
corners[at] = 0
corners[at + 1] = (i64)(1 + next)
corners[at + 2] = (i64)(1 + s)
face += 1
at += 3
for ring in 1..<rows - 1:
for s in 0..<segments:
let next = (s + 1) % segments
let upper = 1 + (ring - 1) * segments
let lower = upper + segments
sizes[face] = 4
corners[at] = (i64)(upper + s)
corners[at + 1] = (i64)(upper + next)
corners[at + 2] = (i64)(lower + next)
corners[at + 3] = (i64)(lower + s)
face += 1
at += 4
let last = 1 + (rows - 2) * segments
for s in 0..<segments:
let next = (s + 1) % segments
sizes[face] = 3
corners[at] = (i64)(last + s)
corners[at + 1] = (i64)(last + next)
corners[at + 2] = bottom
face += 1
at += 3
let storage = try new Mesh[1] --- in memory.heap
storage[0] = Mesh(points, sizes[..<face], corners[..<at]) catch failure:
free(storage) in memory.heap
error(failure.code, failure.message)
return try GeometrySet.of_mesh(try geocore_kernel.mesh_adopt(storage.data))
pub func no_names() -> const str[]:
var none_given: const str[]
return none_given
pub func no_values() -> const f64[]:
var none_given: const f64[]
return none_given
## Run `body` over `set` (no header, group, parameters; frame 1, time 0, 24 fps).
pub func run(set: interop.Reference[GeometrySet], mode: i64, body: str, threads: usize = 0) -> interop.Reference[GeometrySet]!:
return try run_with(set, mode, "", body, "", no_names(), no_values(), threads)
pub func run_with(set: interop.Reference[GeometrySet], mode: i64, header: str, body: str, group: str, names: const str[], values: const f64[], threads: usize = 0, count: i64 = 0) -> interop.Reference[GeometrySet]!:
let made = try geocore_kernel.run_code(try set.get(), none, mode, header, body, group, 0, names, values, 1.0, 0.0, 24.0, count, threads)
return try geocore_kernel.adopt_set(made)
## Run `body` restricted to `group` read on `group_type`'s domain.
pub func run_with_type(set: interop.Reference[GeometrySet], mode: i64, body: str, group: str, group_type: i64) -> interop.Reference[GeometrySet]!:
let made = try geocore_kernel.run_code(try set.get(), none, mode, "", body, group, group_type, no_names(), no_values(), 1.0, 0.0, 24.0, 0, 0)
return try geocore_kernel.adopt_set(made)
## Run with a second input and a Numbers count, on `threads` workers.
pub func run_inputs(set: interop.Reference[GeometrySet], input1: interop.Reference[GeometrySet]?, mode: i64, body: str, count: i64 = 0, threads: usize = 0) -> interop.Reference[GeometrySet]!:
var second: const GeometrySet*? = none
if let given = input1: second = try given.get()
let made = try geocore_kernel.run_code(try set.get(), second, mode, "", body, "", 0, no_names(), no_values(), 1.0, 0.0, 24.0, count, threads)
return try geocore_kernel.adopt_set(made)
## An empty set (no mesh).
pub func empty_set() -> interop.Reference[GeometrySet]!:
return try geocore_kernel.adopt_set(try geocore_kernel.empty_set())
## The mesh of a set (trap without one).
pub func mesh_of(set: interop.Reference[GeometrySet]) -> interop.Reference[Mesh]!:
let found = try (try set.get()).mesh()
return found else trap("the set has no mesh")
## Attribute `name` on domain `domain` (0 point, 1 corner, 2 face) of `mesh`, component
## `component` of element `element`.
pub func value(mesh: interop.Reference[Mesh], name: str, domain: i64, element: i64, component: i64 = 0) -> f64!:
let m = try mesh.get()
let index = m.find_attribute(name, domain)
if index < 0:
print(f"no attribute {name}")
trap("missing attribute")
return try m.attribute_value(index, element, component)