File size: 6,039 Bytes
2c55b92 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | .. _UI:
User Interface
--------------
MuJoCo has a native UI framework. Its use is illustrated in the :ref:`simulate.cc <saSimulate>` viewer. It is
designed to be fast in terms of updating and rendering, easy to use both for the developer and for the user,
cross-platform, and integrated with the native MuJoCo renderer. In order to achieve these design goals, we have omitted
many features and customization options that are available in other UI frameworks, and instead focused on efficiency and
automation.
.. _uiDesign:
Design overview
~~~~~~~~~~~~~~~
Native OpenGL rendering
We do not use any helper tools or libraries. Instead we provide C code for rendering all UI elements directly in
OpenGL. We support multiple UIs, each of which is a virtual rectangle that can be taller than the visible window. The
elements of each UI are rendered offscreen in auxiliary OpenGL buffers, via minimal updates, only when changes are
necessary. At each screen refresh we then copy the pixels from these auxiliary buffers to the window framebuffer, and
also implement vertical scroll bars when the window is smaller than the UI. This copy operation is done on the GPU and
is very fast.
Platform abstraction
The software design has 3 layers: OpenGL rendering of UI elements working in conjunction with the MuJoCo renderer
(which is fully cross-platform); abstract functions for access to windows, keyboard and mouse, defined as pure virtual
functions in the ``PlatformUIAdapter`` class; and an implementation of those functions in the derived class
``GlfwAdapter``. `GLFW <https://www.glfw.org/>`__ itself is cross-platform. Nevertheless, we have opted for this
layered design in order to separate generic from platform-specific functionality. If GLFW needs to be replaced with
another similar framework for some reason, only ``GlfwAdapter`` will need to be rewritten.
Themes and appearance
Individual UI elements do not allow customization in terms of appearance or layout. Instead, we use themes for colors
and spacing, and arrange all UI elements automatically. Several built-in themes are provided and the user can design
custom themes, however the entire UI uses a single theme for all elements. Appearance is minimalist: mostly colored
rectangles with text. Bitmaps and other custom decorations are not supported. The UI element types are check boxes,
radio button groups, selection lists, sliders, text edit boxes, static text, buttons, separators. These elements are
grouped into sections which can be expanded and collapsed.
Layout and rectangles
Each UI is one virtual rectangle, whose width is determined by the theme and whose height is determined by the
sections, items within each section, and also the expand/collapse state of each section. The sizes and auxiliary
buffers for these virtual rectangles are handled automatically when the UI is updated. Each UI has a visible rectangle
on the screen, and in addition there are other rectangles -- for 3D rendering, 2D figures, and possibly custom OpenGL
rendering. All these visible rectangles are saved (in :ref:`mjuiState`) and are used to determine where mouse events
should be directed. The rectangle layout is updated by a callback provided by the user.
Static allocation and creation
Rather than allocating and deallocating a large number of objects corresponding to UI elements and linking them
together, we create a single C struct (type :ref:`mjUI`) with static allocation supporting some maximum number of
sections and elements; and then keep a record of how many are in use. UI creation is simplified by helper functions
whose input is a C struct (type :ref:`mjuiDef`) that is essentially a table where each row describes one UI element
(see below). This makes it possible to construct elaborate user interfaces with surprisingly little C code.
Programmatic UI creation is also possible, for example when populating a UI with sliders corresponding to MuJoCo model
joints.
Minimal state
The UI is designed to be as stateless as possible, so as to simplify development. This has two aspects. First, instead
of replicating user data within the UI elements, we store pointers to user data. For example, we might create a UI
slider and set its data pointer to ``mjData* d->qpos+7``. This slider will visualize as well as control the 7th scalar
component of the qpos vector of a MuJoCo model. Thus, when the simulation is updated, we have to remember to update
the UI as well. And furthermore we have to disable UI editing when the simulation is being updated. But the advantage
is that the UI becomes easier to construct, and there is no danger of discrepancies between user data and the UI.
Second, the UI elements themselves are mostly stateless. Instead we keep track of a minimal set of global states, in
particular mouse and keyboard state, section expand/collapse, contents of the text box being edited if any.
Automated enable and disable
While each UI item can be set in enabled or disabled state directly, we also provide automation as follows. Each UI
item can be assigned an integer category. Then a :ref:`mjfItemEnable` callback determines whether each category should
be enabled or disabled, based on some program-specific conditions. For example, sliders that can change the values of
MuJoCo model joints should be disabled when the simulation state is being updated.
.. _uiAPI:
Main API
~~~~~~~~
Click on the links below for detailed API reference of the main UI data structures and functions.
**Main data structures:**
- :ref:`mjUI<mjUI>`: An entire UI.
- :ref:`mjuiState<mjuiState>`: Global UI state.
- :ref:`mjuiDef<mjuiDef>`: One entry in the definition table used for UI construction.
**Main functions:**
- :ref:`mjui_update<mjui_update>`: Main UI update function.
- :ref:`mjui_render<mjui_render>`: Renders the UI.
- :ref:`mjui_event<mjui_event>`: Low-level event handler.
- :ref:`mjui_add<mjui_add>`: Helper function used to construct a UI.
|