Struct MjViewer 

pub struct MjViewer<'m> { /* private fields */ }

A Rust-native implementation of the MuJoCo viewer. To confirm to rust safety rules, the viewer doesn’t store a mutable reference to the MjData struct, but it instead accepts it as a parameter at its methods.

Currently supported (to be expanded in the future):

• Visualization of the 3D scene,
• Close via Ctrl + Q or by closing the window,
• Body tracking via Ctrl + Alt + double left click,
• Camera look at object via Alt + double left click,
• Escape from tracked camera via Esc.
• Perturbations:
  • Select the object of interested by double clicking on it,
  • Hold down Control and start dragging for rotational perturbations,
  • Hold down Control+Alt and start dragging for translational perturbations,
  • To move in the XY plane instead of the default XZ plane, hold Shift.

The MjViewer::sync method must be called to sync the state of MjViewer and MjData.

Safety

Due to the nature of OpenGL, this should only be run in the main thread.

Implementations

impl<'m> MjViewer<'m>

pub fn launch_passive( model: &'m MjModel, scene_max_geom: usize, ) -> Result<Self, MjViewerError>

Launches the MuJoCo viewer. A Result struct is returned that either contains MjViewer or a MjViewerError. 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.

Examples found in repository

examples/rust_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 = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");
    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_millis(2));
    }
}

examples/tendon.rs (line 43)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/ffi_attributes.rs (line 38)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");

    /******************************************/
    /* Access a FFI attribute */
    let timestep = model.ffi().opt.timestep;
    /******************************************/

    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");

    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

examples/touch_sensor.rs (line 38)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    let sensor_data_info = data.sensor("touch").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Print the touch sensor output, which is the contact force */
        println!("{}", sensor_data_info.view(&data).data[0]);

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/joint_view.rs (line 32)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    /* Create the joint info */
    let ball_info = data.joint("ball_joint").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Obtain the view and access first three variables of `qpos` (x, y, z) */
        let xyz = &ball_info.view(&data).qpos[..3];
        println!("The ball's position is: {xyz:.2?}");

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/drawing_scene.rs (lines 38-41)

fn main() {
    /* Create model and data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(
        &model,
        10  // create space for 10 visual-only geoms
    )
        .expect("could not launch the viewer");

    /* Obtain joint info */
    let ball1_joint_info = data.joint("ball1_joint").unwrap();
    let ball2_joint_info = data.joint("ball2_joint").unwrap();

    /* Give the first ball some y-velocity to showcase the visualization */
    ball1_joint_info.view_mut(&mut data).qvel[1] = 2.0;

    let timestep = model.ffi().opt.timestep;
    let mut user_scn;
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Prepare the scene */
        user_scn = viewer.user_scn_mut();  // obtain a mutable reference to the user scene. The method name mirrors the C++ viewer.
        user_scn.clear_geom();  // clear existing geoms

        /* Create a line, that (visually) connects the two balls we have in the example model */
        let new_geom = user_scn.create_geom(
            MjtGeom::mjGEOM_LINE,  // type of geom to draw.
            None,  // size, ignore here as we set it below.
            None,   // position: ignore here as we set it below.
            None,   // rotational matrix: ignore here as we set it below.
            Some([1.0, 1.0, 1.0, 1.0])  // color (rgba): pure white.
        );

        /* Read X, Y and Z coordinates of both balls. */
        let ball1_position = ball1_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();
        let ball2_position = ball2_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();

        /* Modify the visual geom's position, orientation and length, to connect the balls */
        new_geom.connect(
            0.0,            // width
            ball1_position,  // from
            ball2_position     //  to
        );

        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

pub fn running(&self) -> bool

Checks whether the window is still open.

Examples found in repository

examples/rust_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 = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");
    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_millis(2));
    }
}

examples/tendon.rs (line 46)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/ffi_attributes.rs (line 41)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");

    /******************************************/
    /* Access a FFI attribute */
    let timestep = model.ffi().opt.timestep;
    /******************************************/

    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");

    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

examples/touch_sensor.rs (line 42)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    let sensor_data_info = data.sensor("touch").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Print the touch sensor output, which is the contact force */
        println!("{}", sensor_data_info.view(&data).data[0]);

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/joint_view.rs (line 37)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    /* Create the joint info */
    let ball_info = data.joint("ball_joint").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Obtain the view and access first three variables of `qpos` (x, y, z) */
        let xyz = &ball_info.view(&data).qpos[..3];
        println!("The ball's position is: {xyz:.2?}");

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/drawing_scene.rs (line 53)

