All Classes and Interfaces
Class
Description
An axis-aligned bounding box.
A keyboard shortcut for a
MenuItem: one key plus the modifier mask that must be
held with it.A mixer bus: a named volume group every playback belongs to.
An immutable, backend-independent chunk of PCM audio: interleaved 16-bit
signed samples, 1 (mono) or 2 (stereo) channels, at a given sample rate.
Decodes encoded audio bytes into an
AudioClip.Service-provider interface for audio output, the sound counterpart of the
Backend rendering SPI.Reads a sounding audio playback's position as a
VideoClock.MasterClock, so pictures are
timed by the device that is actually making noise rather than by the wall clock.A pull source of PCM frames for streamed playback: music and long ambience
decoded incrementally instead of
AudioClip-style all-at-once (a four
minute track fully decoded is ~40 MB of heap; streamed it is a few hundred
KB of ring buffers).What a shape does to the pixels already behind it: a material, not a paint.
The backdrop blurred along one axis.
Which way one blur pass runs.
A transparent pane: the backdrop is not blurred, it is refracted at the rim, the way
light bends through the bevelled edge of real glass.
The backdrop as a cathode-ray tube shows it: bent onto a curved face and striped by the
scan.
The backdrop reduced to squares: redaction, not decoration.
The backdrop, undisplaced, with its saturation moved.
A panel whose background is the content behind it, put through a
BackdropEffect: a
glass control bar over video, a washed header over a picture, a redacted field.Service-provider interface for a native platform backend (windows, input,
GPU rendering, clipboard).
Handle to an in-scene modal (see
Backend.pushSceneModal(limn.backend.NativeWindow, boolean)); Backend.SceneModalHandle.release() it on close.Bars, grouped or stacked, vertical or horizontal.
How subsequent
Canvas painting combines with what is already on the
target.Push button with the full state set (normal, hover, pressed, disabled,
focused) and an
Button.onAction(Runnable) fired by click or by
Enter/Space while focused.Coordinates a set of
RadioButtons so that exactly one is selected at a
time.A perspective camera positioned by
eye/target/up.Translates pointer input into camera motion.
Immediate-mode 2D drawing API: what every widget paints through.
The half of a chart that has axes: a category axis with one slot per label and a value
axis with a scale over the numbers.
Committed text input (one code point), routed like
KeyEvent.What every chart in this package has in common: the data (labels and
series), the colors, the title, the legend, the hover tooltip,
the click callback and the animation.
One row of the legend: a swatch, a name, and whether its data is currently drawn.
Where the legend sits relative to the plot.
How much a hover reports.
One axis of a
CartesianChart: the value axis that carries the numbers, or the
category axis that carries the labels.Ready-made number formats for axis ticks and tooltip values: what a chart puts on
screen when the application does not supply its own
Chart.setValueFormat(DoubleFunction).The colors a chart hands to its series (or, in a donut, to its slices) when the
application names none.
One datum a chart can point at: what was hovered, what was clicked, what a tooltip row
is about.
One named run of values: a bar series, a line, or (in a
DonutChart) the ring
itself.Toggle with two visual variants: the classic
BOX with a check
mark, and the mobile-style SWITCH whose thumb slides.System clipboard (UTF-8 text).
Immutable straight-alpha RGBA color, channels in
[0..1].Picks a colour the way a graphics application does: a saturation/value field
for the current hue, a hue ramp beside it, a before/after swatch, a hex field,
and numeric channels in whichever model the user thinks in: RGB, HSV or CMYK.
Which numeric model the channel row is showing.
A colour, shown as a chip, that opens a
ColorPicker in a dialog when clicked:
the control an application reaches for when it needs a colour from the user but cannot
give up a panel to a whole picker.How the channel values of a color or texture are encoded.
An animated
Color: the color counterpart to Transition.Vertical
Flex: children stack top to bottom.Dropdown selector.
Layout constraints handed down the tree (Flutter/Compose style): a widget's
measured size must fall inside
[minWidth..maxWidth] x
[minHeight..maxHeight].Gives any widget a context menu, and answers what a request for one looks like.
The size step of a control: a deliberate, hand-tuned design axis, not a scale
factor and not a DPI setting (that is
Canvas.contentScale(), applied
downstream in the backend; the two multiply, in that order, and must never be conflated).The density axis, as one picture: the same five controls built five times and told
nothing except which size step to sit at.
Crash containment registry: one process-wide
CrashHandler (default:
log and continue) that the toolkit and backend notify whenever application
code throws inside the event loop.Unwinds the event loop when a
CrashHandler returned false;
containment sites let it pass through instead of re-dispatching, so the
handler sees each crash once.Application hook for crashes the toolkit caught in the event loop.
Where application code was executing when a contained crash was caught.
A standard mouse-cursor shape a widget can request while hovered: the OS's
native pointer, so it looks and feels exactly like every other application.
Immediate-mode debug geometry: world-space lines (AABBs, oriented boxes,
axes, grids, rays) batched on the CPU and flushed into a
RenderPass
once per frame.A modal (or non-modal) dialog that resolves a
CompletionStage with
the chosen button's result: never a nested event loop, so show*
returns immediately and the stage completes (on the UI thread) later.A monitor/screen, normalized so every part of the toolkit reads display
information the same way instead of each class poking at the platform: its
identity (
Display.id()/Display.name()), the mode currently set
(Display.currentResolution()), all supported modes
(Display.availableResolutions()), the physical Display.bounds(), the usable
Display.workArea() (minus taskbar/dock), and the DPI Display.contentScale().Where a surface that floats above the page is actually drawn: in a window of its own, or as an
overlay inside the window that owns it.
A ring of slices, or a pie, with
DonutChart.setInnerRadius(float) at 0.An easing curve: maps a normalized time
t in [0,1] to an eased
progress (usually in [0,1], though some curves may overshoot).An image-based lighting environment as a procedural gradient sky:
sky
straight up, horizon at the equator, ground straight down, in
linear color, scaled by intensity.A node in the neutral, typed shader-expression DAG.
Binary arithmetic; result type follows GLSL scalar/vector promotion.
A built-in or engine helper call with a declared result type.
A constructor like
vec4(rgb, a) or vec3(x).A numeric literal, scalar or vector by value count.
Arithmetic operators.
Non-portable inline GLSL, valid only for
target.A named input the framework declares (a UBO member, varying, or sampler).
Samples
sampler at uv → vec4.Component selection, e.g.
What every failure inside the FFmpeg decoder arrives as, including every failure that started
in C.
Finds and loads the native library the FFmpeg decoder needs, and answers whether it is there.
An open container, and the tracks inside it: one picture stream, and whichever of its soundtracks
is playing.
One of a container's audio tracks, as the container describes it: read once at open, from
the file's own stream headers, without opening a decoder for it.
One audio track of a written clip.
How a written clip's pictures are coded.
Whether to decode on a platform accelerator, and therefore what shape this container's
pictures have.
One of a container's subtitle tracks, as the container describes it: read once at open, from
the file's own stream headers, without opening a decoder for it.
Decodes H.264, HEVC, VP9 and VP8 video and AAC, Opus and Vorbis audio out of MP4 and
Matroska/WebM, through a trimmed FFmpeg behind a hand-written native shim.
Native system file/folder dialogs, obtained via
Backend.fileDialogs().A file-name filter: a human-readable description plus glob patterns,
e.g.
Files dragged from the OS and dropped on the window.
Simplified flexbox shared by
Column and Row: children flow
along the main axis with an optional gap; Expanded children
split the leftover main-axis space by flex weight; alignment controls the
distribution of leftovers (Flex.MainAlignment) and cross-axis placement
(Flex.CrossAlignment, including STRETCH).Cross-axis placement.
How leftover space along the layout axis is distributed, on two vocabularies that coexist
on purpose.
A first-person "fly" camera: dragging looks around (yaw/pitch about the eye,
pitch clamped near the poles) and the wheel flies forward/back along the view
direction.
A typeface selection: family name, size in logical points, and weight/style
(regular / bold / italic / bold-italic).
The set of font families the running backend can resolve: the bundled faces
plus any enumerated from the operating system.
Registers a font file the application ships, so its family becomes usable by name.
Process-wide font configuration (mirrors the
TextRulers / Ui
facade lifecycle).The worked form the guide's Forms page is built from: a whole screen rather than a
single widget, because the interesting part of a form is the arrangement, not the field.
Renders one frame of a window.
Immutable per-frame metrics handed to a
FrameCallback.Rolling per-frame performance samples the
Scene collects each frame:
frames-per-second, CPU frame time (tick + layout + paint, in ms),
input-processing time (ms), and how much of the scene each frame actually
repainted.A fixed-capacity ring of recent samples (oldest evicted first) exposing
the latest value, the windowed average/max, and a copy of the history for
a sparkline.
A fixed set of pictures a decoder fills and hands out, and the free list that takes them back.
The six clip planes of a view-projection, for frustum culling.
Renders every gallery entry twice (once in
Limn, once in Limn Light)
and writes gallery.json beside the PNGs.Loads a glTF 2.0 asset into a neutral
GltfModel: no AWT, no GPU.A parsed glTF 2.0 asset as neutral CPU data: a node hierarchy, meshes (as
MeshData), metallic-roughness materials, and encoded texture images.The model's texture images decoded to pixels, ready to upload: the CPU half of
GltfModel.toScene3D(), separated so it can be done off the UI thread.An encoded image (PNG/JPEG bytes), left encoded until
GltfModel.decodeTextures().Metallic-roughness material; texture fields index
GltfModel.textures() (-1 = none).One drawable range of a mesh with its material index (
-1 = default).A glTF sampler, kept as the file's GL enums;
-1 = unspecified.An opaque handle to mesh geometry uploaded to the GPU (via
Graphics3D.upload).GPU rendering entry point for one window.
An offscreen GPU render target owned by the backend: a texture (with its own
depth buffer) that something can draw into off-screen and that the 2D
Canvas can then composite as one layer via
Canvas.drawSurface(limn.graphics.GpuSurface, float, float, float, float).An opaque handle to a texture uploaded to the GPU (see
Graphics3D.uploadTexture).Facade + install-at-startup SPI for the 3D backend, the same inversion pattern
as
Images/Sounds: a neutral entry point here, the GL
implementation installed by the backend on startup.Backend-supplied factory + renderer (installed at startup).
Which graphics context a backend actually obtained, and which of the optional
capabilities the toolkit uses are present on it.
The shortest complete Limn program, and the one the site's "get started" page shows.
The UI language: the process locale, the
locale in effect here, the registered
bundles, and the epoch
that every
I18nString validates its cache against.A piece of user-visible text, carried as a value instead of resolved into a
String at the point of use.A themeable, resolution-independent glyph, conceptually distinct from an
Image, which is just a fixed grid of RGBA pixels for display.Whether an icon turns around when the interface does.
An immutable, backend-independent bitmap: RGBA8 pixels, straight (non
premultiplied) alpha, row-major, row 0 at the top.
Decodes encoded image bytes (PNG/JPG/…) into an
Image.What an encode should produce: the
ImageFormat, plus the knobs a lossy
format needs.Encodes an
Image into a file format.An encoded image format, named by its IANA media type: what a caller asks
Images.encode(Image, ImageFormat) for and what an ImageEncoder
declares it can produce.Image loading and saving facade.
Base of all dispatched input events.
Edge insets in logical points (padding/margins).
Order-2 (9-coefficient) spherical-harmonic irradiance baked from an
Environment, the diffuse half of image-based lighting (Ramamoorthi &
Hanrahan 2001).A started piece of background work, as seen by whoever asked for it.
A keyboard event routed to the focused widget (bubbling to its ancestors
until consumed).
Toolkit key codes and modifier bits.
Single- or multi-line text.
Where a line sits in the text region, on two vocabularies that coexist on purpose.
Which typographic token the text is drawn with, orthogonal to the size step,
which decides how big that token is.
The direction a subtree lays out in: an inherited design axis, not a transform and
not a property of the locale.
The worked window the guide's Layout page is built from: an asset library with a toolbar,
a sidebar, a tile grid and a status bar, assembled out of the primitives that page
teaches, and nothing else.
An analytic light for the PBR pass, added to a
RenderPass with
RenderPass.addLight(limn.render3d.Light).An infinitely distant light (sun):
direction points toward the source.An omnidirectional light at
position with inverse-square falloff.A cone light at
position aimed along direction (pointing away
from the light).Two-stop linear gradient from
(x0,y0) (color start) to
(x1,y1) (color end), clamped beyond the endpoints.Lines, with optional filled areas and markers.
A vertically scrolling list that virtualizes its rows like a
JTable/RecyclerView: only the rows in the viewport get a
widget, so a list of a million rows costs the same as one of twenty (layout
and paint are O(visible)).Supplies and (optionally) caches the row widgets of a
ListView.GLFW + OpenGL 3.3 core implementation of
Backend.Limn UI demo.
An immutable column-major 3×3 matrix (
m[col*3 + row]).An immutable column-major 4×4 matrix (
m[col*4 + row], OpenGL
convention), single precision.How a surface is shaded.
A tangent-space normal map and how far to lean on it.
Metallic-roughness PBR (Cook-Torrance GGX), lit by every
Light on the
pass plus a flat ambient term.Custom GLSL.
Lambert diffuse from the pass's single directional light, over a base color.
A surface the application builds itself, out of the same neutral shader IR the
built-in materials are generated from, and lit by the same core.
A named sampler.
A named
vec4 uniform.A flat/vertex color, unaffected by lights.
Playback controls for a
VideoView: play/pause, a scrub bar and a position clock — the
bar every player lays over its picture.Whether the mute button and volume slider are offered.
Plays a video stream: a decode thread ahead of a small ring of pictures, a
VideoClock
timing them, and an optional audio track that becomes the clock's master.Where a player is in its life.
What one pass of the decode loop did: what a host driving it needs to know to pace itself.
A horizontal strip of top-level menu titles; the strip itself is drawn
in-scene (part of the window chrome).
One entry in a
Menu: a command, a checkable toggle, a submenu, or a
separator.CPU-side geometry: one float array per
VertexAttribute plus a triangle
index list.How often a mesh's contents change, declared at upload, because a GPU buffer's
usage is fixed when it is allocated.
The screen the home page's mosaic is cut from, and nothing else.
A pointer event, positioned in scene coordinates (logical points, origin at
the window's top-left).
A mutable column-major 4×4 matrix (
m[col*4 + row], same conventions
as Mat4) for allocation-free transform composition in hot loops.A top-level native window.
Notified when the window moves to a monitor with a different content scale.
What a registered child window is, which decides whether a modal over the owner
leaves it usable.
A node in the retained
Scene3D graph: a local Transform3D plus
children.The digits a formatted number is written in: one zero code point and its nine successors,
which is all a decimal numbering system is.
Orbits a
Camera around its target: horizontal drag spins the azimuth,
vertical drag tilts the elevation (clamped near the poles), the wheel dollies
in/out.Wraps one child with edge insets.
TextField that renders every character as a mask dot, with an optional reveal toggle.Mutable 2D path: move/line/quadratic/cubic segments and closed subpaths, in
logical points.
Receives the flattened (curve-free) form of a path.
Performance footer: two rows of live gauges, what a frame costs (FPS, CPU
frame time, GPU time, widgets painted, repaint regions) over what the process
costs (CPU, heap, GC pause, 3D memory, 3D draw calls), each with the current
value and a per-second bar chart of the last 60 ticks (the oldest tick falls
off once the window is full).
CPU ray picking.
The memory layout of a decoded
VideoFrame: how many planes it has, what each one
holds, and how each plane's sample grid is derived from the frame size.A handle to a sound that has started playing on the
AudioEngine.How to play a sound: volume, pitch, stereo pan or 3D position, looping,
mixer
bus and voice-steal PlayOptions.Priority.Voice-steal class; see
PlayOptions.priority.The toolkit's built-in
ImageEncoder: PNG, 8-bit RGBA with straight alpha, which is
Image's pixel layout unchanged, so no channel is dropped, no value is quantized, and
decoding the result yields the bytes that went in.How the window treats the mouse pointer: visibility and capture.
Ear-clipping triangulation of simple (non-self-intersecting) polygons,
convex or concave, any winding.
A context menu / dropdown that presents a
Menu (with checkable items,
separators and cascading submenus) as a real native window: an
undecorated, floating, transparent OS window (like a ComboBox popup) that may
overflow the owner window exactly like a true OS menu.In-progress IME composition ("preedit"): the text an input method is still
composing, shown inline with an underline but not committed to the
editing model.
Procedural
MeshData for common shapes, each with POSITION, NORMAL and
UV0.The only handle a background body has on the outside world while it runs:
it can ask whether it has been cancelled, and it can say how far it has got.
Simple horizontal progress bar.
A
StringBundle backed by UTF-8 .properties files on the classpath,
one family per domain:An immutable unit quaternion (x, y, z, w) for rotations: no gimbal lock,
cheap to compose and interpolate (
Quat.slerp(limn.math.Quat, float)).Two-stop radial gradient:
center color at (cx,cy) fading to
edge color at distance radius, clamped beyond it.A single-choice control: a ring that fills with a dot when selected.
A ray
origin + t·direction, t ≥ 0.A
GpuSurface whose pixels can be brought back to the CPU.Immutable axis-aligned rectangle in logical points.
A snapshot of the 3D subsystem's GPU footprint and last-frame workload, for
diagnostics (a performance monitor).
The draw interface handed to a render callback (see
Graphics3D.render(target, camera, body)).A snapshot of GPU resources the renderer is holding: currently the number of
GL textures resident (glyph-atlas pages + cached image textures) and their
estimated size in bytes.
An offscreen render target for 3D content: a color texture plus a depth
buffer, optionally multisampled (MSAA).
An immutable screen mode: a pixel size and refresh rate.
Immutable rounded rectangle with independent corner radii, in logical
points.
Horizontal
Flex: children flow left to right.How a texture is filtered and wrapped when sampled.
Owns a widget tree bound to one window: queues native input (with
coalescing), dispatches events with hit-testing and bubbling, tracks hover,
click synthesis and keyboard focus (Tab traversal in layout order), ticks
animations and runs the two-phase layout before painting.
Animation hook, called once per frame while registered.
A retained 3D scene: a
Node tree plus scene-wide ambient/exposure and an
optional background.A mesh to draw, paired with its composed world transform.
Scene-referred pixels read back from a
ReadableSurface: RGBA floats, linear light,
premultiplied alpha, row-major, row 0 at the top.SPI for widgets that can scroll their content programmatically: scroll
containers (
ScrollView), virtualized lists (ListView),
overflow strips, popup panels.The one scrollbar shared by every scrollable component (
ListView,
TextArea, ScrollView, …), so they look and behave identically.The scroll state the bar reflects and drives.
Which axis the bar controls.
When the bar is shown.
How much of a scrolling widget's box its scrollbars take, and the settling that
decides it.
How the content is measured for a candidate viewport.
Whether a bar floats over the content or takes a strip out of it.
Generic scroll container: the child is measured unbounded on the scrolling
axes, painted clipped to the viewport and offset by the scroll position; the
wheel scrolls whenever there is overflow.
A
TextField preset for search: a leading magnifier icon inside the
field and a trailing coupled clear button (the ComboBox-caret idiom).A row of connected segments with a single selection, a compact alternative to
a
RadioButton group or tabs.A thin divider line drawn in the theme's
Theme.outline color.The value types the neutral shader IR works with: the GLSL scalar/vector types
plus
sampler2D.One line of text after shaping: the glyphs a face draws for it, where each one sits, and every
geometric question a widget then asks about that line.
Which side of a char index a caret sits on, and so which of the two points that index can
occupy is meant.
Assembles a
ShapedText run by run.The two places a caret may sit for one char index, for a caller that stores no side.
Which way a paragraph reads.
A caret position: where text is inserted, plus which side of that index the caret is on.
One shaped stretch: a single face, a single embedding level, a single shaping call, and the
unit the backend resolves a face at and batches a draw at.
One horizontal box of a selection, in logical points from the left edge of the line.
Whole screens, as opposed to the component gallery's single widgets: the kitchen sink and
the 3D viewport, captured on a canvas the size of a real window.
A measured widget size in logical points.
Forces a fixed width and/or height (unset dimensions pass through to the
child, or collapse to zero without one).
The numeric size table: one immutable row per
ControlSize step.Horizontal slider selecting a value in
[min, max].Audio facade, backed by the running backend's
AudioEngine and
AudioDecoder (both installed at startup, mirroring Images).A stepper input for a bounded value, in two modes:
Spinner.Mode.NUMERIC: new Spinner(min, max, step) shows a number
(decimals inferred from the step);
Spinner.Mode.TIME: Spinner.time() shows HH:MM, where the up/down
arrows adjust the focused field (hours by 60, minutes by the step) and
Left/Right (or a click) move between the two fields.
Numeric value vs.
Two panes and a divider the user drags to share the space between them.
Which axis the two panes are arranged along.
Overlays children on top of each other (later children on top; the base
for overlays and modal dialogs).
Where a child sits in the stack's box, on two vocabularies that coexist on purpose.
Builds the
SurfaceOutputs for the built-in metallic-roughness material,
the same surface the hand-written reference shader computes, expressed as
neutral IR so one code generator can target multiple shading languages.A source of translations.
Quantities that are pixel-locked: identical at every
ControlSize step.The cues of a container's selected subtitle track, asked for by position: what is on screen
at this moment.
One subtitle cue: its text, and the interval it is on screen for.
What a material's surface function contributes to the engine's lighting core:
the metallic-roughness inputs.
A themeable vector
Icon: keeps the SVG source and lazily rasterizes it
(via the installed SvgRasterizer) to a cached Image per
requested pixel size (a small LRU of 16 sizes).SPI that rasterizes SVG icon bytes to an
Image.What a synthetic stream draws.
The whole description of a synthetic stream: what it draws, how
big, in which layout, under which colour interpretation, how fast, for how long, and how many
pictures it keeps in flight.
A decoder with nothing to decode: it draws its pictures, so a video is available on any machine,
in every layout, under every colour interpretation and at any size, with no file to ship and
nothing to go missing.
Tabbed panel: a horizontal strip of tab headers over a content area that
shows the selected tab.
Where the strip sits when the headers are narrower than the pane, named for where it lands
in an interface that reads left to right.
A shading-language target the IR can be compiled to.
Multiline text editor: hard line breaks (Enter), arrow navigation across
lines with a sticky column, mouse/Shift+arrow selection spanning lines,
clipboard shortcuts, blinking cursor, and both scrollbars: draggable
thumbs and wheel-responsive.
Pure, headless text-editing model shared by TextField/PasswordField (single
line) and TextArea (multiline): cursor, anchor-based selection, line-aware
Home/End and Up/Down with a sticky goal column, bounded undo/redo.
The lines edits have replaced: lines
[firstLine, oldLastLine] of the text as it
stood at the last TextEditModel.clearLineDamage() became lines [firstLine, newLastLine]
of the text as it stands now.Single-line text input: blinking cursor (frame-clock ticker), mouse and
Shift+arrow selection, Home/End, Ctrl/Cmd+A/C/V/X through the system
clipboard, placeholder, and horizontal scrolling that keeps the cursor
visible when the text overflows.
Validation state; colors the border (and a caller-supplied message).
Measured extents of a single line of text, in logical points, relative to
the baseline.
Measures text without a frame in flight: what widget layout uses (the
layout pass runs before painting, when no
Canvas exists).Process-wide
TextRuler registry, installed by the running backend
(mirrors the Ui facade lifecycle).CPU-side pixels for a 2D texture: tightly packed 8-bit RGBA, row-major from the
top-left, tagged with the
ColorSpace the values are authored in.Central design tokens: colors, corner radii, typography and spacing.
Collects the colours of a palette and builds one.
Every colour a palette is made of, as values, so that code which has to
treat every tone alike (a serializer, an editor, a contrast report) enumerates them
instead of naming them all and getting all but one right.
What is wrong with a palette, measured rather than judged.
Which side of its bar a measurement came out on.
One measurement that missed its bar.
How much a finding matters.
Which scale a finding was measured on, and how a number on it is written.
The screen an application embeds so that its users can build a palette of their own:
every tone of a
Theme on a colour well, a preview that shows all of them at once,
and a legibility report that names the unreadable pair before anyone ships it.The theme editor as a program you run, rather than a screen you embed.
The theme editor as the site captures it: the module's own screen, and nothing this file adds.
Open and Save As for a
ThemeEditor, through the platform's own chooser.A palette as text, and back, so an application can ship a theme its designer built as
a file beside the jar instead of as a recompile.
A miniature window, painted from a palette that is not the process-wide one.
Writes the
Limn and Limn Light palettes out as CSS custom properties,
for the public site to consume.A
SizedBox whose fixed dimensions come from the resolved
ControlSize step instead of from a number baked at construction.One extent, read off a size step.
A
Column whose gap follows the resolved ControlSize step.A
Padding whose insets follow the resolved ControlSize step,
uniform on all four edges.A
Row whose gap follows the resolved ControlSize step.Pushes resolved
SizeTokens spacing into the geometry-only containers, which hold
plain floats and therefore cannot follow a size step on their own.Which of the three spacing tokens a container follows.
A horizontal strip of controls (buttons, toggles, segmented controls,
Separators…) on a rounded Theme.surface background.Appearance of the scene's hover tooltip panel.
A translation/rotation/scale transform, the human-friendly way to place a
node in 3D.
One animated
float property: the toolkit's reusable "CSS transition".Static facade over the toolkit's
UiRuntime, Limn's first-class
async API.The concurrency runtime behind
Ui: a single UI thread fed by a
thread-safe (MPSC) task queue, plus a worker pool for the application's
heavy background work.Wakes the native event loop when work is posted from another thread.
An immutable 2-component vector (single precision): texture coords, screen points.
An immutable 3-component vector (single precision), right-handed.
An immutable 4-component vector: homogeneous positions (
w=1),
directions (w=0), and RGBA colors.A vertex attribute semantic and its component count.
Decides, one candidate picture at a time, whether to show it, keep the current one, or throw it
away: a player's whole timing policy, as arithmetic.
What the caller must do with the picture it just asked about.
A media position source on the same timeline as the pictures' presentation times.
How the samples of a
VideoFrame are to be turned into colour: which luma/chroma matrix
was used to encode them, whether the codes cover the full range or the studio range, and what
transfer function the encoded values carry.The luma/chroma matrix a stream was encoded with.
Which codes a stream's samples occupy.
What the decoded values are, once the matrix has been undone: numbers a display can
show, or a curve that has to be inverted before they mean light.
Opens a video input for incremental decoding.
One decoded picture, borrowed from the producer that published it.
How a producer reads one of its own device pictures back into memory a consumer can address,
when
VideoFrame.toPlanar() asks it to.Which of the two shapes a picture has: samples in memory, or a handle to a device allocation.
How a producer gets a released frame's memory back.
A producer's handle on one pooled frame: the only thing that can point a frame at memory or
publish it.
Video facade, over the installed
VideoDecoders.A pull source of decoded pictures: the video counterpart of an incrementally decoded audio
stream, obtained from a
VideoDecoder and driven one picture at a time.The outcome of a
VideoStreamSource.readFrame() call.How close to the target a
seek is asked to land.A device-side picture: the destination a
VideoFrame's planar samples are uploaded to,
converted to colour by the backend, and composited by Canvas.drawSurface(limn.graphics.GpuSurface, float, float, float, float) as one quad in
the 2D paint order, so clipping, opacity, overlays and dialogs apply to a video exactly as they
apply to a rectangle.Video-surface facade + install-at-startup SPI (the same inversion as the image, audio and 3D
facades): a neutral entry point here, the device implementation installed by the backend.
Backend-supplied factory, installed at startup.
Shows the pictures of a
VideoStreamSource: each one handed to a device-side picture and
composited as one quad in the 2D paint order, so clipping, opacity, overlays and dialogs apply to
a video exactly as they apply to a rectangle.How a picture whose aspect ratio differs from the box's is mapped into it.
A viewport that renders 3D content into an offscreen
RenderTarget (with
MSAA) and composites it as a normal 2D layer, proving that GPU-rendered content
respects the scene's layering: overlays, dialogs, tooltips and clipping all
apply to it because it draws as one quad in the paint order.Draws the 3D scene into a pass each frame;
timeSeconds advances while showing.The 3D viewport as a whole screen: a lit scene on a checkered ground, filling a window.
Base of the widget tree.
Initial configuration for a
NativeWindow.Receives a window's translated native input on the UI thread, in logical
points.
Visual framing of a window.
A description of background work, built up and then started once.
The background body.
Reads YUV4MPEG2: a text header, then a
FRAME line and raw planes per picture, with no
compression and no container.Writes what a source produces as a YUV4MPEG2 file: the counterpart that makes
Y4mDecoder
verifiable, and the only way to get a real video file out of this project without shipping one.Converts a decoded picture to 8-bit RGBA on the CPU: the reference implementation of the
colour arithmetic, and the path used where no device conversion is available.