Struct MjViewerCpp 

pub struct MjViewerCpp<'m> { /* 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 MjViewer instead.

Implementations

impl<'m> MjViewerCpp<'m>

pub fn running(&self) -> bool

Examples found in repository

examples/cpp_viewer.rs (line 30)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewerCpp::launch_passive(&model, &data, 100);
    let step = model.ffi().opt.timestep;
    while viewer.running() {
        viewer.sync();
        viewer.render(true);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(step));
    }
}

pub fn user_scn_mut(&mut self) -> &mut MjvScene<'m>

pub fn launch_passive( model: &'m MjModel, data: &MjData<'_>, scene_max_geom: usize, ) -> Self

Launches a wrapper around MuJoCo’s C++ viewer. The scene_max_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 (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

To allow certain flexibility, while still maintaining compatibility with the C++ code, MjViewerCpp keeps internals pointers to mjModel and mjData, which are wrapped inside MjModel and MjData, respectively. This technically allows model and data to be modified while the viewer keeps a pointer to them (their wrapped pointers). Undefined behavior should not occur, however caution is advised as this is a violation of the Rust’s borrowing rules.

Examples found in repository

examples/cpp_viewer.rs (line 28)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewerCpp::launch_passive(&model, &data, 100);
    let step = model.ffi().opt.timestep;
    while viewer.running() {
        viewer.sync();
        viewer.render(true);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(step));
    }
}

pub fn __raw(&self) -> *mut mujoco_Simulate

Returns the underlying C++ binding object of the viewer.

pub fn render(&mut self, update_timer: bool)

Renders the simulation. update_timer flag species whether the time should be updated inside the viewer (for vsync purposes).

SAFETY

This needs to be called periodically from the MAIN thread, otherwise GLFW stops working.

Examples found in repository

examples/cpp_viewer.rs (line 32)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewerCpp::launch_passive(&model, &data, 100);
    let step = model.ffi().opt.timestep;
    while viewer.running() {
        viewer.sync();
        viewer.render(true);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(step));
    }
}

pub fn sync(&mut self)

Syncs the simulation state with the viewer as well as perform rendering on the viewer.

Examples found in repository

examples/cpp_viewer.rs (line 31)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewerCpp::launch_passive(&model, &data, 100);
    let step = model.ffi().opt.timestep;
    while viewer.running() {
        viewer.sync();
        viewer.render(true);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(step));
    }
}

Trait Implementations

impl Drop for MjViewerCpp<'_>

fn drop(&mut self)

Executes the destructor for this type.