Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.9

0.11.9 / src / parameter_rows.luc

## A parameter row (Houdini's parameter templates): what a node's pane,
## and the viewport's tool bar, show for one value or text slot, with the
## builders node_catalog and the Edit kinds describe their rows by.
from luce_ui.ui import ParameterSpec, ParameterKind, Unit

## One row of a node's parameter pane. `slot` is the first value slot (a
## vector's components take the slots after it) or, for text rows, the text slot.
pub class Parameter:
    pub let name: str
    pub let slot: int
    pub let initial: float
    pub let minimum: float
    pub let maximum: float
    pub let step: float
    pub let integer: bool
    pub let decimals: int
    ## number, integer, vector, toggle, menu, text, path (a file), node (a
    ## node path, node_paths.luc), button, info, folder, separator, color.
    pub var kind: str = "number"
    ## The name conditions and scripts use; the label, lower-cased, when not given.
    pub var key: str = ""
    pub var components: int = 1
    ## A vector's or color's defaults after the first.
    pub var rest: list[float]
    pub var items: str = ""
    pub var suffix: str = ""
    pub var doc: str = ""
    pub var hide_when: str = ""
    pub var disable_when: str = ""
    pub var slider: bool = false
    pub var soft_maximum: float = 0.0
    pub var join: bool = false
    pub var text: str = ""
    ## A length (millimeters), shown and typed in the document's unit.
    pub var length: bool = false
    ## A node path row: the nodes it may name (node_paths.fits), whether *
    ## and ? may name several, and whether a take records it (takes.luc).
    pub var targets: str = ""
    pub var patterns: bool = false
    pub var recorded: bool = false
    ## Whether an Edit node's step shows the row in its tool bar (a node's
    ## own choices, such as a Rule fillet's rule, are not a step's).
    pub var in_steps: bool = true
    ## A folder heading: whether it starts open (More options starts shut).
    pub var open: bool = true

    ## The pane's description of this row (lengths in `shown`).
    pub func spec(self, shown: Unit) -> ParameterSpec:
        return spec_of(self, shown)

    pub func init(self, name: str, slot: int, initial: float, minimum: float = -1000.0, maximum: float = 1000.0, step: float = 0.1, integer: bool = false, decimals: int = 3):
        self.name = name
        self.slot = slot
        self.initial = initial
        self.minimum = minimum
        self.maximum = maximum
        self.step = step
        self.integer = integer
        self.decimals = 0 if integer else decimals
        self.rest = []

    ## Whether the row keeps numbers in value slots (not text, buttons or headings).
    pub func valued(self) -> bool:
        return self.kind in ["number", "integer", "vector", "toggle", "menu", "color"]

    ## Whether it is a ramp kept in value slots (a verb's ramp parameter,
    ## Bevel's Custom profile): `components` slots from `slot`, the ramp's
    ## numbers first (luce-std ramp's flat form), the rest unused.
    pub func value_ramp(self) -> bool:
        return self.kind == "ramp" and self.components > 1

# -- Row builders.

## A float, `doc` its tooltip; a slider when `slider` (to `soft` when the hard maximum is far).
pub func number(label: str, slot: int, initial: float, minimum: float = -1000.0, maximum: float = 1000.0, step: float = 0.1,
            doc: str = "", slider: bool = false, soft: float = 0.0, decimals: int = 3, suffix: str = "") -> Parameter:
    let parameter = Parameter(label, slot, initial, minimum, maximum, step, decimals = decimals)
    parameter.doc = doc
    parameter.slider = slider
    parameter.soft_maximum = soft
    parameter.suffix = suffix
    parameter.length = is_length(label)
    return parameter

## The rows that are lengths, by label: kept in millimeters and shown in the
## document's unit. Lens values (focal length, apertures) stay plain.
pub func is_length(label: str) -> bool:
    return label in ["Radius", "Size", "Height", "Width", "Translate", "Tube", "Tube radius", "Top radius", "Target edge", "Spacing", "Soft radius",
                     "Position", "Pivot", "Offset", "Near clip", "Far clip", "Focus distance", "Longest side", "Distance"]

pub func whole(label: str, slot: int, initial: float, minimum: float, maximum: float, doc: str = "", slider: bool = false) -> Parameter:
    let parameter = Parameter(label, slot, initial, minimum, maximum, 1.0, true)
    parameter.kind = "integer"
    parameter.doc = doc
    parameter.slider = slider
    return parameter

## Components on one row, in `slot` and the slots after it.
pub func vector(label: str, slot: int, defaults: list[float], doc: str = "", minimum: float = -1000.0, maximum: float = 1000.0, suffix: str = "") -> Parameter:
    let parameter = Parameter(label, slot, defaults[0], minimum, maximum)
    parameter.kind = "vector"
    parameter.components = defaults.length
    for component in 1..<defaults.length:
        parameter.rest.append(defaults[component])
    parameter.doc = doc
    parameter.suffix = suffix
    parameter.length = is_length(label)
    return parameter

