Struct MjViewerCpp 

pub struct MjViewerCpp { /* private fields */ }

Wrapper around the C++ implementation of MuJoCo viewer. If you don’t need the side UI, we recommend you use the Rust-native viewer crate::viewer::MjViewer instead.

Safety

Calls to MjViewerCpp::render must be done only on the main thread! For convenience MjViewerCpp implements both Send and Sync, however that is meant only for syncing the viewer.

MjViewerCpp::launch_passive keeps internal pointers to mjModel and mjData. The caller must ensure both remain alive and at a fixed address for the viewer’s lifetime. See MjViewerCpp::launch_passive for the full safety contract.

Implementations

impl MjViewerCpp

pub fn running(&self) -> bool

Returns whether the viewer window is still open.

pub fn user_scn_mut(&mut self) -> &mut MjvScene

Returns a mutable reference to the user scene for drawing custom visual-only geoms.

pub unsafe fn launch_passive<M: ModelType + Clone + Send + Sync>( model: M, data: &MjData<M>, max_user_geom: usize, ) -> Self

Launches a wrapper around MuJoCo’s C++ viewer. The max_user_geom parameter defines how much space will be allocated for additional, user-defined visual-only geoms. It can thus be set to 0 if no additional geoms will be drawn by the user. Unlike the Rust-native viewer (crate::viewer::MjViewer), this also accepts a data parameter. Additionally, this just returns a MjViewerCpp instance directly, without result as the initialization may fail internally in C++ anyway, which we have no way of checking.

Safety

The caller must ensure that both model and data remain alive and at a stable memory address for the entire lifetime of the returned MjViewerCpp. Dropping or moving the underlying MjModel or MjData while the viewer is alive is undefined behavior. MjViewerCpp::launch_passive itself performs the OpenGL initialization and render steps, so it and MjViewerCpp::render must be called only on the main thread. The viewer writes through both pointers, so the caller must treat model and data as mutably borrowed by the viewer, and must not access them while MjViewerCpp::sync runs.

Panics

Panics if the load thread panics.

pub unsafe fn render(&mut self) -> Result<(), &'static str>

Renders the simulation.

Errors

Returns Err when called after the viewer has already been closed. The call that detects the close event still returns Ok(()) and flips the internal running state to false.

Safety

Must be called from the main thread. GLFW requires main-thread access; calling from any other thread causes undefined behaviour.

pub fn sync(&mut self)

Syncs the simulation state with the viewer. The transfer runs in both directions.

Trait Implementations

impl Debug for MjViewerCpp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for MjViewerCpp

Requests viewer exit and destroys the underlying C++ simulation handle.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for MjViewerCpp

Safety

Rendering must only be performed on the main thread. Send is provided so the viewer handle can be moved to another thread that only calls MjViewerCpp::sync.

impl Sync for MjViewerCpp

Safety

The viewer is safe to share across threads for syncing, but rendering must only be done on the main thread. See MjViewerCpp for the full contract.