mujoco 3.4.0__tar.gz → 3.6.0__tar.gz

{mujoco-3.4.0/mujoco.egg-info → mujoco-3.6.0}/PKG-INFO

@@ -1,24 +1,24 @@
 Metadata-Version: 2.4
 Name: mujoco
-Version: 3.4.0
+Version: 3.6.0
 Summary: MuJoCo Physics Simulator
 Author-email: Google DeepMind <mujoco@deepmind.com>
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/google-deepmind/mujoco
-Project-URL: Documentation, https://mujoco.readthedocs.io/en/3.4.0
+Project-URL: Documentation, https://mujoco.readthedocs.io/en/3.6.0
 Project-URL: Repository, https://github.com/google-deepmind/mujoco
-Project-URL: Changelog, https://mujoco.readthedocs.io/en/3.4.0/changelog.html
+Project-URL: Changelog, https://mujoco.readthedocs.io/en/3.6.0/changelog.html
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: LICENSES_THIRD_PARTY.md
@@ -27,6 +27,17 @@ Requires-Dist: etils[epath]
 Requires-Dist: glfw
 Requires-Dist: numpy
 Requires-Dist: pyopengl
+Provides-Extra: sysid
+Requires-Dist: absl-py; extra == "sysid"
+Requires-Dist: colorama; extra == "sysid"
+Requires-Dist: imageio[ffmpeg]; extra == "sysid"
+Requires-Dist: jinja2; extra == "sysid"
+Requires-Dist: matplotlib; extra == "sysid"
+Requires-Dist: plotly; extra == "sysid"
+Requires-Dist: pyyaml; extra == "sysid"
+Requires-Dist: scipy; extra == "sysid"
+Requires-Dist: tabulate; extra == "sysid"
+Requires-Dist: typing_extensions; extra == "sysid"
 Provides-Extra: usd
 Requires-Dist: usd-core; extra == "usd"
 Requires-Dist: pillow; extra == "usd"

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/CMakeLists.txt

@@ -51,6 +51,8 @@ endif()
 
 include(MujocoLinkOptions)
 get_mujoco_extra_link_options(EXTRA_LINK_OPTIONS)
+list(FILTER EXTRA_LINK_OPTIONS EXCLUDE REGEX "STACK")
+list(FILTER EXTRA_LINK_OPTIONS EXCLUDE REGEX "stack")
 add_link_options(${EXTRA_LINK_OPTIONS})
 
 include(MujocoMacOS)
@@ -84,7 +86,7 @@ if(NOT TARGET mujoco)
     if(MUJOCO_FRAMEWORK)
       message("MuJoCo framework is at ${MUJOCO_FRAMEWORK}/mujoco.framework")
       set(MUJOCO_LIBRARY
-          ${MUJOCO_FRAMEWORK}/mujoco.framework/Versions/A/libmujoco.3.4.0.dylib
+          ${MUJOCO_FRAMEWORK}/mujoco.framework/Versions/A/libmujoco.3.6.0.dylib
       )
       target_compile_options(mujoco INTERFACE -F${MUJOCO_FRAMEWORK})
     endif()
@@ -92,7 +94,7 @@ if(NOT TARGET mujoco)
 
   if(NOT MUJOCO_FRAMEWORK)
     find_library(
-      MUJOCO_LIBRARY mujoco mujoco.3.4.0 HINTS ${MUJOCO_LIBRARY_DIR} REQUIRED
+      MUJOCO_LIBRARY mujoco mujoco.3.6.0 HINTS ${MUJOCO_LIBRARY_DIR} REQUIRED
     )
     find_path(MUJOCO_INCLUDE mujoco/mujoco.h HINTS ${MUJOCO_INCLUDE_DIR} REQUIRED)
     message("MuJoCo is at ${MUJOCO_LIBRARY}")
