Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.8

0.7.8 / 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)