Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.2

0.11.2 / 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, 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

    ## 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"]

# -- 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 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

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

## 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 = 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())

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":
        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