@@ -140,7 +142,7 @@ findorfetch(
   GIT_REPO
   https://github.com/abseil/abseil-cpp
   GIT_TAG
-  d38452e1ee03523a208362186fd42248ff2609f6 # LTS 20250814.1
+  255c84dadd029fd8ad25c5efb5933e47beaa00c7 # LTS 20250814.1
   TARGETS
   ${MUJOCO_PYTHON_ABSL_TARGETS}
   EXCLUDE_FROM_ALL
@@ -173,7 +175,7 @@ findorfetch(
   GIT_REPO
   https://gitlab.com/libeigen/eigen
   GIT_TAG
-  49623d0c4e1af3c680845191948d10f6d3e92f8a
+  75bcd155c40cb48e647c87c3f29052360255bc9e
   TARGETS
   Eigen3::Eigen
   EXCLUDE_FROM_ALL

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/__init__.py

@@ -56,11 +56,23 @@ from mujoco._constants import *
 from mujoco._enums import *
 from mujoco._errors import *
 from mujoco._functions import *
-from mujoco._render import *
 from mujoco._specs import *
 from mujoco._structs import *
-from mujoco.gl_context import *
-from mujoco.renderer import Renderer
+
+try:
+  from mujoco._render import *  # pytype: disable=import-error
+except ImportError:
+  pass
+
+try:
+  from mujoco.rendering.classic.renderer import Renderer  # pytype: disable=import-error
+except ImportError:
+  pass
+
+try:
+  from mujoco.rendering.classic.gl_context import *  # pytype: disable=import-error
+except ImportError:
+  pass
 
 MjStruct: TypeAlias = Union[
     _specs.MjsBody,

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/bindings_test.py

@@ -495,6 +495,15 @@ class MuJoCoBindingsTest(parameterized.TestCase):
     mujoco.mj_forward(self.model, data_copy)
     self.assertEqual(data_copy.ncon, 4)
 
+    # Test copying into existing data.
+    data_copy.qpos[1] = 1.234
+    data_copy.geom_xpos[2] = 5.678
+    self.assertFalse(np.array_equal(self.data.qpos, data_copy.qpos))
+    self.assertFalse(np.array_equal(self.data.geom_xpos, data_copy.geom_xpos))
+    mujoco.mj_copyData(self.data, self.model, data_copy)
+    np.testing.assert_array_equal(self.data.qpos, data_copy.qpos)
+    np.testing.assert_array_equal(self.data.geom_xpos, data_copy.geom_xpos)
+
   def test_mjdata_can_read_warning_array(self):
     warnings = self.data.warning
     self.assertLen(warnings, mujoco.mjtWarning.mjNWARNING)
@@ -1279,8 +1288,9 @@ Euler integrator, semi-implicit in velocity.
     geomid = np.zeros(1, np.int32)
     mujoco.mj_forward(self.model, self.data)
     mujoco.mj_ray(
-        self.model, self.data, [0, 0, 0], [0, 0, 1], None, 0, 0, geomid
+        self.model, self.data, [0, 0, 0], [0, 0, 1], None, 0, 0, geomid, None
     )
+    # Check the normal argument is optional
     mujoco.mj_ray(
         self.model,
         self.data,
@@ -1292,6 +1302,7 @@ Euler integrator, semi-implicit in velocity.
         geomid,
     )
     # Check that named arguments work
+    normal = np.zeros(3, np.float64)
     mujoco.mj_ray(
         m=self.model,
         d=self.data,
@@ -1301,7 +1312,33 @@ Euler integrator, semi-implicit in velocity.
         flg_static=0,
         bodyexclude=0,
         geomid=geomid,
+        normal=normal,
+    )
+
+  def test_mju_ray_geom(self):
+    # Test mju_rayGeom with a plane at origin
+    pos = np.zeros(3)
+    mat = np.eye(3).flatten()
+    size = np.array([10.0, 10.0, 1.0])
+    pnt = np.array([5.0, 5.0, 5.0])
+    # Normalize direction for Euclidean distance
+    vec = np.array([-1.0, -1.0, -1.0])
+    vec = vec / np.linalg.norm(vec)
+    normal = np.zeros(3)
+
+    # Call with normal argument
+    dist = mujoco.mju_rayGeom(
+        pos, mat, size, pnt, vec, mujoco.mjtGeom.mjGEOM_PLANE, normal
+    )
+    expected_dist = np.sqrt(3 * 5 * 5)
+    np.testing.assert_allclose(dist, expected_dist)
+    np.testing.assert_allclose(normal, [0, 0, 1])
+
+    # Call without normal argument (should still work)
+    dist2 = mujoco.mju_rayGeom(
+        pos, mat, size, pnt, vec, mujoco.mjtGeom.mjGEOM_PLANE
     )
+    np.testing.assert_allclose(dist2, expected_dist)
 
   def test_mj_multi_ray(self):
     nray = 3
@@ -1324,6 +1361,7 @@ Euler integrator, semi-implicit in velocity.
         bodyexclude=-1,
         geomid=geomid,
         dist=dist,
+        normal=None,
         nray=nray,
         cutoff=mujoco.mjMAXVAL,
     )
@@ -1331,7 +1369,9 @@ Euler integrator, semi-implicit in velocity.
     for i in range(0, 3):
       self.assertEqual(
           dist[i],
-          mujoco.mj_ray(self.model, self.data, pnt, vec[i], None, 1, -1, geom1),
+          mujoco.mj_ray(
+              self.model, self.data, pnt, vec[i], None, 1, -1, geom1, None
+          ),
       )
       self.assertEqual(geomid[i], geom1)
       self.assertEqual(geomid[i], geom_ex[i])
@@ -1679,6 +1719,168 @@ Euler integrator, semi-implicit in velocity.
     self.assertIn(model_path, dependencies)
     self.assertIn(msh_path, dependencies)
 
+  def test_mj_read_ctrl_and_init_ctrl_delay(self):
+    xml = r"""
+<mujoco>
+  <worldbody>
+    <body>
+      <geom type="sphere" size="0.1"/>
+      <joint name="hinge" type="hinge"/>
+    </body>
+  </worldbody>
+  <actuator>
+    <position name="actuator" joint="hinge" delay="0.01" nsample="4"/>
+  </actuator>
+</mujoco>
+"""
+    model = mujoco.MjModel.from_xml_string(xml)
+    data = mujoco.MjData(model)
+    mujoco.mj_forward(model, data)
+
+    # Initialize the delay buffer with known values
+    # actuator_history[i, 0] = nsample, actuator_history[i, 1] = interp
+    nhistory = model.actuator_history[0, 0]
+    self.assertEqual(nhistory, 4)
+    times = np.array([0.0, 0.01, 0.02, 0.03])
+    values = np.array([1.0, 2.0, 3.0, 4.0])
+    mujoco.mj_initCtrlHistory(model, data, 0, times, values)
+
+    # Read back a value using zero-order hold
+    # mj_readCtrl auto-subtracts delay: lookup_time = read_time - delay
+    # delay = 0.01, so:
+    #   read_time=0.02 -> lookup at 0.01 -> value 2.0
+    #   read_time=0.03 -> lookup at 0.02 -> value 3.0
+    result = mujoco.mj_readCtrl(model, data, 0, 0.02, interp=0)
+    self.assertEqual(result, 2.0)  # ZOH returns value at t=0.01
+
+    # Test with times=None (uses existing timestamps)
+    new_values = np.array([5.0, 6.0, 7.0, 8.0])
+    mujoco.mj_initCtrlHistory(model, data, 0, None, new_values)
+    # read_time=0.02 -> lookup at 0.01 -> value 6.0
+    result = mujoco.mj_readCtrl(model, data, 0, 0.02, interp=0)
+    self.assertEqual(result, 6.0)
+
+    # Test dimension validation errors
+    with self.assertRaises(TypeError):
+      # wrong times
+      mujoco.mj_initCtrlHistory(model, data, 0, np.zeros(3), values)
+    with self.assertRaises(TypeError):
+      # wrong values
+      mujoco.mj_initCtrlHistory(model, data, 0, times, np.zeros(5))
+
+  def test_mj_read_sensor_and_init_sensor_delay(self):
+    xml = r"""
+<mujoco>
+  <worldbody>
+    <body>
+      <geom type="sphere" size="0.1"/>
+      <joint name="hinge" type="hinge"/>
+      <site name="site"/>
+    </body>
+  </worldbody>
+  <sensor>
+    <accelerometer name="accel" site="site" delay="0.01" nsample="3"/>
+  </sensor>
+</mujoco>
+"""
+    model = mujoco.MjModel.from_xml_string(xml)
+    data = mujoco.MjData(model)
+    mujoco.mj_forward(model, data)
+
+    # Initialize the delay buffer with known values
+    # sensor_history[i, 0] = nsample, sensor_history[i, 1] = interp
+    nhistory = model.sensor_history[0, 0]
+    dim = model.sensor_dim[0]
+    self.assertEqual(nhistory, 3)
+    self.assertEqual(dim, 3)  # accelerometer has dim=3
+    times = np.array([0.0, 0.01, 0.02])
+    values = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float64)
+    mujoco.mj_initSensorHistory(model, data, 0, times, values, phase=0.0)
+
+    # Read back a value using zero-order hold
+    # mj_readSensor auto-subtracts delay: lookup_time = read_time - delay
+    # delay = 0.01, so:
+    #   read_time=0.02 -> lookup at 0.01 -> value [4, 5, 6]
+    result = np.zeros(dim)
+    mujoco.mj_readSensor(model, data, 0, 0.02, result, interp=0)
+    # ZOH returns value at t=0.01
+    np.testing.assert_array_equal(result, [4, 5, 6])
+
+    # Test with times=None (uses existing timestamps)
+    new_values = np.array([
+        [10, 11, 12], [13, 14, 15], [16, 17, 18]], dtype=np.float64)
+    mujoco.mj_initSensorHistory(model, data, 0, None, new_values, phase=0.0)
+    # read_time=0.02 -> lookup at 0.01 -> value [13, 14, 15]
+    mujoco.mj_readSensor(model, data, 0, 0.02, result, interp=0)
+    np.testing.assert_array_equal(result, [13, 14, 15])
+
+    # Test dimension validation errors
+    with self.assertRaises(TypeError):
+      # wrong result size
+      mujoco.mj_readSensor(model, data, 0, 0.02, np.zeros(2), interp=0)
+    with self.assertRaises(TypeError):
+      # wrong times size
+      mujoco.mj_initSensorHistory(model, data, 0, np.zeros(2), values, 0.0)
+    with self.assertRaises(TypeError):
+      # wrong values rows
+      mujoco.mj_initSensorHistory(model, data, 0, times, np.zeros((4, 3)), 0.0)
+    with self.assertRaises(TypeError):
+      # wrong values cols
+      mujoco.mj_initSensorHistory(model, data, 0, times, np.zeros((3, 2)), 0.0)
+
+  def test_init_sensor_history_pedagogical(self):
+    # A framequat sensor reports body orientation as a unit quaternion.
+    # Quaternions are never zero: the identity quaternion is [1, 0, 0, 0].
+    # This test demonstrates why mj_initSensorHistory is needed: after
+    # mj_makeData, the history buffer is filled with zeros, which is invalid.
+    xml = r"""
+<mujoco>
+  <worldbody>
+    <body name="body">
+      <freejoint/>
+      <geom type="sphere" size="0.1"/>
+    </body>
+  </worldbody>
+  <sensor>
+    <framequat name="quat" objtype="body" objname="body" delay="0.01" nsample="5"/>
+  </sensor>
+</mujoco>
+"""
+    model = mujoco.MjModel.from_xml_string(xml)
+    data = mujoco.MjData(model)
+    dim = model.sensor_dim[0]
+    nsample = model.sensor_history[0, 0]
+    delay = model.sensor_delay[0]
+    self.assertEqual(dim, 4)
+    self.assertEqual(nsample, 5)
+    self.assertEqual(delay, 0.01)
+
+    # After mj_makeData, reading from the delay buffer gives all zeros.
+    # For a quaternion sensor, this is invalid data.
+    result = np.zeros(dim)
+    mujoco.mj_readSensor(model, data, 0, delay, result, interp=0)
+    np.testing.assert_array_equal(result, [0, 0, 0, 0])
+
+    # To get valid sensor values, we temporarily set delay to 0 so that
+    # mj_forward populates sensordata directly (without using the delay
+    # buffer), then restore the original delay value.
+    saved_delay = model.sensor_delay.copy()
+    model.sensor_delay[:] = 0
+    mujoco.mj_forward(model, data)
+    model.sensor_delay[:] = saved_delay
+
+    # Now sensordata contains the valid identity quaternion.
+    np.testing.assert_array_equal(data.sensordata, [1, 0, 0, 0])
+
+    # Use mj_initSensorHistory to fill the buffer with valid quaternion values.
+    # Passing None for times keeps the existing timestamps in the buffer.
+    values = np.tile(data.sensordata, (nsample, 1))
+    mujoco.mj_initSensorHistory(model, data, 0, None, values, phase=0.0)
+
+    # Now reading from the delay buffer gives the valid identity quaternion.
+    mujoco.mj_readSensor(model, data, 0, delay, result, interp=0)
+    np.testing.assert_array_equal(result, [1, 0, 0, 0])
+
   def _assert_attributes_equal(self, actual_obj, expected_obj, attr_to_compare):
     for name in attr_to_compare:
       actual_value = getattr(actual_obj, name)

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/cmake/MujocoDependencies.cmake

@@ -39,12 +39,12 @@ set(MUJOCO_DEP_VERSION_qhull
     CACHE STRING "Version of `qhull` to be fetched."
 )
 set(MUJOCO_DEP_VERSION_Eigen3
-    49623d0c4e1af3c680845191948d10f6d3e92f8a
+    75bcd155c40cb48e647c87c3f29052360255bc9e
     CACHE STRING "Version of `Eigen3` to be fetched."
 )
 
 set(MUJOCO_DEP_VERSION_abseil
-    d38452e1ee03523a208362186fd42248ff2609f6 # LTS 20250814.1
+    255c84dadd029fd8ad25c5efb5933e47beaa00c7 # LTS 20250814.1
     CACHE STRING "Version of `abseil` to be fetched."
 )
 
@@ -54,15 +54,10 @@ set(MUJOCO_DEP_VERSION_gtest
 )
 
 set(MUJOCO_DEP_VERSION_benchmark
-    5f7d66929fb66869d96dfcbacf0d8a586b33766d
+    5c55f5d4f45a1b09c5d98aa63a671993ebd42c69
     CACHE STRING "Version of `benchmark` to be fetched."
 )
 
-set(MUJOCO_DEP_VERSION_TriangleMeshDistance
-    2cb643de1436e1ba8e2be49b07ec5491ac604457
-    CACHE STRING "Version of `TriangleMeshDistance` to be fetched."
-)
-
 mark_as_advanced(MUJOCO_DEP_VERSION_lodepng)
 mark_as_advanced(MUJOCO_DEP_VERSION_MarchingCubeCpp)
 mark_as_advanced(MUJOCO_DEP_VERSION_tinyxml2)
@@ -73,7 +68,6 @@ mark_as_advanced(MUJOCO_DEP_VERSION_Eigen3)
 mark_as_advanced(MUJOCO_DEP_VERSION_abseil)
 mark_as_advanced(MUJOCO_DEP_VERSION_gtest)
 mark_as_advanced(MUJOCO_DEP_VERSION_benchmark)
-mark_as_advanced(MUJOCO_DEP_VERSION_TriangleMeshDistance)
 
 include(FetchContent)
 include(FindOrFetch)
@@ -202,30 +196,6 @@ if(CMAKE_POLICY_VERSION_MINIMUM_LOCALLY_DEFINED)
   unset(CMAKE_POLICY_VERSION_MINIMUM_LOCALLY_DEFINED)
 endif()
 
-if(NOT TARGET trianglemeshdistance)
-  FetchContent_Declare(
-    trianglemeshdistance
-    GIT_REPOSITORY https://github.com/InteractiveComputerGraphics/TriangleMeshDistance.git
-    GIT_TAG ${MUJOCO_DEP_VERSION_TriangleMeshDistance}
-  )
-
-  FetchContent_GetProperties(trianglemeshdistance)
-  if(NOT trianglemeshdistance_POPULATED)
-    FetchContent_Populate(trianglemeshdistance)
-    # Patch the source code to silence a warning/error related to a loop variable creating a copy.
-    # Since this is a header only library this fix is less intrusive than disabling the warning for
-    # any target including the header.
-    set(TMD_HEADER ${trianglemeshdistance_SOURCE_DIR}/TriangleMeshDistance/include/tmd/TriangleMeshDistance.h)
-    file(READ ${TMD_HEADER} TMD_CONTENT)
-    string(REPLACE
-      "for (const auto edge_count : edges_count) {"
-      "for (const auto& edge_count : edges_count) {"
-      TMD_CONTENT "${TMD_CONTENT}")
-    file(WRITE ${TMD_HEADER} "${TMD_CONTENT}")
-    include_directories(${trianglemeshdistance_SOURCE_DIR})
-  endif()
-endif()
-
 set(ENABLE_DOUBLE_PRECISION ON)
 set(CCD_HIDE_ALL_SYMBOLS ON)
 
@@ -339,9 +309,7 @@ if(MUJOCO_BUILD_TESTS)
         "sed"
         "-i"
         "-e"
-        "s/-std=c++11/-std=c++14/g"
-        "-e"
-        "s/HAVE_CXX_FLAG_STD_CXX11/HAVE_CXX_FLAG_STD_CXX14/g"
+        "s/-Wformat=2/-Wformat/g"
         "${CMAKE_BINARY_DIR}/_deps/benchmark-src/CMakeLists.txt"
     )
   endif()

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/cmake/MujocoLinkOptions.cmake

