mesh.mcl

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

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

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

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

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]| ...

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

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

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

mesh globe = fill{alpha{0.2} BLUE} stroke{BLUE} Sphere(0.8)

Rectangular prism centered at the origin.

let RectangularPrism = |dimensions| ...

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

Cone from apex to base center.

let Cone = |apex = [0, 1, 0], base = [0, 0, 0], radius = 1, sample_count = 32| ...

Torus centered at the origin in the XY plane.

let Torus = |radii = [1, 0.3], samples = [48, 24]| ...

Rectangular plane in the XY plane, offset along 1b.

let Plane = |dist = 0, size = [4, 4]| ...

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.

let Image = |name, center = [0, 0, 0], size = [1, 1]| ...

mesh logo = Image("monocurl-1024.png", ORIGIN, [1.2, 1.2])

Full LaTeX fragment converted into mesh geometry.

Use this when the input already contains document-level LaTeX structure; use Tex for ordinary displayed math.

let Latex = |latex, scale = 1| ...

Attach tags to text fragments before they become mesh contours.

Use text tags for equation transforms and selective coloring inside Tex/Latex. The tag can be an integer or a list of integers; the wrapper lowers to the LaTeX \text_tag{...}{...} marker before rendering.

let text_tag = operator |target, tag| ...

mesh eq = Tex([text_tag{1} "x", " + ", text_tag{2} "1"], 0.8)

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 LaTeX, then placed outside the target in dir while staying centered on the target's orthogonal direction.

let Label = |target, str, dir = 1u, scale = 1, buffer = 0.1| ...

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

mesh n = Number(value, 2, 1)

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]| ...

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 f(x, y) = 0.

Uses a rectangular sampling grid and extracts zero contours as strokes; increase sample counts for sharper features.

let ImplicitFunc2d = |f, x_min_max_samples = [-1, 1, 41], y_min_max_samples = [-1, 1, 41]| ...

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 = [[], []]| ...

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]| ...

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)]

Scale a mesh uniformly or per axis.

A scalar factor scales all coordinates. A 3-list scales x/y/z independently.

let scale = operator |target, factor = 1, filter = nil| ...

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

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.

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} group

Promote 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| ...

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

mesh hud = camera_transfer{camera, $camera} to_side{UP} Text("fixed")

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

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.

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

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