Monocurl
std.mesh
Reference for the symbols exported by mesh.mcl.
A circle centered at the origin in the XY plane. Apply stroke or fill operators to style it, and shift to reposition.
let Circle = |radius, samples = 64| ...samples | number of line segments used to approximate the curve (default 64) |
mesh c = stroke{CYAN} Circle(1.5)A square centered at the origin with sides parallel to the axes.
let Square = |width| ...mesh box = fill{alpha{0.2} ORANGE} stroke{ORANGE} Square(1.1)An axis-aligned rectangle centered at the origin.
let Rect = |size| ...size | [width, height] |
mesh card = fill{alpha{0.12} BLUE} stroke{BLUE} Rect([2.0, 0.8])A directed arrow from start to end, with an arrowhead at the tip.
path_arc bends the shaft by rotating along a circular arc instead of a straight segment. Its sign is relative to normal; use 0 for a straight arrow.
let Arrow = |start = [0, 0, 0], end = [1, 0, 0], normal = 1b, path_arc = 0| ...start | tail position, default origin |
end | tip position, default [1, 0, 0] |
normal | preferred plane normal for the arrow body |
path_arc | signed arc angle in radians, default 0 |
mesh curved = color{ORANGE} Arrow(1.2l, 1.2r, 1b, PI / 3)A single point in 3-D space, rendered as a viewport-facing dot.
Unlike most line/surface primitives, Dot has a visible default radius; topology dots created internally by other constructors are invisible unless styled.
let Dot = |point = [0, 0, 0]| ...mesh p = fill{CYAN} Dot([1, 0, 0])A filled annulus between two concentric circles in the XY plane.
The inner loop is authored as a hole, so fill/stroke operators style the ring as one surface with a boundary.
let Annulus = |inner, outer| ...mesh ring = fill{alpha{0.18} CYAN} stroke{CYAN} Annulus(0.7, 1.0)A regular n-gon inscribed in a circle of the given circumradius, centered at the origin.
let RegularPolygon = |n, circumradius| ...n | clamped to at least 3 sides |
mesh pentagon = RegularPolygon(5, 0.8)A closed polygon from an ordered list of vertices.
The vertex loop is tessellated into a filled surface. Use Polyline for an open path or downrank{} when you want only the boundary.
let Polygon = |vertices, normal_hint = 1b| ...normal_hint | preferred face orientation; defaults to 1b |
mesh poly = fill{alpha{0.2} GREEN} Polygon([LEFT, UP, RIGHT, DOWN])An open polyline through the given vertices.
let Polyline = |vertices, normal_hint = 1b| ...normal_hint | preferred stroke normal; defaults to 1b |
mesh path = stroke{TEAL, 3} Polyline([1.2l, 0.4u, 1.2r])A straight line segment between two points.
let Line = |start = [0, 0, 0], end = [1, 0, 0], normal = 1b| ...normal | preferred stroke normal, used by lighting and topology transforms |
mesh l = stroke{WHITE} Line([0,0,0], [2,1,0])Circular arc centered at the origin in the XY plane.
theta is [start_angle, end_angle] in radians. The sampled stroke includes both endpoints.
let Arc = |radius = 1, theta = [0, 3.14159265358979]| ...theta | [start, end] angles in radians |
mesh arc = stroke{CYAN} Arc(1, [0, PI])Rounded filled capsule between two cap centers.
radii may be one number for a constant-width capsule or [start_radius, end_radius] for a tapered capsule.
let Capsule = |start_center, end_center, radii = 0.4, normal = 1b| ...radii | single radius or [start_radius, end_radius] |
normal | preferred plane normal |
mesh pill = fill{alpha{0.18} BLUE} Capsule(LEFT, RIGHT, 0.25)Filled triangle from three vertices.
normal_hint controls the preferred winding/lighting side.
let Triangle = |p, q, r, normal_hint = 1b| ...normal_hint | preferred face orientation |
mesh tri = fill{alpha{0.2} PURPLE} Triangle(1l, 1r, 1u)3-D sphere centered at the origin.
sample_depth controls subdivision; higher values add triangles quickly.
let Sphere = |radius, sample_depth = 2| ...sample_depth | subdivision depth, clamped to at least 0 |
mesh globe = fill{alpha{0.2} BLUE} stroke{BLUE} Sphere(0.8)Rectangular prism centered at the origin.
let RectangularPrism = |dimensions| ...dimensions | [width, height, depth] |
Cylinder oriented along a direction.
The cylinder is centered at the origin. A zero direction falls back to the y axis.
let Cylinder = |radius, height, direction = 1u, sample_count = 32| ...sample_count | radial samples, clamped to at least 3 |
Cone from apex to base center.
let Cone = |apex = [0, 1, 0], base = [0, 0, 0], radius = 1, sample_count = 32| ...sample_count | radial samples, clamped to at least 3 |
Torus centered at the origin in the XY plane.
let Torus = |radii = [1, 0.3], samples = [48, 24]| ...radii | [major_radius, minor_radius] |
samples | [major_samples, minor_samples], each clamped to at least 3 |
Rectangular plane in the XY plane, offset along 1b.
let Plane = |dist = 0, size = [4, 4]| ...size | [width, height] |
Sample a color function over a rectangular grid.
By default each visible cell gets one flat color sampled at the cell corner. Pass smooth = 1 to color vertices for smooth interpolation, or pass a callable as the fourth argument to use it as the mask while keeping flat colors. color_at receives (pos, [ix, iy]); mask receives pos.
let ColorGrid = |color_at, x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], smooth = 0, mask = |pos| 1| ...color_at | function from cell 3d position and 2d index to RGBA color |
x_min_max_samples | [x_min, x_max, samples] |
y_min_max_samples | [y_min, y_max, samples] |
smooth | truthy for vertex color interpolation, falsey for flat cells, or a mask function |
mask | optional function deciding which positions render |
mesh heat = ColorGrid(|p, idx| hsv(norm(p) / 2, 0.7, 0.9), [-2, 2, 60], [-1, 1, 30])Build a rectangular grid of line segments.
The result is one mesh with subdivided line topology, which makes later point_map and Trans operations smoother.
let LineGrid = |x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], subdivision = 16| ...x_min_max_samples | [x_min, x_max, samples] |
y_min_max_samples | [y_min, y_max, samples] |
subdivision | subdivisions per grid segment |
mesh grid = stroke{LIGHT_GRAY} LineGrid([-2, 2, 9], [-1, 1, 5])Sample a mesh-producing function over a rectangular field.
mesh_at receives (pos, [ix, iy]); mask receives pos. Calls are batched internally, so this is the preferred way to build repeated arrows/glyphs on a grid.
let Field = |mesh_at, x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], mask = |pos| 1| ...mesh_at | function from position and index to a mesh |
x_min_max_samples | [x_min, x_max, samples] |
y_min_max_samples | [y_min, y_max, samples] |
mask | optional function deciding which subset of cells to include |
mesh arrows = Field(|p, idx| Arrow(p, p + 0.2 * normalize(p)), [-2, 2, 12], [-1, 1, 7])Bezier curve through control points, sampled as a 64-segment stroke.
With fewer than two control points this returns an empty mesh.
let Bezier = |control_points| ...mesh curve = stroke{MAGENTA, 3} Bezier([1.4l, 1u, 1.4r])Arrow-like vector from a tail by a delta.
The arrowhead and shaft proportions are adjusted for short vectors so fields stay legible.
let Vector = |delta = 1r, tail = [0, 0, 0], normal = 1b| ...mesh v = color{CYAN} Vector(0.8r + 0.4u, ORIGIN)Simple line segment from tail to tail + delta.
Use this for dense fields when arrowheads would clutter the scene.
let HalfVector = |tail = [0, 0, 0], delta = 1r, normal = 1b| ...Place a bundled or project image into the scene.
The image is rendered as a textured upright rectangle in the XY plane. name may be a bundled asset name or a project-relative path resolved by the runtime. Not available in web runtimes yet.
let Image = |name, center = [0, 0, 0], size = [1, 1]| ...name | image asset name or path, relative to the currently invoked scene or library |
center | image center |
size | [width, height] |
mesh logo = Image("monocurl.png", ORIGIN, [1.2, 1.2])Import an SVG file into mesh geometry.
filename should be a project-relative .svg file path, passed as a string such as "icons/play.svg" rather than pasted raw SVG markup. File imports resolve supported relative SVG references from the SVG file's folder. The importer handles ordinary solid-color fills and strokes best; unsupported SVG features such as gradients, filters, masks, and raster images may be ignored. SVG coordinates are y-down, so imported geometry is flipped into Monocurl's y-up scene space. At scale = 1, 100 SVG units map to 1 scene unit. Not available in web runtimes yet.
let Svg = |filename, scale = 1| ...filename | project-relative .svg file path |
scale | scene scale where 100 SVG units equal scale scene units |
mesh icon = Svg("icons/play.svg", 1.2)Plain text converted to mesh geometry.
Use Text for literal text. It still returns mesh geometry, so Write, Fade, tag_filter, and styling operators all apply. With the default font = nil, text is rendered through the existing LaTeX backend. Passing a string such as "Arial" uses system-font SVG outlines instead; a .ttf, .otf, .ttc, or .otc path is resolved relative to the scene file. Custom/system/font-file text fonts are not available in web runtimes yet; keep font = nil there. Apply text_tag{...} inside the text argument when only part of the rendered text should be addressable; apply tag{...} outside Text when the whole rendered label should share one identity. String escapes use %, not \: write %" for a quote, %% for a literal percent sign, and LaTeX-style backslashes directly.
let Text = |text, scale = 1, font = nil| ...text | string/list text fragments; use text_tag{...} on fragments that need stable mesh tags after rendering |
font | nil for the existing LaTeX-backed renderer, or a system font family / font file path for direct SVG font outlines |
mesh title = center{UP} Text("Monocurl", 0.8)Math text converted through TeX into mesh geometry.
Tex accepts a raw TeX string or a list of string-compatible fragments. Fragments wrapped in text_tag{...} become tagged mesh contours after rendering, which makes individual terms usable with tag_filter, filtered styling, TagTrans, and subset-transfer animations. Raw TeX can also contain \text_tag{1,2}{...} or shorthand wrappers like \tag2{...}. Monocurl strings escape with %, not \, so LaTeX commands can usually be written directly, such as "\frac{a}{b}"; use %% when the string itself needs a percent character.
let Tex = |tex, scale = 1| ...tex | TeX math fragment, string/list text fragments, or text_tag{...} fragments |
scale | text scale in scene units |
mesh eq = Tex([text_tag{1} "a^2", " + ", text_tag{2} "b^2", " = ", text_tag{3} "c^2"], 0.8)
mesh raw = Tex("\tag1{a^2} + \tag2{b^2} = \tag3{c^2}", 0.8)
mesh word = Tex("\tag1{text} + \tag2{more}", 0.8)Measurement marker drawn next to a target mesh.
Builds a stroke spanning the target's bounds perpendicular to dir, offset by buffer.
let Measure = |target, dir = 1d, buffer = 0.15| ...mesh width = [seg, Measure(seg, DOWN), Label(seg, "w", DOWN)]Full LaTeX fragment converted into mesh geometry.
Use this when the input needs ordinary LaTeX body structure beyond display math; use Tex for ordinary displayed math. additional_preamble is inserted before \begin{document}, which is useful with the system backend for packages and font setup such as \usepackage{fontspec}. Latex supports the same text tagging markers as Tex, so \text_tag{...}{...}, \tag2{...}, and text_tag{...} fragments all become ordinary mesh tags after rendering. Not available in web runtimes yet; use Text or Tex for browser-compatible MathJax rendering.
let Latex = |latex, scale = 1, additional_preamble = ""| ...latex | LaTeX body content, string/list text fragments, or text_tag{...} fragments |
scale | text scale in scene units |
additional_preamble | extra LaTeX declarations inserted before \begin{document} |
Attach tags to text fragments before they become mesh contours.
Use text tags for equation transforms and selective coloring inside Text, Tex, and Latex. The tag can be an integer or a list of integers; the wrapper lowers to the LaTeX \text_tag{...}{...} marker before rendering. The rendered contours from that fragment then carry the requested tag list, just as if they had been tagged with tag{...} after they became meshes. Place text_tag{...} inside the text constructor for fragment-level identity. Place tag{...} outside the text constructor only when the entire rendered text mesh should share one identity. Raw TeX strings can use \text_tag{1,2}{...} or the numbered shorthand \tag2{...} directly. Nested text tags are allowed; the innermost tag owns the overlapping contours.
let text_tag = operator |target, tag| ...target | string-compatible text fragment to tag before rendering |
tag | integer tag or list of integer tags; [] is allowed for an explicitly empty tag list |
mesh eq = Tex([text_tag{1} "x", " + ", text_tag{[2, 10]} "1"], 0.8)
mesh highlighted = color{ORANGE, |tags| 2 in tags} eq
let term_palette = operator |target|
color{BLUE, |tags| 1 in tags}
color{ORANGE, |tags| 2 in tags}
color{MAGENTA, |tags| 3 in tags}
target
mesh raw = term_palette{} Tex("\tag1{x^2} + \tag2{2x} + \tag3{1}", 0.8)
mesh label = term_palette{} Text([text_tag{1} "left", " / ", text_tag{2} "right"], 0.5)
mesh raw_label = term_palette{} Text("\tag1{text} / \tag2{label}", 0.5)Brace drawn next to a target mesh.
Reserved wrapper; the native implementation is not complete yet. Prefer Measure plus Label for current scenes.
let Brace = |target, dir = 1d, buffer = 0.15| ...Text label placed relative to a target mesh.
The label is rendered as text, then placed outside the target in dir while staying centered on the target's orthogonal direction. Pass font as a system font name or font filename to use direct font outlines instead of the default LaTeX renderer.
let Label = |target, str, dir = 1u, scale = 1, buffer = 0.1, font = nil| ...buffer | distance from target |
font | optional system font name or font filename; custom fonts are native-only and are not available on web |
mesh labeled = [seg, Label(seg, "length", UP)]Number rendered as text with optional formatting.
With decimal_places = nil, formatting uses compact %g-style output. Set include_sign truthy for a leading plus sign on positive values.
let Number = |value, decimal_places = nil, include_sign = 0| ...decimal_places | optional fixed decimal count |
include_sign | include plus sign for positive values |
mesh n = Number(value, 2, 1)Pre-fill axis options on an axis constructor.
This is a configuration operator; compose it before Axis1d, Axis2d, or Axis3d. It uses set_default internally, so axis settings interpolate cleanly when the axis is animated.
let axis_style = operator |target, axis, min, max, axis_title = nil, tick_spacing = 0.25, major_tick_rate = 4, label_map = (|x| x), arrow_extrusion = 0.2| ...axis | "x", "y", or "z" |
tick_spacing | distance between ticks in axis coordinates |
major_tick_rate | every nth tick is drawn/labelled as major |
label_map | function from value to tick label |
arrow_extrusion | arrowhead length in scene units |
mesh axes = axis_style{"x", 0, 4, "x"} axis_style{"y", 0, 3, "y"} Axis2d()Two-dimensional coordinate axes, optionally with grid lines.
basis gives the scene-space x/y unit vectors for the graph. Use grid_color to draw grid lines; leave it nil for ticks only.
let Axis2d = |basis = [1r, 1u], color = [0, 0, 0, 1], grid_color = nil, x_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2], y_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2]| ...
mesh axes = axis_style{"x", -2, 2, "x"} axis_style{"y", -1, 3, "f(x)"} Axis2d()Sample y = f(x) as a polyline in the XY plane.
Endpoints are included. Use in_space{...} to embed the graph into a custom axes coordinate system.
let ExplicitFunc = |f, x_min_max_samples = [-5, 5, 128]| ...
mesh graph = stroke{CYAN} ExplicitFunc(|x| sin(x), [-PI, PI, 160])One-dimensional axis mesh along a basis vector.
Usually configured through axis_style{"x", ...} rather than by manually editing the compact x_axis style list.
let Axis1d = |basis = 1r, normal = 1b, color = [0, 0, 0, 1], x_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2]| ...Three-dimensional coordinate axes, optionally with grid lines.
label_up controls how tick labels and titles are oriented per axis; pass three up vectors when default text orientation is not readable from the active camera.
let Axis3d = |basis = [1r, 1u, 1b], color = [0, 0, 0, 1], grid_color = nil, label_up = [1u, 1u, 1b], x_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2], y_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2], z_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2]| ...mesh axes = axis_style{"z", 0, 2, "z"} Axis3d(label_up: [1u, 1u, 1b])Polar coordinate axis mesh.
theta and radius are [min, max, unit, tick_step]; radius values are clamped to non-negative.
let PolarAxis = |center = [0, 0, 0], theta = [-5, 5, 1, 1], radius = [0, 5, 1, 1]| ...Sample a 3-D parametric curve function.
The function receives t and must return a 3-D point. Endpoints are included.
let ParametricFunc = |f, t_min_max_samples = [0, 1, 64]| ...t_min_max_samples | [t_min, t_max, samples] |
mesh spiral = stroke{CYAN} ParametricFunc(|t| [cos(t), sin(t), t / TAU], [0, TAU * 3, 180])Sample z = f(x, y) as a 3-D surface.
The function receives (x, y) and returns z. The domain lists are [min, max, samples].
let ExplicitFunc2d = |f, x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21]| ...mesh surface = ExplicitFunc2d(|x, y| x * x + y * y, [-1, 1, 31], [-1, 1, 31])Sample an implicit 2-D contour around f(x, y) <= 0.
Uses a padded rectangular sign grid and extracts the boundary of the non-positive region as linked stroke loops; increase sample counts for sharper features.
let ImplicitFunc2d = |f, x_min_max_samples = [-1, 1, 65], y_min_max_samples = [-1, 1, 65]| ...mesh level = stroke{CYAN} ImplicitFunc2d(|x, y| x * x + y * y - 1)Fill the signed area between two explicit functions.
Returns two tagged filled regions, one for where f is below g and one for where it is above. This is useful for shaded inequalities or visualizing approximation error.
let ExplicitFuncDiff = |f, g, x_min_max_samples = [-5, 5, 128], fills = [[0.3, 0.8, 0.3, 0.5], [0.8, 0.3, 0.3, 0.5]], tags = [[], []]| ...x_min_max_samples | [x_min, x_max, samples] |
fills | [lower_fill, upper_fill] |
tags | tags assigned to the two filled regions |
mesh diff = ExplicitFuncDiff(|x| sin(x), |x| 0, [-PI, PI, 160])Lay meshes out in a line along a direction.
Items are placed touching along dir with a small built-in gap. align_dir can pin one side of each item to a common line.
let Stack = |meshes, dir, align_dir = [0, 0, 0]| ...align_dir | optional direction whose extreme edge should be aligned |
mesh row = XStack([Circle(0.2), Square(0.4), Text("x")])Stack meshes along the x axis.
let XStack = |meshes, align_dir = [0, 0, 0]| Stack(meshes, 1r, align_dir)Stack meshes along the y axis.
let YStack = |meshes, align_dir = [0, 0, 0]| Stack(meshes, 1u, align_dir)Stack meshes along the z axis.
let ZStack = |meshes, align_dir = [0, 0, 0]| Stack(meshes, 1b, align_dir)Return a nested mesh list unchanged for grid-style grouping.
Currently this is a semantic wrapper around nested mesh lists; it does not auto-position cells.
let Grid = |mesh_array| ...Return a nested mesh list unchanged for table-style grouping.
Currently aliases Grid.
let Table = |mesh_array| ...Rectangle around the visible bounds of a mesh.
Builds a filled rectangle in the XY plane at the target bounds' z value. Style it with fill{CLEAR}/stroke{...} for an outline.
let BoundingBox = |target, buffer = 0.1| ...mesh boxed = [label, fill{CLEAR} stroke{CYAN} BoundingBox(label, 0.08)]Translate a mesh by a vector.
Most primitive constructors are authored at the origin; shift is the lightweight way to place them without changing their local parameters.
let shift = operator |target, delta, filter = nil| ...filter | optional tag predicate applied to mesh leaves |
mesh moved = shift{2r + 1u} Circle(0.4)Set stroke color and optional stroke width.
If stroke_width is nil, existing stroke widths are preserved. When you need a filter and no width change, call stroke{color, nil, filter}.
let stroke = operator |target, color, stroke_width = nil, filter = nil| ...stroke_width | optional width; nil preserves existing width |
filter | optional tag predicate |
mesh outline = fill{CLEAR} stroke{CYAN, 2} Circle(1)Set fill color.
Applies to filled surfaces and dots; use color{...} when you want to recolor fill, stroke, and dots together.
let fill = operator |target, color, filter = nil| ...filter | optional tag predicate |
mesh disk = fill{alpha{0.2} BLUE} Circle(1)Recolor both fill and stroke where applicable.
Useful for fading a whole mesh tree into a muted state without separately touching fill and stroke.
let color = operator |target, color, filter = nil| ...mesh muted = color{LIGHT_GRAY, |tags| not (2 in tags)} groupReplace mesh tags, optionally filtered by existing tags.
Tags are stable identities for filters and tag-aware animations. A scalar tag becomes a one-element tag list; a list can give one mesh several identities. Use tag{...} after construction for whole mesh leaves. For text/Tex/LaTeX fragments, prefer text_tag{...} inside the constructor so only the generated contours for that fragment receive the tag.
let tag = operator |target, tag, filter = nil| [target, __monocurl__native__ op_retagged(target, |old| ...mesh pair = [tag{1} Circle(0.3), tag{2} Square(0.4)]Map every point of a mesh through a function.
The callback receives a 3-D point and should return a 3-D point. Callback invocations are batched internally for mesh-sized transforms.
let point_map = operator |target, f, filter = nil| ...mesh lifted = point_map{|p| [p[0], p[1], p[0] * p[0]]} LineGrid()Move a mesh so its center lies at a point.
Centers by bounding-box center, not by centroid.
let center = operator |target, center, filter = nil| ...mesh title = center{1.2u} Text("Title", 0.8)Move a mesh near one side of the camera frame.
Placement is camera-aware, so to_side{UP} means the top of the rendered frame rather than global +y when a camera is supplied.
let to_side = operator |target, dir = [0, 0, 0], buffer = 0.1, camera = nil, filter = nil| ...dir | side direction, such as 1u or 1d |
buffer | distance from the side |
camera | optional camera, default current camera |
mesh caption = to_side{DOWN, 0.2} Text("caption", 0.5)Move a mesh near a corner of the camera frame.
dir chooses the corner by signs, for example UP + RIGHT or [1, 1, 0].
let to_corner = operator |target, dir = [1, 1, 0], buffer = 0.1, camera = nil, filter = nil| ...mesh badge = to_corner{UP + RIGHT, 0.2} Text("1")Place a mesh next to a reference mesh.
Like matched_edge, but adds buffer spacing between the two bounding boxes.
let next_to = operator |target, ref, dir = 1r, buffer = 0.1, filter = nil| ...buffer | gap between meshes |
mesh label = next_to{base, RIGHT, 0.2} Text("area")Keep only mesh leaves matching a tag filter.
A scalar or list filter matches leaves containing any requested tag. A predicate filter receives the full tag list for each mesh leaf, not one tag at a time. Tags produced by text_tag{...} are ordinary mesh tags here, so this can select individual text or formula fragments after rendering.
let tag_filter = operator |target, filter| ...mesh selected = tag_filter{|tags| 2 in tags} group
mesh warm_terms = tag_filter{[2, 3]} equationScale a mesh uniformly or per axis.
A scalar factor scales all coordinates. A 3-list scales x/y/z independently. Scaling is centered on the affected mesh tree's bounding-box center.
let scale = operator |target, factor = 1, filter = nil| ...factor | scalar or vector scale |
filter | optional tag predicate applied to mesh leaves |
mesh wide = scale{[2, 0.5, 1]} Circle(0.5)Rotate a mesh around an axis and optional pivot.
Rotation is interpolatable because the operator supplies identity and target rotation states to Lerp.
let rotate = operator |target, radians, axis = 1b, pivot = nil, filter = nil| ...axis | rotation axis, default 1b |
pivot | optional point to rotate around; defaults to the affected mesh tree's bounding-box center |
mesh spun = rotate{PI / 4, 1b} Square(1)Multiply mesh opacity by an opacity value.
This scales existing alpha channels; it does not replace them.
let fade = operator |target, opacity, filter = nil| ...Set dotted stroke color.
Dots are rendered at line vertices; this is separate from dashed, which rewrites line geometry into dash segments.
let dotted = operator |target, color, filter = nil| ...Override the normal hint used for rendering or strokes.
This changes normal hints on dots and lines. It is useful after custom geometry mapping if lighting or stroke orientation looks wrong.
let normal_hint = operator |target, normal, filter = nil| ...Apply an image texture to a mesh.
Usually used by Image; applying it manually expects the mesh to have meaningful UV coordinates. Not available in web runtimes yet.
let textured = operator |target, image, filter = nil| ...Assign a draw ordering hint to a mesh.
Higher z-index values draw later among otherwise comparable meshes.
let z_index = operator |target, z_index, filter = nil| ...Add glossy lighting amount to a mesh.
Mainly visible on filled 3-D surfaces.
let gloss = operator |target, amount = 0.5, filter = nil| ...Map mesh colors through a function.
The callback receives an RGBA color and should return an RGBA color.
let color_map = operator |target, f, filter = nil| ...Map mesh UV coordinates through a function.
The callback receives a UV pair and should return a UV pair; mostly useful for textured meshes.
let uv_map = operator |target, f, filter = nil| ...Map mesh tags through a function.
The callback receives the full tag list for each mesh leaf and should return a replacement tag or tag list.
let tag_map = operator |target, f| ...Apply a mapping function only to tag-filtered subsets.
The filter selects mesh leaves by their tag list; the mapper receives each selected leaf as a mesh value and should return the replacement mesh.
let subset_map = operator |target, filter, f| ...mesh emphasized = subset_map{|tags| 2 in tags, |m| scale{1.2} m} groupPromote lower-dimensional topology into higher-dimensional topology.
uprank turns point chains into line segments and closed line contours into tessellated filled surfaces. It is useful before operations that expect surfaces, such as extrude, or when a closed outline should become fillable.
let uprank = operator |target, filter = nil| ...mesh disk = fill{alpha{0.16} CYAN} uprank{} Polyline([1l, 1u, 1r, 1d, 1l])Demote higher-dimensional topology into lower-dimensional topology.
downrank turns surfaces into boundary strokes and strokes into endpoint dots. Use it for outlines/wire geometry, or to expose a filled shape's boundary for stroke-only proofs and construction diagrams.
let downrank = operator |target, filter = nil| ...mesh outline = stroke{WHITE} fill{CLEAR} downrank{} Rect([2, 1])Convert surface-like geometry to wireframe display.
Alias for downrank.
let wireframe = operator |target, filter = nil| ...Convert strokes to dashed strokes.
Rewrites line geometry into dash segments while preserving fills and dots in the same mesh tree. A scalar lengths value uses the same dash and gap length.
let dashed = operator |target, lengths = [0.2, 0.1], offset = 0, filter = nil| ...lengths | dash length or [dash, gap] |
offset | phase offset |
filter | optional tag predicate |
mesh guide = dashed{[0.15, 0.08]} stroke{LIGHT_GRAY} Line(1.5l, 1.5r)Subdivide mesh geometry for smoother downstream transforms.
Adds intermediate samples to lines/surfaces without changing the intended shape. Useful before point_map, Trans, or nonlinear deformations.
let subdivide = operator |target, factor = 2, filter = nil| ...Tessellate mesh geometry to the requested depth.
Splits surface triangles repeatedly; use it before curved point_map deformations.
let tesselated = operator |target, depth = 1, filter = nil| ...Extrude a mesh by a delta vector.
Builds side walls from surface boundaries. Standalone closed line loops must be uprank{}ed first so the extruder sees a surface.
let extrude = operator |target, delta, filter = nil| ...mesh block = extrude{0.5b} Square(1)Revolve mesh geometry around an axis rotation.
Sweeps geometry around the rotation vector; larger rotation magnitude sweeps farther around the axis.
let revolve = operator |target, rotation, filter = nil| ...Keep a mesh fixed relative to the frame while camera changes.
Remaps mesh positions from original_camera to live_camera so the mesh keeps the same apparent screen placement during camera motion. Use this for overlays, labels, and callouts that should not drift while the camera lerps.
let camera_transfer = operator |target, original_camera, live_camera, filter = nil| ...original_camera | camera used when the mesh was authored |
live_camera | current or stateful camera, often $camera |
mesh hud = camera_transfer{camera, $camera} to_side{UP} Text("fixed")Rotate a mesh tree so its local XY plane faces the camera.
Keeps the affected mesh tree's bounding-box center fixed, then interprets each vertex offset from that center in a camera-facing local basis. The local y axis follows the camera up direction projected perpendicular to the view direction, and the local x axis is chosen to preserve a right-handed local frame. Use this for labels, panels, and flat mesh trees that should turn toward the camera without changing their center.
let orient_to_camera = operator |target, camera, filter = nil| ...camera | camera to face |
mesh label = orient_to_camera{$camera} center{[1, 0, 0]} Text("A")Place one edge of a mesh against an edge of a reference mesh.
Moves the target so its -dir edge sits on the reference mesh's dir edge.
let matched_edge = operator |target, ref, dir, filter = nil| ...Project a screen-space point along a ray into mesh space.
Casts from each target point along ray and snaps to the nearest triangle hit in the screen mesh. Points that miss are unchanged.
let projected = operator |target, screen, ray = 1b, filter = nil| ...Interpret a mesh inside a local coordinate space.
Maps each point p to axis_center + x_unit * p.x + y_unit * p.y + z_unit * p.z, and remaps dot/line normal hints through the same basis. This is commonly used to build graphs in axis coordinates and then embed them into global scene coordinates.
let in_space = operator |target, axis_center = [0, 0, 0], x_unit = 1r, y_unit = 1u, z_unit = 1b, filter = nil| ...axis_center | local origin |
x_unit | local x basis |
y_unit | local y basis |
z_unit | local z basis |
let graph_space = operator |target| in_space{[-1.2, -1.0, 0], 0.45r, 0.45u} target
mesh graph = graph_space{} ExplicitFunc(|x| x * x, [0, 3, 80])Split a mesh into [matching, non_matching] by tag filter.
Useful for transfer animations and custom progressors that need to move part of a mesh tree. The filter rules match tag_filter, including text tags recovered from Text, Tex, and Latex.
let tag_split = |target, filter = nil| ...Collapse nested mesh lists into a flatter mesh.
Preserves geometry while reducing mesh-tree nesting.
let mesh_collapse = |target| ...Separate contours so morphing can treat them independently.
Flattens contour-separated leaves and tags them [0], [1], ... in output order, making later tag_filter selections deterministic.
let contour_separate = operator |target| ...Compute an intermediate Trans morph value between two meshes.
This is the pure value form behind the Trans animation. path_arc bends point paths through circular arcs; pass 0 for straight-line motion or a 3-vector whose direction chooses the arc plane and whose length is the arc angle in radians.
let trans = |start, end, t, path_arc = 0, similar_topo_hint = 0| ...path_arc | 0 or a 3-vector arc control |
similar_topo_hint | truthy to try exact topology matching first |
let halfway = trans(Square(1), Circle(0.7), 0.5, 0.6b)Compute an intermediate Bend morph value between two meshes.
Pure value form behind Bend; best for line/path geometry where local tangent rotation matters.
let bend = |start, end, t| ...Left x bound of a mesh.
let mesh_left = |target| ...Right x bound of a mesh.
let mesh_right = |target| ...Up y bound of a mesh.
let mesh_up = |target| ...Down y bound of a mesh.
let mesh_down = |target| ...Forward z bound of a mesh.
let mesh_forward = |target| ...Backward z bound of a mesh.
let mesh_backward = |target| ...Extreme bound of a mesh along a direction.
let mesh_direc = |target, direc| ...Width of a mesh bounding box.
let mesh_width = |target| ...Height of a mesh bounding box.
let mesh_height = |target| ...Center of a mesh bounding box.
let mesh_center = |target| ...Topological rank of a mesh: 0 for dots, 1 for lines, 2 for surfaces.
uprank and downrank move geometry between these ranks.
let mesh_rank = |target| ...Tags present in a mesh.
let mesh_tags = |target| ...Sample a point on a mesh at normalized position t.
Samples by authored geometry order; for multi-contour meshes, use contour_separate{} first when each contour needs its own sampling domain.
let mesh_sample = |target, t| ...Sample a normal on a mesh at normalized position t.
let mesh_normal = |target, t| ...Sample a tangent on a mesh at normalized position t.
let mesh_tangent = |target, t| ...Test whether a mesh contains a point.
Primarily meaningful for filled planar/surface geometry.
let mesh_contains = |target, point| ...Distance from a point to a mesh.
let mesh_dist = |target, test_point| ...Raycast against a mesh from a source along a direction.
Returns the closest hit point along the ray when a triangle is hit.
let mesh_raycast = |target, src, direction| ...Raw vertex set of a mesh.
Low-level topology inspection; prefer bounds and sampling helpers for ordinary layout.
let mesh_vertex_set = |target| ...Raw edge set of a mesh.
Low-level topology inspection.
let mesh_edge_set = |target| ...Raw triangle set of a mesh.
Low-level topology inspection.
let mesh_triangle_set = |target| ...Number of contours in a mesh.
let mesh_contour_count = |target| ...