@@ -23,16 +23,12 @@ function(get_mujoco_extra_link_options OUTPUT_VAR)
     set(EXTRA_LINK_OPTIONS)
 
     if(WIN32)
-      set(EXTRA_LINK_OPTIONS ${EXTRA_LINK_OPTIONS} -Wl,/STACK:16777216)
       set(CMAKE_REQUIRED_FLAGS "-fuse-ld=lld-link")
-      check_c_source_compiles("int main() {}" SUPPORTS_LLD)
-      if(SUPPORTS_LLD)
-        set(EXTRA_LINK_OPTIONS
-            ${EXTRA_LINK_OPTIONS}
-            -fuse-ld=lld-link
-            -Wl,/OPT:REF
-            -Wl,/OPT:ICF
-        )
+      check_c_source_compiles("int main() {}" SUPPORTS_LLD_LINK)
+      if(SUPPORTS_LLD_LINK)
+        set(EXTRA_LINK_OPTIONS ${EXTRA_LINK_OPTIONS} -fuse-ld=lld-link -Wl,/STACK:16777216 -Wl,/OPT:REF -Wl,/OPT:ICF)
+      else()
+        set(EXTRA_LINK_OPTIONS ${EXTRA_LINK_OPTIONS} -Wl,--stack,16777216)
       endif()
     else()
       set(CMAKE_REQUIRED_FLAGS "-fuse-ld=lld")

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/cmake/ShellTests.cmake

