Initialization, fonts, events and frame rendering. RML loading, element properties and native lifetimes. Copied event payloads and JavaScript listener signatures.
Initialization, fonts, events and frame rendering.
Create a named RmlUi context.
RmlUi context bound to one sfml.js render window.
Rml::Animation value; fields and Tween are copied at each native boundary.
Native Animation equality; negation represents operator!=.
Tagged Rml::AnimationList.
Rml::Any: check whether a unit set contains any flag.
Native template result selected by a non-null default value's type.
Attribute values, including lifetime-guarded element references.
Native XML tokenizer with synchronous or batched event delivery.
Synchronous Rml::BaseXMLParser virtual implementations.
Rml::BlendMode for premultiplied layer composition.
Native-owned Rml::Box value with writable shared numerical fields.
Rml::BoxArea, ordered from the outside towards the content.
Rml::BoxDirection for size-across queries.
Rml::BoxEdge, in native edge-array order.
Copied Rml::BoxShadow fields; lengths are not resolved to pixels.
Tagged Rml::BoxShadowList snapshot, preserving native order.
Built-in native font engines selectable before initialization.
Unique Rml::CallbackTexture with lazy synchronous texture generation.
Synchronous Rml::CallbackTextureFunction; submit exactly once on success.
Rml::CallbackTextureInterface valid only during its generation callback.
CallbackTextureSource equivalent with a unique callback texture per manager.
Opaque equality token for Rml::ClassId, without exposing native addresses.
Owned copy of Rml::ClipMaskGeometry; no borrowed element pointers.
Compare Rml::ClipMaskGeometry with native pointer equality semantics.
Rml::ClipMaskOperation, also used by clipping query snapshots.
The channel format of a glyph bitmap: alpha coverage or RGBA colour.
Copied Rml::ColorStop, with the unresolved position unit.
Tagged Rml::ColorStopList snapshot, preserving native order.
Owned Rml::CompiledFilter with automatic native release.
Owned Rml::CompiledShader; shares the compiled filter lifetime rules.
Owned Rml::ComputedValues storage associated with a live element.
Read-only live view of an element’s computed style.
RmlUi context bound to one sfml.js render window.
Read-only view of the context's cached physical dimensions.
Allocate an owned context through another native instancer.
Checked Rml::ContextInstancer with native allocation and release ownership.
Observe completed native destruction at a safe runtime boundary.
Copied name captured before native context destruction.
Native Rml::ConvolutionFilter with a writable shared float32 kernel.
Rml::CornerSizes: top-left, top-right, bottom-right, bottom-left.
Create a named RmlUi context.
Create an independent SFML renderer before or after initialisation.
Managed Rml::CreateString using the checked native formatting path.
Native custom face and fixed writable measurement storage.
Independent metrics used to register a Native custom face.
Ordered native root/member/index entries, copied when resolving a variable.
One native data address component, with independently mutable name and index.
Explicit numeric view group evaluated by the native model scheduler.
Configuration for explicit native data-view groups.
Compute one compact dirty interval and return its output command count.
Initialization of a real Rml::DataView or Rml::DataController.
Native data-binding release notification at a safe outer call boundary.
Checked owning or Core-borrowed Rml::DataController.
Virtual operations of an actual Rml::DataController.
Allocate a controller for the requesting element or decline with null.
Real Rml::DataControllerInstancer for native RML controllers.
Real native VariableDefinition callbacks over a retained JS payload. Omitted callbacks use native defaults: false, zero, null, or an empty list.
Checked native VariableDefinition, including unregistered variable leases.
Integer widths supported by checked native enum storage.
Rml::DataEventFunc receives a model, live event and expression arguments.
Native member event equivalent; bind the host receiver before registration.
Rml::DataGetFunc equivalent returning an owned Variant.
Explicit result of VariableDefinition::Get, including successful null values.
Read a member from its current checked parent path. Scalar schemas return an owned value; reference, array and struct schemas return a same-register variable or null.
Assign a scalar member after native width and enum conversion. Custom scalar members exchange owned Variants directly.
Rml::DataModelConstructor with native-owned bindings.
Checked Rml::DataModelHandle with native dirty-variable scheduling.
Options matching Rml::Context::CreateDataModel.
Shared views of native numeric array storage.
Runtime counterpart of Rml::PointerTraits for checked native data leases. Raw, unique and shared C++ pointers use managed nullable references in JS. Native retains storage; dereferencing never exposes an address to JS.
Registered scalar type callbacks, corresponding to ScalarFuncDefinition. Each bound payload is retained; getters return owned Variants.
Native scalar types, including every signed and unsigned integer width.
Built-in scalar values stored by native RmlUi data definitions.
Registered native definition with a real Rml::FamilyId.
Rml::DataSetFunc equivalent assigning one value.
Named initial members of a native record.
Initial native storage values; records and arrays may nest recursively.
Runtime struct registration corresponding to Rml::DataStructHandle.
Rml::DataTransformFunc receives native expression arguments in order.
Output of Rml::TransformFuncRegister::Call, preserving its success flag.
Host equivalent of a native typed getter with a Variant output parameter.
Rml::DataTypeRegister, owned independently or borrowed from one context.
Host equivalent of a native typed void setter.
Checked path into an Rml::DataVariable; resolves native storage on each call.
Native Rml::DataVariableType categories.
Owned native Variant values accepted by data callbacks, including null.
Owning or Core-borrowed handle to a real native Rml::DataView.
Virtual operations of a native Rml::DataView.
Allocate a view for the requesting element or decline with null.
Real Rml::DataViewInstancer used by the RML parser and Factory.
Native RmlUi Debugger tools hosted in one context and inspecting another.
Copied Rml::Transforms::DecomposedMatrix4.
Shared Rml::Decorator returned by an instancer.
Synchronous Rml::Decorator virtual functions with host-owned element data.
Owned Rml::DecoratorDataHandle with checked decorator and element identity.
Writable Rml::DecoratorDeclaration record, copied when assigned to a list.
Rml::DecoratorInstancer with properties and synchronous JS instancing.
Synchronous Rml::DecoratorInstancer::InstanceDecorator implementation.
Rml::DecoratorInstancerInterface for a stylesheet and render manager.
Generation-owned Rml::DecoratorsPtr, preserving shared resource identity.
Phases that run Rml::Element::ProcessDefaultAction after listeners finish.
Native collection of dirty root variable names.
Explicit Rml::Element::DispatchEvent propagation options.
Native-owned Rml::DocumentHeader for document parsing and resource merging.
Header input with empty strings/lists and native resource defaults.
Owned snapshot of Rml::DocumentHeader::Resource.
Resource input with upstream defaults for omitted fields.
Complete independent copy of native document-header storage.
Rml::EdgeSizes: top, right, bottom, left.
A copied property in an effect instancer's local specification.
Checked element-owned Rml::ElementBackgroundBorder.
Both native clipping outputs; a mask can exist without a scissor region.
Native-owned numeric command planes with a registered element slot table.
Ordered numeric operations consumed by ElementCommandBuffer.submit.
Per-command numeric query result.
Immutable Rml::ElementDefinition from stylesheet selector matching.
Native Rml::ElementForm wrapper.
Native Rml::ElementFormControl base wrapper; obtain it from a document.
Rml::ElementFormControlInput, including native input-type behavior.
Native Rml::ElementFormControlSelect wrapper.
Native Rml::ElementFormControlTextArea wrapper.
Allocate a detached native element through another typed instancer.
Checked native allocation/release customization for Rml::ElementInstancer.
Native Rml::ElementLottie; playback uses the native system clock.
Checked wrapper for Rml::ElementProgress.
Owned rectangle snapshot in window coordinates.
Observe an independent pre-destruction snapshot at a safe native boundary.
Owned attribute snapshot captured before native element destruction.
Owned Rml::ElementScroll or checked view of Element::GetElementScroll.
Checked element-owned Rml::ElementStyle with native cascade and dirty state.
Native Rml::ElementSVG with inline XML or a file-backed src attribute.
Checked wrapper for Rml::ElementTabSet.
Checked Rml::ElementText wrapper with native text layout operations.
Reusable native transform snapshots for many elements in one native entry.
Checked static Rml::ElementUtilities operations.
Checked Rml::EventDispatcher owned by its native element.
Rml::EventId constants. Custom ids are returned by registerEventType.
Delegate event allocation to another EventInstancer.
Native Rml::EventInstancer with checked allocation and release.
Native Rml::EventListener supporting multiple dispatcher attachments.
Element identity copied when a native listener attaches.
Observe a native attachment or detachment after its active frame returns.
Allocate a listener for an exact native inline attribute value.
Rml::EventListenerInstancer adapter for real RML on* attributes.
Rml::EventPhase values.
Observe native event destruction after its active stack returns.
Event identity copied before native release.
Checked Rml::Factory instancing, parsing and cache operations.
Synchronous file provider methods; omitted methods use Native byte storage.
Native token for one open file.
Native-owned Rml::FileInterface with a filesystem root or custom callbacks.
Owned Rml::Filter with native or synchronous JavaScript virtual methods.
Synchronous implementations of Rml::Filter virtual functions.
Writable Rml::FilterDeclaration record, copied when assigned to a list.
Rml::FilterHandleList adapter retaining its compiled resources.
Rml::FilterInstancer with local properties and a synchronous JS factory.
Synchronous Rml::FilterInstancer::InstanceFilter implementation.
Generation-owned Rml::FiltersPtr, preserving shared resource identity.
Rml::FilterOperation for native alpha convolution.
Corner representation of the Rml::Rectanglef ink overflow.
Rml::FocusFlag for Document.show.
Optional independent codepoint advances for entirely Native measurement.
Rml::FontEffect with writable metadata and native virtual glyph operations.
Synchronous native Rml::FontEffect virtual overrides.
Native font effect factory with local properties and a JS callback.
Synchronous Rml::FontEffectInstancer::InstanceFontEffect implementation.
Choose whether a font effect is rendered behind or in front of the text.
Generation-owned Rml::FontEffectsPtr containing const font effects.
Opaque font effect preparation hook.
Opaque Rml::FontEffectsHandle bound to its face, engine and font generation.
Metadata fields exposed by a native FontEffect wrapper.
Synchronous Rml::FontEngineInterface virtuals, captured at construction.
Upstream engine semantics, independent of current selection.
Native Rml::FontEngineInterface with shared values and host virtuals.
Selected built-in engine or explicit synchronous custom callbacks.
Provider-owned face selection hook.
Opaque Rml::FontFaceHandle from the active native font engine.
Identifiers for descriptors in a font-face rule.
Owned geometry generation hook.
Native-owned Rml::FontGlyph with mapped metrics and retained bitmap storage.
Rml::FontGlyphMap represented by Unicode code point keys and owned glyphs.
Output of Rml::FontEffect::GetGlyphMetrics.
Synchronous provider lifecycle hook.
File metadata loading hook.
Snapshot-based memory loading hook.
Explicitly named file loading hook.
Reusable native UTF-8, offset and width storage for font measurement.
One packed callback without per-string JS conversion.
Native-owned Rml::FontMetrics snapshot with shared field access.
Font metrics refresh hook.
Snapshot of the upstream text-shaping arguments.
Rml::Style::FontStyle values for explicit font registration.
Font geometry version hook.
Named Rml::Style::FontWeight values; any integer from 1 to 1000 is valid.
Compatibility single-string measurement hook.
Compatibility bulk text measurement hook.
Format typed arguments through the real native Rml::FormatString.
Managed result of Rml::FormatString, with its native byte length.
Rml::FontEngineInterface::GenerateString result.
Copied outputs from Rml::ElementText::GenerateLine.
Unique Rml::Geometry owning an immutable native mesh snapshot.
Choose whether releasing geometry preserves or clears its owned mesh.
Read compiled modules, font semantics and runtime availability.
Look up Rml::GetContext by name or zero-based index.
Return the selected Native file interface.
Rml::GetFontEngineInterface, with canonical public wrapper identity.
Get the number of active contexts in the runtime registry.
Read the actual Rml::GetRenderInterface pointer as a checked reference.
Read Rml::GetSystemInterface before or after initialization.
Return the selected native global input handler.
Copy Rml::GetTextureSourceList across all render managers.
Initialise RmlUi with SFML-backed system and render interfaces.
Options for the process-wide RmlUi runtime.
Independent Rml::KeyframeBlock.
Native reusable optional shorthand cache, dependencies and output storage.
Independent Rml::Keyframes snapshot.
RmlUi key identifiers; custom keys occupy 177 through 250.
RmlUi modifier flags; combine flags with bitwise OR.
Opaque Rml::LayerHandle belonging to one manager and one layer lifetime.
Forward the checked overload to the native font engine.
Application logging through Rml::Log and the selected system interface.
Native Rml::Log::Type values.
Captured native Lua function or compiled chunk, retaining its exact VM.
Values copied between Node and Lua; Lua integers return as bigint.
Native-owned Lua 5.4 host; its documents intentionally share Lua globals.
Explicit trusted-source policy for one native Lua state.
Construct Rml::Animation with native defaults and float32 fields.
Create Core's immutable signed 32-bit integer variable. It owns no mutable storage and remains valid across runtime shutdown.
Invoke an upstream NumericValue-array primitive constructor.
Construct Rml::Transition with native defaults and float32 fields.
Construct Rml::TransitionList; none=true, all=false, entries=[] by default.
Identifiers for context-dependent media conditions.
Native Variant-output member getter; bind the host receiver for bindFunc.
Native value or reference member getter represented by a bound host method.
Native Variant-input member setter; bind the host receiver for bindFunc.
Native value member setter represented by a bound host method.
Native-owned Rml::Mesh with shared vertex and index allocations.
Rml::MeshUtilities with Native geometry generation and batch submission.
Rml::ModalFlag for Document.show.
Compiled support and availability in the current owning runtime.
Independent Rml::NamedDecorator metadata.
Native-owned, per-document JavaScript host using Node's vm.Script.
Explicit policy for trusted JavaScript document execution.
Native-owned Rml::NumericValue with mapped number and unit fields.
Copied Rml::NumericValue fields; no shared buffer or runtime owner.
Native-owned reusable packed measurement workspace.
Rml::ParameterMap, mapping own string keys to signed 32-bit integers.
Native-owned adapter for Rml::Plugin.
Synchronous Rml::Plugin notifications.
Rml::Plugin context creation or destruction notification.
Rml::Plugin data model creation or pre-destruction notification.
Rml::Plugin document load or unload notification.
Rml::Plugin::OnDocumentOpen request notification.
Rml::Plugin element creation or destruction notification.
Rml::Plugin::EventClasses subscription bits, captured on each registration.
Rml::Plugin::GetEventClasses contract.
Rml::Plugin runtime lifecycle notification.
Choose the reference edge or centre used to position an element.
Copied box and output offset from Rml::Element::GetBox(index, offset).
A file font registered under an explicit family through Rml::LoadFontFace.
Prepare resources with Native workers and the selected file provider, then commit texture uploads and font registration on the owning runtime thread.
Resources to prepare before loading and showing a document.
Rml::ColourbPremultiplied bytes, already multiplied by alpha.
Copied return value and in/out point from Rml::Element::Project.
Native-owned Rml::Property copy, valid for its RmlUi runtime generation.
Generation-checked Rml::PropertyDefinition.
Native-owned Rml::PropertyDictionary with independent property snapshots.
Identifiers for built-in and custom RCSS properties.
Native property parser, either built in or implemented by a JS callback.
Rml::PropertyParser::ParseValue callback, returning synchronously.
A shorthand component referencing a property definition.
Copied Rml::PropertySource.
Own an Rml::PropertySpecification with local property and shorthand ids.
Both outputs from Rml::PropertyDefinition::GetValue.
A shorthand component referencing another shorthand.
Register a native event specification with Rml::RegisterEventType.
Register Rml::Plugin and retain its Native adapter.
Rml::RelativeTarget used when resolving relative property units.
Release handles with Rml::ReleaseCompiledGeometry, retaining the meshes.
Release font textures/glyph caches and rebuild active fonts.
Release unused managers with Rml::ReleaseRenderManagers.
Release a named texture with Rml::ReleaseTexture.
Release loaded/generated texture handles with Rml::ReleaseTextures.
Remove a named context with Rml::RemoveContext and invalidate its aliases.
Independent Rml::RenderBox with writable native numerical views.
Opaque runtime-owned Rml::RenderInterface reference.
Checked Rml::RenderManager resource factory.
Owned scalar/vector/colour parameters passed to Rml::RenderManager.
Owned snapshot of Rml::RenderState.
Cancellation and renderer selection for one preload batch.
RmlUi event snapshot with callback-scoped native propagation controls.
Snapshot of this binary and its owning process-wide runtime.
Synchronous named document event handler.
Typed base for checked Rml::ScriptInterface objects.
Native Rml::ScrollAlignment.
Native Rml::ScrollBehavior for context and element scrolling.
Rml::ScrollFlag for Document.show.
Options for native Rml::Element::ScrollIntoView.
Choose the horizontal or vertical scrollbar.
Native Rml::ScrollParentage.
Native seek origins.
Select a Native file provider before RmlUi initialization.
Rml::SetFontEngineInterface before initialization; null restores automatic FreeType selection.
Select Rml::SetRenderInterface before initialisation.
Install Rml::SetSystemInterface before initialization.
Call Rml::SetTextInputHandler; existing contexts keep their selected handler.
Snapshot of Rml::ShorthandDefinition with checked property references.
Identifiers for RCSS shorthand property groups.
Flags copied from an Rml::ShorthandItem.
Rml::ShorthandType controls how a declaration fills its component properties.
Shut down RmlUi and release its interfaces.
Rml::Sprite metadata copied before insertion can invalidate native pointers.
Rml::SpriteDefinitionList, ordered sprite name and pixel rectangle pairs.
Rml::SpriteMap with sprite names as keys.
Pixel corners of a native Rml::Rectanglef sprite region.
Copied Rml::Spritesheet metadata with an independently owned texture source.
Owned Rml::SpritesheetList preserving native overwrite and merge behavior.
Checked Rml::Stream with native memory, file or synchronous JS storage.
Synchronous implementations of Rml::Stream virtual methods.
Read-only Rml::StreamFile using the installed RmlUi file interface.
Rml::StreamMemory backed by native-owned bytes.
Rml::Stream mode bits.
UTF-8 text or a retained immutable native byte view.
Managed Rml::StringIteratorU8 with one cached native index per byte view.
Native Rml::StringUtilities with UTF-8 byte and codepoint positions.
Rml::StringView with immutable native backing retained by every slice.
Native computed style types, values and resolution functions.
The computed flex line alignment.
The computed default flex item alignment.
The computed individual flex item alignment.
The computed size calculation box.
The computed float clearance.
Native Rml::Style::Clip with its encoded signed-byte semantics.
The computed ancestor clipping control.
Owned storage for common layout and border properties.
The computed text reading direction.
The computed layout box generation.
The computed drag interaction.
The computed flex main axis direction.
The computed flex line wrapping.
The computed float placement.
The computed focus eligibility.
The computed font kerning.
The computed font slant.
The computed font weight.
Owned storage for inherited text, colour and input properties.
The computed flex main axis alignment.
A length in pixels or a percentage of a reference size.
A length in pixels, a percentage, or automatic sizing.
A length in pixels, a percentage, or automatic sizing.
A length in pixels or a percentage of a reference size.
Computed line height in pixels together with its inherited number or length.
Computed line height in pixels together with its inherited number or length.
The computed directional keyboard navigation.
A numeric value or the automatic keyword, used for stacking order.
A numeric value or the automatic keyword, used for stacking order.
The computed horizontal transform origin.
The computed vertical transform origin.
The computed overflow handling.
The computed scroll chaining.
The computed pointer hit testing.
The computed positioning scheme.
Owned storage for less common layout, transform and effect properties.
Rml::ResolveValue for either computed length type.
Rml::ResolveValueOr for either computed length type.
The computed sequential keyboard focus.
The computed text horizontal alignment.
The computed text decoration line.
The computed text overflow marker.
The computed text case conversion.
An inline vertical alignment keyword or pixel offset.
An inline vertical alignment keyword or pixel offset.
The computed visibility.
The computed whitespace and wrapping.
The computed word breaking.
Native Rml::Style::Display.
Native Rml::Style::Float.
Native Rml::Style::Position.
Rml::StyleSheet: a checked compiled view or an owned combination.
Owned or read-only shared Rml::StyleSheetContainer.
Rml::StyleSheetSpecification, the runtime's global RCSS registry.
Optional synchronous system virtual implementations.
Native clipboard read callback.
Native-owned SFML system interface with optional host virtuals.
Native resource path callback.
Native log decision callback.
Native translation callback.
Projected text-area bounds in screen pixels.
Optional explicit host callbacks for native text-input lifecycle events.
Checked native Rml::TextInputContext for a live input or textarea widget.
Native lifecycle batch. Kinds are 0 activate, 1 deactivate, 2 destroy.
Native Rml::TextInputHandler with batched lifecycle notifications.
Character range in Unicode code points, with an exclusive end.
Copy of Rml::ElementText::Line.
Copied native text selection, in Unicode code points rather than UTF-16.
Owned Rml::TextShapingContext language and shared numerical fields.
Rml::Texture view retaining its native render manager.
Rml::TexturedMesh aggregate of native mesh storage and a texture view.
Ordered Rml::TexturedMeshList represented by typed native-resource records.
Owned SFML texture token for Rml::CallbackTextureInterface::SetTextureHandle.
Native Rml::TextureSource with per-manager lazy texture caching.
A point in a Rml::TouchList, used by direct context touch input.
Native-owned Rml::Transform with copied primitive access.
Primitive types with ordered component arrays.
Native transform functions shared by every model using one type register.
All 22 native primitives as a discriminated union of copied fields.
Array primitive snapshot preserving its native discriminator and arity.
Exact Rml::TransformPrimitive::Type discriminators.
Exact native component tuple selected by the primitive type.
Owned TransformPtr snapshot; null primitives preserve a null native pointer.
Rml::TransformState, independently owned or a read-only element view.
Property transition settings: target property, duration, delay and easing.
Native Transition equality; negation represents operator!=.
Tagged Rml::TransitionList, preserving none/all independently of entries.
Native TransitionList equality; negation represents operator!=.
Native TranslateString output and number of substitutions.
Native Rml::Tween, copied into animation keys.
Synchronous callback, with native float32 input and finite float32 output.
Select whether easing applies at the start, end, or both ends of a tween.
Unambiguous second type for the native (Type, Type) overload.
Rml::Tween::Type easing families.
Rml::Unit flags. Combine and intersect sets with JavaScript | and &.
Rml::Units: a set of Unit flags.
Unregister Rml::Plugin, returning whether a registration was removed.
Native Rml::URL resource parser, independent of runtime initialisation.
Native-owned Rml::Variant with shared type metadata.
Native GetInto result, including destination changes on conversion failure.
Exact Rml::Variant::Type values, matching the upstream character codes.
RmlUi version reported by the native library.
Typed view of a native Rml::Vertex allocation.
Rml::ColourbPremultiplied channels, each an integer from 0 through 255.
Absent member callback, corresponding to native VoidMemberFunc.
Owned copy of Rml::XMLAttributes; parser-produced attributes contain strings.
One native text, CDATA, or captured-markup event.
Rml::XMLDataType values used by the native parser.
One native end-tag event in a batched parse result.
Checked native XML node handler, owned or borrowed from the registry.
Synchronous implementations of all Rml::XMLNodeHandler virtuals.
Ordered native XML event snapshot.
Owned snapshot of Rml::XMLParser::ParseFrame with checked references.
Native Rml::XMLParser with retained root ownership.
Source positions recorded by native XML parsing.
One native start-tag event in a batched parse result.
RML loading, element properties and native lifetimes.
Loaded RmlUi document wrapper.
Checked wrapper around an RmlUi-owned element.
Copied outputs of Rml::Element::GetIntrinsicDimensions.
Copied event payloads and JavaScript listener signatures.
JavaScript event listener.
JavaScript event listener.
Rml::Colourb snapshot with integer channels from 0 through 255.
Native Rml::Character enum. Storage uses INT64; conversion returns uint32.
Tagged Rml::Colourb or Rml::Colourf, preserving the native colour type.
Native conversion default, including destinations without Variant storage.
Owned non-null value selecting a native Variant conversion template.
Explicit signed or unsigned 64-bit Variant storage or conversion selector.
Integer vector template destination. Rml::Variant cannot store this type.
Explicit numeric Variant storage or conversion selector.
Original host object with checked native opaque-pointer provenance. Its hidden native identity is independent of the object's public fields.
Owned opaque host object selecting native void* storage and conversion.
Native Variant output, including the original object of an opaque pointer. Native provenance allows an opaque output to be stored again. Arbitrary host objects first require a voidptr selector.
Result type selected by a default value, widening primitive literals.
Original JS identity registered by a Native ScriptInterface owner. Copies retain its guarded pointer; the extension controls native lifetime.
Guarded native ScriptInterface pointer storage and GetInto destination.
Supported Rml::Variant values. Native 64-bit integers retain exact BigInt values; native script owners retain identity. Arbitrary pointers are rejected.
Two-component Rml::Vector2f value; components round to native float.
Three-component Rml::Vector3f value.
Four-component Rml::Vector4f value.
Initialise RmlUi with SFML-backed system and render interfaces.