pub func toggle(label: str, slot: int, initial: float, doc: str = "") -> Parameter:
    let parameter = Parameter(label, slot, initial, 0.0, 1.0, 1.0, true)
    parameter.kind = "toggle"
    parameter.doc = doc
    return parameter

## A choice of `items` (`label` or `label=value`, `|` between); its value is the item's.
pub func menu(label: str, slot: int, items: str, initial: float, doc: str = "") -> Parameter:
    var highest = 0.0
    var index = 0
    for item in items.split("|"):
        let parts = item.split("=")
        let value = float(index)
        highest = larger(highest, value if parts.length < 2 else parse_number(parts[1]))
        index += 1
    let parameter = Parameter(label, slot, initial, 0.0, highest, 1.0, true)
    parameter.kind = "menu"
    parameter.items = items
    parameter.doc = doc
    return parameter

## A float ramp kept in `capacity` value slots from `slot`, starting as
## `defaults` (a ramp's numbers; the slots past them are 0).
pub func ramp_values(label: str, slot: int, capacity: int, defaults: list[float], doc: str = "") -> Parameter:
    let parameter = Parameter(label, slot, defaults[0] if defaults.length > 0 else 0.0, -1.0e9, 1.0e9)
    parameter.kind = "ramp"
    parameter.components = capacity
    for at in 1..<capacity:
        parameter.rest.append(defaults[at] if at < defaults.length else 0.0)
    parameter.doc = doc
    return parameter

## A value ramp's numbers among `values` (its slots): the ramp's own, cut
## to the size its header gives (none when there is no ramp).
pub func ramp_numbers(values: list[float]) -> list[float]:
    if values.length < 3 or values[0] != 1.0:
        return []
    let size = 3 + int(values[2]) * (int(values[1]) + 2)
    return values[..<size] if size <= values.length else []

## A ramp's numbers padded with 0 to `capacity` value slots.
pub func padded(numbers: list[float], capacity: int) -> list[float]:
    let result: list[float] = []
    for at in 0..<capacity:
        result.append(numbers[at] if at < numbers.length else 0.0)
    return result

## A line of text in text slot `slot`.
pub func entry(label: str, slot: int, doc: str = "", kind: str = "text") -> Parameter:
    let parameter = Parameter(label, slot, 0.0)
    parameter.kind = kind
    parameter.doc = doc
    return parameter

## A path to another node in text slot `slot` (node_paths.luc), naming the
## nodes `targets` allows; the row's button opens the node path picker.
pub func node_path(label: str, slot: int, doc: str, targets: str, patterns: bool = false) -> Parameter:
    let parameter = entry(label, slot, doc, "node")
    parameter.targets = targets
    parameter.patterns = patterns
    return parameter

pub func heading(label: str, kind: str = "folder") -> Parameter:
    let parameter = Parameter(label, -1, 0.0)
    parameter.kind = kind
    return parameter

## The folder the rows a modeler sets less often sit under, shut at first.
pub func more_options() -> Parameter:
    let folder = heading("More options")
    folder.open = false
    return folder

## A small whole number written as text ("2" in "Faces=2").
func parse_number(written: str) -> float:
    var value = 0.0
    for digit in written.trim():
        let at = "0123456789".index_of(digit) else return value
        value = value * 10.0 + float(at)
    return value

func larger(a: float, b: float) -> float:
    return a if a > b else b

## The panel's description of a catalog row.
func spec_of(row: Parameter, shown: Unit) -> ParameterSpec:
    let rest = row.rest + [0.0, 0.0, 0.0]
    let soft = row.soft_maximum > 0.0
    return ParameterSpec(name = row.key if row.key != "" else row.name.lower().replace(" ", "_"), label = row.name, kind = kind_of(row.kind),
                         components = 1 if row.kind in ["ramp", "color_ramp"] else row.components, value = row.initial, y = rest[0], z = rest[1], w = rest[2],
                         minimum = row.minimum, maximum = row.maximum, soft_minimum = (row.minimum if row.minimum >= 0.0 else -row.soft_maximum) if soft else 0.0,
                         soft_maximum = row.soft_maximum, step = row.step, decimals = row.decimals, suffix = row.suffix, slider = row.slider or soft,
                         items = row.items, doc = row.doc, hide_when = row.hide_when, disable_when = row.disable_when, join = row.join,
                         linear = row.kind == "color", tag = row.slot, units = shown if row.length else Unit(), open = row.open)

func kind_of(name: str) -> ParameterKind:
    if name == "integer":
        return ParameterKind.integer
    if name == "vector":
        return ParameterKind.vector
    if name == "toggle":
        return ParameterKind.toggle
    if name == "menu":
        return ParameterKind.menu
    if name == "text":
        return ParameterKind.text
    if name == "path" or name == "node":
        return ParameterKind.path
    if name == "button":
        return ParameterKind.button
    if name == "info":
        return ParameterKind.info
    if name == "folder":
        return ParameterKind.folder
    if name == "separator":
        return ParameterKind.separator
    if name == "color":
        return ParameterKind.color
    if name == "ramp":
        return ParameterKind.ramp
    if name == "color_ramp":
        return ParameterKind.color_ramp
    return ParameterKind.number