fn main() {
    /* Create model and data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(
        &model,
        10  // create space for 10 visual-only geoms
    )
        .expect("could not launch the viewer");

    /* Obtain joint info */
    let ball1_joint_info = data.joint("ball1_joint").unwrap();
    let ball2_joint_info = data.joint("ball2_joint").unwrap();

    /* Give the first ball some y-velocity to showcase the visualization */
    ball1_joint_info.view_mut(&mut data).qvel[1] = 2.0;

    let timestep = model.ffi().opt.timestep;
    let mut user_scn;
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Prepare the scene */
        user_scn = viewer.user_scn_mut();  // obtain a mutable reference to the user scene. The method name mirrors the C++ viewer.
        user_scn.clear_geom();  // clear existing geoms

        /* Create a line, that (visually) connects the two balls we have in the example model */
        let new_geom = user_scn.create_geom(
            MjtGeom::mjGEOM_LINE,  // type of geom to draw.
            None,  // size, ignore here as we set it below.
            None,   // position: ignore here as we set it below.
            None,   // rotational matrix: ignore here as we set it below.
            Some([1.0, 1.0, 1.0, 1.0])  // color (rgba): pure white.
        );

        /* Read X, Y and Z coordinates of both balls. */
        let ball1_position = ball1_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();
        let ball2_position = ball2_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();

        /* Modify the visual geom's position, orientation and length, to connect the balls */
        new_geom.connect(
            0.0,            // width
            ball1_position,  // from
            ball2_position     //  to
        );

        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

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

Returns an immutable reference to a user scene for drawing custom visual-only geoms.

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

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

Examples found in repository

examples/drawing_scene.rs (line 59)

fn main() {
    /* Create model and data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(
        &model,
        10  // create space for 10 visual-only geoms
    )
        .expect("could not launch the viewer");

    /* Obtain joint info */
    let ball1_joint_info = data.joint("ball1_joint").unwrap();
    let ball2_joint_info = data.joint("ball2_joint").unwrap();

    /* Give the first ball some y-velocity to showcase the visualization */
    ball1_joint_info.view_mut(&mut data).qvel[1] = 2.0;

    let timestep = model.ffi().opt.timestep;
    let mut user_scn;
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Prepare the scene */
        user_scn = viewer.user_scn_mut();  // obtain a mutable reference to the user scene. The method name mirrors the C++ viewer.
        user_scn.clear_geom();  // clear existing geoms

        /* Create a line, that (visually) connects the two balls we have in the example model */
        let new_geom = user_scn.create_geom(
            MjtGeom::mjGEOM_LINE,  // type of geom to draw.
            None,  // size, ignore here as we set it below.
            None,   // position: ignore here as we set it below.
            None,   // rotational matrix: ignore here as we set it below.
            Some([1.0, 1.0, 1.0, 1.0])  // color (rgba): pure white.
        );

        /* Read X, Y and Z coordinates of both balls. */
        let ball1_position = ball1_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();
        let ball2_position = ball2_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();

        /* Modify the visual geom's position, orientation and length, to connect the balls */
        new_geom.connect(
            0.0,            // width
            ball1_position,  // from
            ball2_position     //  to
        );

        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

pub fn sync(&mut self, data: &mut MjData<'_>)

Syncs the state of data with the viewer as well as perform rendering on the viewer.

Examples found in repository

examples/rust_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 = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");
    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_millis(2));
    }
}

examples/tendon.rs (line 48)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/ffi_attributes.rs (line 42)

fn main() {
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");

    /******************************************/
    /* Access a FFI attribute */
    let timestep = model.ffi().opt.timestep;
    /******************************************/

    let mut data = model.make_data();  // or MjData::new(&model);
    let mut viewer = MjViewer::launch_passive(&model, 100)
        .expect("could not launch the viewer");

    while viewer.running() {
        viewer.sync(&mut data);
        data.step();
        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

examples/touch_sensor.rs (line 44)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    let sensor_data_info = data.sensor("touch").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Print the touch sensor output, which is the contact force */
        println!("{}", sensor_data_info.view(&data).data[0]);

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/joint_view.rs (line 39)

fn main() {
    /* Load the model and create data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();  // or MjData::new(&model);

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(&model, 0)
        .expect("could not launch the viewer");

    /* Create the joint info */
    let ball_info = data.joint("ball_joint").unwrap();
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Obtain the view and access first three variables of `qpos` (x, y, z) */
        let xyz = &ball_info.view(&data).qpos[..3];
        println!("The ball's position is: {xyz:.2?}");

        std::thread::sleep(Duration::from_secs_f64(0.002));
    }
}

examples/drawing_scene.rs (line 55)

fn main() {
    /* Create model and data */
    let model = MjModel::from_xml_string(EXAMPLE_MODEL).expect("could not load the model");
    let mut data = model.make_data();

    /* Launch a passive Rust-native viewer */
    let mut viewer = MjViewer::launch_passive(
        &model,
        10  // create space for 10 visual-only geoms
    )
        .expect("could not launch the viewer");

    /* Obtain joint info */
    let ball1_joint_info = data.joint("ball1_joint").unwrap();
    let ball2_joint_info = data.joint("ball2_joint").unwrap();

    /* Give the first ball some y-velocity to showcase the visualization */
    ball1_joint_info.view_mut(&mut data).qvel[1] = 2.0;

    let timestep = model.ffi().opt.timestep;
    let mut user_scn;
    while viewer.running() {
        /* Step the simulation and sync the viewer */
        viewer.sync(&mut data);
        data.step();

        /* Prepare the scene */
        user_scn = viewer.user_scn_mut();  // obtain a mutable reference to the user scene. The method name mirrors the C++ viewer.
        user_scn.clear_geom();  // clear existing geoms

        /* Create a line, that (visually) connects the two balls we have in the example model */
        let new_geom = user_scn.create_geom(
            MjtGeom::mjGEOM_LINE,  // type of geom to draw.
            None,  // size, ignore here as we set it below.
            None,   // position: ignore here as we set it below.
            None,   // rotational matrix: ignore here as we set it below.
            Some([1.0, 1.0, 1.0, 1.0])  // color (rgba): pure white.
        );

        /* Read X, Y and Z coordinates of both balls. */
        let ball1_position = ball1_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();
        let ball2_position = ball2_joint_info.view(&data).qpos[..3]
            .try_into().unwrap();

        /* Modify the visual geom's position, orientation and length, to connect the balls */
        new_geom.connect(
            0.0,            // width
            ball1_position,  // from
            ball2_position     //  to
        );

        std::thread::sleep(Duration::from_secs_f64(timestep));
    }
}

Trait Implementations

impl<'m> Debug for MjViewer<'m>

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

Formats the value using the given formatter.