@@ -38,6 +38,7 @@ function(add_mujoco_shell_test TEST_NAME TARGET_BINARY)
                "CMAKE_SOURCE_DIR=${CMAKE_SOURCE_DIR}"
                "TARGET_BINARY=$<TARGET_FILE:${TARGET_BINARY}>"
                "TEST_TMPDIR=${TEST_TMPDIR}"
+               "MUJOCO_PLUGIN_DIR=$<TARGET_FILE_DIR:obj_decoder>"
     )
     if(WIN32)
       # Define the directory containing the mujoco DLL library so that it can be added to the PATH.

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/constants.cc

@@ -59,6 +59,7 @@ PYBIND11_MODULE(_constants, pymodule) {
   X(mjMAXCONPAIR);
   X(mjMAXTREEDEPTH);
   X(mjMAXFLEXNODES);
+  X(mjMINAWAKE);
   X(mjNEQDATA);
   X(mjNDYN);
   X(mjNGAIN);

{mujoco-3.4.0 → mujoco-3.6.0}/mujoco/enum_traits.h

@@ -98,6 +98,14 @@ struct mjtGeom {
     std::make_pair("mjGEOM_NONE", ::mjtGeom::mjGEOM_NONE)};
 };
 
+struct mjtProjection {
+  static constexpr char name[] = "mjtProjection";
+  using type = ::mjtProjection;
+  static constexpr auto values = std::array{
+    std::make_pair("mjPROJ_PERSPECTIVE", ::mjtProjection::mjPROJ_PERSPECTIVE),
+    std::make_pair("mjPROJ_ORTHOGRAPHIC", ::mjtProjection::mjPROJ_ORTHOGRAPHIC)};
+};
+
 struct mjtCamLight {
   static constexpr char name[] = "mjtCamLight";
   using type = ::mjtCamLight;
@@ -199,6 +207,8 @@ struct mjtEq {
     std::make_pair("mjEQ_JOINT", ::mjtEq::mjEQ_JOINT),
     std::make_pair("mjEQ_TENDON", ::mjtEq::mjEQ_TENDON),
     std::make_pair("mjEQ_FLEX", ::mjtEq::mjEQ_FLEX),
+    std::make_pair("mjEQ_FLEXVERT", ::mjtEq::mjEQ_FLEXVERT),
+    std::make_pair("mjEQ_FLEXSTRAIN", ::mjtEq::mjEQ_FLEXSTRAIN),
     std::make_pair("mjEQ_DISTANCE", ::mjtEq::mjEQ_DISTANCE)};
 };
 
