Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.6

0.7.6 / 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)[51] = [
    transform_verb,
    smooth_verb,
    relax_verb,
    mountain_verb,
    peak_verb,
    flatten_verb,
    snap_verb,
    delete_verb,
    reverse_verb,
    triangulate_verb,
    quadrangulate_verb,
    extrude_verb,
    inset_verb,
    duplicate_verb,
    split_verb,
    separate_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,
    polydraw_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)

    ## 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.
    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 = "") -> interop.Reference[VerbResult]!:
        let verb = find_verb(name) else error(errors.invalid, "unknown operation")
        var product = try run_verb(&verb, try mesh.get(), group, group_type, numbers, symmetry, keep, second)
        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 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)