dymokomi/luce-geocore
Source of release 0.7.9
0.7.9 / src / verbs / api.lucb
## The verb registry and how Luce runs verbs. The node catalog is generated
## from it: each verb is a node kind whose parameters are the verb's, plus
## Group and Group Type.
## Every modeling verb's constructor, in menu order: the array's length is
## the registry's size, so a verb added here is counted. The select rules
## (selecting/registry.lucb) follow them as the Select verbs.
let makers: (func() -> Verb)[84] = [
transform_verb,
smooth_verb,
relax_verb,
shrinkwrap_verb,
bend_verb,
lattice_verb, soft_transform_verb, corrective_smooth_verb, edge_transport_verb,
sculpt_verb,
mountain_verb,
peak_verb,
flatten_verb,
make_planar_verb,
circularize_verb,
straighten_verb,
space_evenly_verb,
snap_verb,
delete_verb,
reverse_verb,
recalculate_verb,
hard_edges_verb,
soft_edges_verb,
smooth_by_angle_verb,
mark_seam_verb,
seams_from_islands_verb,
triangulate_verb,
quadrangulate_verb,
extrude_verb,
inset_verb,
duplicate_verb,
split_verb,
separate_verb,
boolean_verb,
subdivide_verb,
fuse_verb,
clean_verb,
bevel_verb,
bevel_weight_verb,
fill_verb,
dissolve_verb,
delete_loop_verb,
limited_dissolve_verb,
reduce_verb,
loop_cut_verb,
offset_loops_verb,
bridge_verb,
merge_verb,
collapse_verb,
target_weld_verb,
subdivision_verb,
crease_verb,
clip_verb,
knife_verb,
connect_verb,
edge_slide_verb,
vertex_slide_verb,
mirror_verb,
spin_verb,
screw_verb,
box_verb,
grid_verb,
plane_verb,
sphere_verb,
icosphere_verb,
quad_sphere_verb,
cylinder_verb,
cone_verb,
tube_verb,
disc_verb,
torus_verb,
capsule_verb,
platonic_verb,
helix_verb,
polydraw_verb,
poly_pen_verb,
poke_verb,
rotate_edge_verb,
solidify_verb,
symmetrize_verb,
symmetry_snap_verb,
grid_fill_verb,
edge_split_verb,
rip_verb]
## Verb `index` in menu order: the modeling verbs, then the Select verbs.
pub func verb_at(index: usize) -> Verb:
if index >= verb_count(): trap("verb index out of range")
if index >= makers.length: return rule_verb(index - makers.length)
let make = makers[index]
return make()
## How many mesh verbs the registry holds.
pub func verb_count() -> usize:
return makers.length + rule_count()
## The mesh verb called `name`, if any.
pub func find_verb(name: str) -> Verb?:
for index in 0..<verb_count():
let verb = verb_at(index)
if verb.name == name: return verb
return none
## Luce's view of the verbs: their descriptions (for the node catalog) and
## running one.
pub struct Verbs:
let reserved: u8 = 0
## How many mesh verbs there are.
pub static func count() -> i64:
return (i64)verb_count()
## The index of verb `name`, or -1.
pub static func index_of(name: str) -> i64:
for index in 0..<verb_count():
if verb_at(index).name == name: return (i64)index
return -1
## Verb `index`'s node kind and recipe name.
pub static func name(index: i64) -> str:
return verb_at(checked(index)).name
## Verb `index`'s menu category.
pub static func category(index: i64) -> str:
return verb_at(checked(index)).category
## Verb `index`'s one-line description.
pub static func description(index: i64) -> str:
return verb_at(checked(index)).description
## The domain its kernel works on (0 points, 1 corners, 2 faces, 4 edges).
pub static func domain(index: i64) -> i64:
return (i64)(u8)verb_at(checked(index)).domain
## Whether verb `index` changes the topology (else positions and
## attributes only).
pub static func changes_topology(index: i64) -> bool:
return verb_at(checked(index)).changes_topology
## How many parameters verb `index` has.
pub static func parm_count(index: i64) -> i64:
return (i64)verb_at(checked(index)).parms.length
## Parameter `parm`'s label.
pub static func parm_label(index: i64, parm: i64) -> str:
return parm_of(index, parm).label
## 0 number, 1 integer, 2 toggle, 3 vector, 4 menu, 5 ramp.
pub static func parm_kind(index: i64, parm: i64) -> i64:
return (i64)(u8)parm_of(index, parm).kind
## Parameter `parm`'s initial value (each component's, for a vector).
pub static func parm_initial(index: i64, parm: i64) -> f64:
return parm_of(index, parm).initial
## Parameter `parm`'s lower bound.
pub static func parm_minimum(index: i64, parm: i64) -> f64:
return parm_of(index, parm).minimum
## Parameter `parm`'s upper bound.
pub static func parm_maximum(index: i64, parm: i64) -> f64:
return parm_of(index, parm).maximum
## Parameter `parm`'s slider maximum (0: its maximum).
pub static func parm_soft(index: i64, parm: i64) -> f64:
return parm_of(index, parm).soft
## How many numbers parameter `parm` takes (3 for a vector).
pub static func parm_components(index: i64, parm: i64) -> i64:
return (i64)parm_of(index, parm).components
## A menu parameter's choices, `Label|Label`.
pub static func parm_choices(index: i64, parm: i64) -> str:
return parm_of(index, parm).choices
## Parameter `parm`'s tooltip.
pub static func parm_doc(index: i64, parm: i64) -> str:
return parm_of(index, parm).doc
## Whether parameter `parm` shows on a tool's bar.
pub static func parm_bar(index: i64, parm: i64) -> bool:
return parm_of(index, parm).bar
## Whether parameter `parm` sits behind More options.
pub static func parm_more(index: i64, parm: i64) -> bool:
return parm_of(index, parm).more
# How verb `index` is offered as a tool (Verb's tool fields).
## Its tool label: `label`, else its name.
pub static func label(index: i64) -> str:
let verb = verb_at(checked(index))
return verb.label if verb.label.length > 0 else verb.name
## "Create", "Modify", "Select", or "" for a node only.
pub static func section(index: i64) -> str:
return verb_at(checked(index)).section
pub static func family(index: i64) -> str:
return verb_at(checked(index)).family
pub static func icon(index: i64) -> str:
return verb_at(checked(index)).icon
## How many picks it declares (0: one, at every level).
pub static func pick_count(index: i64) -> i64:
return (i64)verb_at(checked(index)).picks.length
pub static func pick_label(index: i64, pick: i64) -> str:
return pick_of(index, pick).label
## The levels pick `pick` takes, space apart ("": every level).
pub static func pick_levels(index: i64, pick: i64) -> str:
return pick_of(index, pick).levels
pub static func pick_prompt(index: i64, pick: i64) -> str:
return pick_of(index, pick).prompt
## The parameter a viewport drag sets after it runs (-1: none).
pub static func drag(index: i64) -> i64:
return verb_at(checked(index)).drag
## How the drag sets it: "length", "normal", "amount", "angle" or
## "slide" (Verb.drag_mode).
pub static func drag_mode(index: i64) -> str:
return verb_at(checked(index)).drag_mode
## Whether the value follows the pointer as soon as the tool runs.
pub static func follows(index: i64) -> bool:
return verb_at(checked(index)).follows
## The count parameter the wheel steps during the drag (-1: none).
pub static func wheel(index: i64) -> i64:
return verb_at(checked(index)).wheel
## The vector parameter an axis lock (X, Y, Z) sets, and the menu
## parameter it switches to its last choice (-1: none).
pub static func axis(index: i64) -> i64:
return verb_at(checked(index)).axis
pub static func axis_choice(index: i64) -> i64:
return verb_at(checked(index)).axis_choice
## How many keys change verb `index` while its drag lasts.
pub static func key_count(index: i64) -> i64:
return (i64)verb_at(checked(index)).keys.length
## Key `key`'s letter ("A"), the parameter it acts on, its action
## ("drag", "cycle" or "toggle") and, for "drag", how the drag moves
## that parameter (Verb.drag_mode's words).
pub static func key_name(index: i64, key: i64) -> str:
return key_of(index, key).key
pub static func key_parm(index: i64, key: i64) -> i64:
return key_of(index, key).parm
pub static func key_action(index: i64, key: i64) -> str:
return key_of(index, key).action
pub static func key_mode(index: i64, key: i64) -> str:
return key_of(index, key).mode
## Parameter `parm`'s initial value for component `component` (a ramp's
## default points; other parameters give `parm_initial` for each).
pub static func parm_initial_at(index: i64, parm: i64, component: i64) -> f64:
return parm_of(index, parm).initial_at((usize)component)
## Verb `name`'s drag frame on `mesh` for `group` (as `run` reads
## it) and its parameters: the group's center and average normal, and
## its rails for a "slide" drag.
pub static func frame(name: str, mesh: interop.Reference[Mesh], group: str, group_type: i64, numbers: const f64[], symmetry: i64 = 0) -> interop.Reference[DragFrame]!:
let verb = find_verb(name) else error(errors.invalid, "unknown operation")
var made = try drag_frame(&verb, try mesh.get(), group, group_type, numbers, symmetry)
let storage = new DragFrame[1] --- in memory.heap catch failure:
made.close()
error(failure.code, failure.message)
storage[0] = made
return try interop.Reference[DragFrame].adopt(storage.data, drag_frame_type, memory.heap)
## A drag frame of `center` and `axis` alone (no rails), for a tool that
## is no verb: a CAD tool's drag measured on its pick geometry.
pub static func frame_at(center: Vector3, axis: Vector3) -> interop.Reference[DragFrame]!:
let storage = try new DragFrame[1] --- in memory.heap
storage[0] = DragFrame.of(center, axis)
return try interop.Reference[DragFrame].adopt(storage.data, drag_frame_type, memory.heap)
## Whether verb `name` run on `group` of `mesh` alone still wants its
## second pick (Bridge given one loop; Target Weld).
pub static func wants_second(name: str, mesh: interop.Reference[Mesh], group: str, group_type: i64, numbers: const f64[]) -> bool!:
let verb = find_verb(name) else error(errors.invalid, "unknown operation")
return try verb_wants_second(&verb, try mesh.get(), group, group_type, numbers)
## The inputs its node has: 0 (a primitive), 1, or 2 (a reference
## surface second, required when `second_required`).
pub static func inputs(index: i64) -> i64:
return (i64)verb_at(checked(index)).inputs
pub static func second_required(index: i64) -> bool:
return verb_at(checked(index)).second_required
# How the "create" gesture sets a primitive's rows (Verb.place).
## "rect", "radius", or "" for a verb that is no primitive.
pub static func place_base(index: i64) -> str:
let place = verb_at(checked(index)).place else return ""
return place.base
## The parameter the base sets, the one the rise sets (-1: none) and its
## component, how the rise moves ("height" or "radius"), and the
## Position and Up parameters.
pub static func place_size(index: i64) -> i64:
return place_of(index).size
pub static func place_rise(index: i64) -> i64:
return place_of(index).rise
pub static func place_rise_component(index: i64) -> i64:
return place_of(index).rise_component
pub static func place_rise_mode(index: i64) -> str:
return place_of(index).rise_mode
pub static func place_position(index: i64) -> i64:
return place_of(index).position
pub static func place_up(index: i64) -> i64:
return place_of(index).up
## Its Name piece parameter (after Up and Turn), which Edit Mesh's
## steps turn on.
pub static func place_piece(index: i64) -> i64:
return place_of(index).up + 2
## Axis `axis` (0 X, 1 Y, 2 Z) of the frame a primitive standing along
## `up`, turned `degrees` about it, is built in (primitives/placement.lucb):
## the viewport draws a base in it.
pub static func placement_axis(up: Vector3, degrees: f64, axis: i64) -> Vector3!:
let frame = try placement(Vector3(), up, degrees)
if axis == 0: return frame.x
if axis == 1: return frame.y
return frame.z
## The boundary edge of `mesh` nearest `point` (-1: none), for Poly
## Pen's Ctrl-click: the edge it extends to the click.
pub static func nearest_boundary_edge(mesh: interop.Reference[Mesh], point: Vector3) -> i64!:
return try boundary_edge_near(try mesh.get(), point)
## The cage of the Lattice run that made `mesh`, moved as its numbers
## `numbers` say: the viewport draws its points over the result and
## drags them.
pub static func lattice(mesh: interop.Reference[Mesh], numbers: const f64[]) -> interop.Reference[LatticeCage]!:
let source = try mesh.get()
var made = LatticeCage()
made.cage = try cage_on(source, numbers)
made.origin = source.position_origin()
let storage = new LatticeCage[1] --- in memory.heap catch failure:
made.close()
error(failure.code, failure.message)
storage[0] = made
return try interop.Reference[LatticeCage].adopt(storage.data, lattice_cage_type, memory.heap)
## The Mesh Check overlay's findings on `mesh` (Intersecting faces only
## with `intersecting`), degenerate within `tolerance`.
pub static func mesh_check(mesh: interop.Reference[Mesh], tolerance: f64 = 0.000001, intersecting: bool = true) -> interop.Reference[MeshReport]!:
var made = try mesh_report(try mesh.get(), tolerance, intersecting)
let storage = new MeshReport[1] --- in memory.heap catch failure:
made.close()
error(failure.code, failure.message)
storage[0] = made
return try interop.Reference[MeshReport].adopt(storage.data, mesh_report_type, memory.heap)
## Its viewport gesture: "", "stroke", "place", "hover" or "knife".
pub static func gesture(index: i64) -> str:
return verb_at(checked(index)).gesture
## Whether it runs on everything with nothing selected.
pub static func whole(index: i64) -> bool:
return verb_at(checked(index)).whole
## A Select verb's group function ("loop": `loop(group, …)` in a
## node's Group), or "".
pub static func function(index: i64) -> str:
let verb = verb_at(checked(index))
return rule_at((usize)verb.rule).function if verb.rule >= 0 else ""
## Run verb `name` on `mesh`: `group` (empty: everything) read on
## `group_type`'s domain (0 guess, 1 points, 2 edges, 3 faces,
## 4 corners), the parameter values in order.
## `symmetry` mirrors the group across X, Y or Z (1..3); `keep` selects
## the group carried through the verb instead of what it made; `second`
## is the second pick's group (Bridge's second loop), read on the
## domain its levels name; `reference` the surface a verb of two inputs
## reads (Shrinkwrap's target).
## `over`: a mesh the result may be made over when it differs from it
## only in positions (a drag's last frame; see finish).
pub static func run(name: str, mesh: interop.Reference[Mesh], group: str, group_type: i64, numbers: const f64[], symmetry: i64 = 0, keep: bool = false, second: str = "", reference: interop.Reference[Mesh]? = none, over: interop.Reference[Mesh]? = none) -> interop.Reference[VerbResult]!:
let verb = find_verb(name) else error(errors.invalid, "unknown operation")
var surface: const Mesh*? = none
if let given = reference: surface = try given.get()
var last: const Mesh*? = none
if let given = over: last = try given.get()
var product = try run_verb(&verb, try mesh.get(), group, group_type, numbers, symmetry, keep, second, surface, last)
let storage = new VerbResult[1] --- in memory.heap catch failure:
product.close()
error(failure.code, failure.message)
storage[0] = VerbResult(product)
return try interop.Reference[VerbResult].adopt(storage.data, verb_result_type, memory.heap)
func checked(index: i64) -> usize:
if index < 0 or (usize)index >= verb_count(): trap("verb index out of range")
return (usize)index
func pick_of(index: i64, pick: i64) -> PickSpec:
let verb = verb_at(checked(index))
if pick < 0 or (usize)pick >= verb.picks.length: trap("verb pick out of range")
return verb.picks[(usize)pick]
func place_of(index: i64) -> PlaceSpec:
let verb = verb_at(checked(index))
let place = verb.place else trap("the verb is no primitive")
return place
func key_of(index: i64, key: i64) -> KeySpec:
let verb = verb_at(checked(index))
if key < 0 or (usize)key >= verb.keys.length: trap("verb key out of range")
return verb.keys[(usize)key]
func parm_of(index: i64, parm: i64) -> ParmSpec:
let verb = verb_at(checked(index))
if parm < 0 or (usize)parm >= verb.parms.length: trap("verb parameter out of range")
return verb.parms[(usize)parm]
## What a run made: its mesh, its output selection and its warning.
pub struct VerbResult:
var run: VerbRun
## The output mesh.
pub func mesh() -> interop.Reference[Mesh]!:
return try mesh_adopt(try mesh_share(self.run.mesh))
## The components the verb made or moved, on the output mesh.
pub func selection() -> interop.Reference[Selection]!:
let guard = (u64)self.run.mesh.topology_hash()
return try adopt_selection(self.run.selection.share(), self.run.selection_count, self.run.selection_domain, guard, GroupReport())
## The warning for the node's info line, or "".
pub func warning() -> str:
return self.run.warning
## Numbers in the group that named no element.
pub func misses() -> i64:
return (i64)self.run.misses
## Release the run's mesh and selection.
pub func close():
self.run.close()
## VerbResult's interop type.
pub let verb_result_type: interop.Type[VerbResult] = interop.Type[VerbResult]("VerbResult", VerbResult.close, closeable = true)