@@ -384,6 +394,31 @@ struct mjtConDataField {
     std::make_pair("mjNCONDATA", ::mjtConDataField::mjNCONDATA)};
 };
 
+struct mjtRayDataField {
+  static constexpr char name[] = "mjtRayDataField";
+  using type = ::mjtRayDataField;
+  static constexpr auto values = std::array{
+    std::make_pair("mjRAYDATA_DIST", ::mjtRayDataField::mjRAYDATA_DIST),
+    std::make_pair("mjRAYDATA_DIR", ::mjtRayDataField::mjRAYDATA_DIR),
+    std::make_pair("mjRAYDATA_ORIGIN", ::mjtRayDataField::mjRAYDATA_ORIGIN),
+    std::make_pair("mjRAYDATA_POINT", ::mjtRayDataField::mjRAYDATA_POINT),
+    std::make_pair("mjRAYDATA_NORMAL", ::mjtRayDataField::mjRAYDATA_NORMAL),
+    std::make_pair("mjRAYDATA_DEPTH", ::mjtRayDataField::mjRAYDATA_DEPTH),
+    std::make_pair("mjNRAYDATA", ::mjtRayDataField::mjNRAYDATA)};
+};
+
+struct mjtCamOutBit {
+  static constexpr char name[] = "mjtCamOutBit";
+  using type = ::mjtCamOutBit;
+  static constexpr auto values = std::array{
+    std::make_pair("mjCAMOUT_RGB", ::mjtCamOutBit::mjCAMOUT_RGB),
+    std::make_pair("mjCAMOUT_DEPTH", ::mjtCamOutBit::mjCAMOUT_DEPTH),
+    std::make_pair("mjCAMOUT_DIST", ::mjtCamOutBit::mjCAMOUT_DIST),
+    std::make_pair("mjCAMOUT_NORMAL", ::mjtCamOutBit::mjCAMOUT_NORMAL),
+    std::make_pair("mjCAMOUT_SEG", ::mjtCamOutBit::mjCAMOUT_SEG),
+    std::make_pair("mjNCAMOUT", ::mjtCamOutBit::mjNCAMOUT)};
+};
+
 struct mjtSameFrame {
   static constexpr char name[] = "mjtSameFrame";
   using type = ::mjtSameFrame;
@@ -455,6 +490,7 @@ struct mjtState {
     std::make_pair("mjSTATE_QPOS", ::mjtState::mjSTATE_QPOS),
     std::make_pair("mjSTATE_QVEL", ::mjtState::mjSTATE_QVEL),
     std::make_pair("mjSTATE_ACT", ::mjtState::mjSTATE_ACT),
+    std::make_pair("mjSTATE_HISTORY", ::mjtState::mjSTATE_HISTORY),
     std::make_pair("mjSTATE_WARMSTART", ::mjtState::mjSTATE_WARMSTART),
     std::make_pair("mjSTATE_CTRL", ::mjtState::mjSTATE_CTRL),
     std::make_pair("mjSTATE_QFRC_APPLIED", ::mjtState::mjSTATE_QFRC_APPLIED),
@@ -762,6 +798,7 @@ struct mjtRndFlag {
     std::make_pair("mjRND_SKYBOX", ::mjtRndFlag::mjRND_SKYBOX),
     std::make_pair("mjRND_FOG", ::mjtRndFlag::mjRND_FOG),
     std::make_pair("mjRND_HAZE", ::mjtRndFlag::mjRND_HAZE),
+    std::make_pair("mjRND_DEPTH", ::mjtRndFlag::mjRND_DEPTH),
     std::make_pair("mjRND_SEGMENT", ::mjtRndFlag::mjRND_SEGMENT),
     std::make_pair("mjRND_IDCOLOR", ::mjtRndFlag::mjRND_IDCOLOR),
     std::make_pair("mjRND_CULL_FACE", ::mjtRndFlag::mjRND_CULL_FACE),
@@ -900,6 +937,7 @@ static constexpr auto kAllEnums = std::make_tuple(
     mjtEnableBit{},
     mjtJoint{},
     mjtGeom{},
+    mjtProjection{},
     mjtCamLight{},
     mjtLightType{},
     mjtTexture{},
@@ -920,6 +958,8 @@ static constexpr auto kAllEnums = std::make_tuple(
     mjtStage{},
     mjtDataType{},
     mjtConDataField{},
+    mjtRayDataField{},
+    mjtCamOutBit{},
     mjtSameFrame{},
     mjtSleepPolicy{},
     mjtLRMode{},