Extracting model geometry

[stillonearth]

I'm trying to implement a basic MJCF model loader for a bevy game engine. For that I would need to extract geometry from a loaded model and export it to the engine. Can anyone point to a right direction or an example?

[yuvaltassa]

Everything you need is in mjModel. Probably mjModel.geom_xxx and mjModel.mesh_xxx.
If you say more specifically what you mean by "geometry" I could give you more details.

[stillonearth]

Thanks, that worked for primitive geometry but I'm failing to locate filenames of the models referred in <asset> in mjcf file.

[yuvaltassa]

The filenames have already been compiled away, but why do you need them? As I said, the geometry data is all in mjModel.mesh_xxx

[stillonearth]

I'm using MuJoCo as physics engine in another game engine that supports loading obj natively. Idea was to rely on MuJoCo for mjcf parsing, scene generation and implement higher-order logic in game engine.

[yuvaltassa]

In this case, maybe just set mesh name == filename ?
This is actually the default behaviour if you don't set the mesh name, except that the extensions are stripped.

[stillonearth]

That worked fine.

[stillonearth]

I assume all 3-vectors and quaternions are within their parent inertial systems and need to be adjusted over their tree path?

I've tried body_ipos and body_iquat for world inertial system but that didn't work.

mjcModel

    mjtNum*   body_pos;             // position offset rel. to parent body      (nbody x 3)
    mjtNum*   body_quat;            // orientation offset rel. to parent body   (nbody x 4)
    mjtNum*   body_ipos;            // local position of center of mass         (nbody x 3)
    mjtNum*   body_iquat;           // local orientation of inertia ellipsoid   (nbody x 4)
    mjtNum*   body_mass;            // mass                                     (nbody x 1)

mjcData

    mjtNum*   xpos;                 // Cartesian position of body frame         (nbody x 3)
    mjtNum*   xquat;                // Cartesian orientation of body frame      (nbody x 4)

Do these take into account initial pos and quat of the body?

[yuvaltassa]

Variable names that start with x are in the global frame. This is documented here.

[stillonearth]

How to extract visual geometry corresponding to a body?

With this I can extract a list of geoms, but I'm unable to select one for rendering.

// bodies
int*      body_geomnum;         // number of geoms                          (nbody x 1)
int*      body_geomadr;         // start addr of geoms; -1: no geoms        (nbody x 1)

// geoms
int*      geom_type;            // geometric type (mjtGeom)                 (ngeom x 1)
int*      geom_bodyid;          // id of geom's body                        (ngeom x 1)
int*      geom_group;           // group for visibility                     (ngeom x 1)

There's a class property in MJCF

<geom class="visual" mesh="trunk" material="carbonfibre"/>

which doesn't seem to exist in geom_* properties of a model

[yuvaltassa]

Look at the class definition, it's setting something that makes the geom in/visible, presumably geom_group.

[stillonearth]

Assuming default visibility groups {0, 1, 2} this worked by filtering out the rest. Not sure about correctness of this.

[stillonearth]

Assuming geom's pos is an offset to a body's pos I get following result

With geom's pos ignored the picture seems to be correct

Is it safe to ignore geom's position and rotation corrections or am I missing something?

this is https://github.com/deepmind/mujoco_menagerie/tree/main/unitree_a1 and aftermentioned example is https://github.com/stillonearth/bevy_mujoco/blob/main/python/a1.ipynb

[yuvaltassa]

• model.geom_pos is w.r.t the parent body frame.
• model.body_pos is also w.r.t the body's parent body frame
• data.geom_xpos is w.r.t the global frame.

[yuvaltassa]

• model.geom_pos is w.r.t the parent body frame.
• model.body_pos is also w.r.t the body's parent body frame
• data.geom_xpos is w.r.t the global frame.

[stillonearth]

A shameless plug. So artifact came out from this thread is bevy_mujoco, a plugin for Rust bevy engine. It's useful for tasks like novel environments and rapid prototyping.