mujoco-react 10.6.0 → 10.8.0

package/dist/onnx.d.ts

@@ -1,5 +1,5 @@
 import * as ort from 'onnxruntime-web';
-import { bq as PolicyActionChunk } from './types-Dvtm4I0o.js';
+import { bq as PolicyActionChunk } from './types-Bu8Aki_j.js';
 import 'react';
 import '@react-three/fiber';
 import 'three';

package/dist/spark.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _sparkjsdev_spark from '@sparkjsdev/spark';
-import { o as SplatEnvironmentProps, r as PairedSplatEnvironmentConfig, S as SceneConfig, u as SplatEnvironmentReadiness, p as VisualScenarioConfig } from './types-Dvtm4I0o.js';
+import { o as SplatEnvironmentProps, r as PairedSplatEnvironmentConfig, S as SceneConfig, u as SplatEnvironmentReadiness, p as VisualScenarioConfig } from './types-Bu8Aki_j.js';
 import 'react';
 import '@react-three/fiber';
 import 'three';

package/dist/spark.js

@@ -1,4 +1,4 @@
-import { useSplatSceneConfig, useSplatEnvironment, SplatEnvironment, CAMERA_FRAME_CAPTURE_RENDER_USER_DATA_KEY } from './chunk-EN55TTGH.js';
+import { useSplatSceneConfig, useSplatEnvironment, SplatEnvironment, CAMERA_FRAME_CAPTURE_RENDER_USER_DATA_KEY } from './chunk-5WFYM73E.js';
 import { useThree } from '@react-three/fiber';
 import { useMemo, useState, useEffect, useCallback, useRef } from 'react';
 import * as THREE from 'three';

package/dist/{types-Dvtm4I0o.d.ts → types-Bu8Aki_j.d.ts}

@@ -310,6 +310,9 @@ interface MujocoModel {
     mesh_vert: Float32Array;
     mesh_face: Int32Array;
     mesh_normal: Float32Array;
+    mesh_texcoordadr?: Int32Array;
+    mesh_texcoord?: Float32Array;
+    mesh_facetexcoord?: Int32Array;
     site_bodyid: Int32Array;
     actuator_trnid: Int32Array;
     actuator_ctrlrange: Float64Array;
@@ -1586,6 +1589,13 @@ type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
     speed?: number;
     interpolate?: boolean;
     renderOptions?: MujocoRenderOptions;
+    /**
+     * Names of model bodies whose geometry should not be rendered. The bodies stay
+     * in the compiled model and continue to simulate — only their meshes are
+     * skipped at scene-build time, so body/joint/actuator indices are unchanged.
+     * Applied on every (re)build, so toggling names cannot be lost to a rebuild.
+     */
+    hiddenBodies?: readonly string[];
 };
 interface SitePositionResult {
     position: React__default.RefObject<THREE.Vector3>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mujoco-react",
-  "version": "10.6.0",
+  "version": "10.8.0",
   "description": "Composable React Three Fiber building blocks for MuJoCo WASM simulations",
   "type": "module",
   "main": "./dist/index.js",

package/src/components/SceneRenderer.tsx

@@ -35,6 +35,7 @@ export function SceneRenderer({ renderOptions, ...props }: SceneRendererProps) {
     mujocoRef,
     onSelectionRef,
     hiddenBodiesRef,
+    hiddenBodiesVersion,
     interpolateRef,
     interpolationStateRef,
     status,
@@ -43,6 +44,7 @@ export function SceneRenderer({ renderOptions, ...props }: SceneRendererProps) {
   const bodyRefs = useRef<(THREE.Group | null)[]>([]);
   const prevModelRef = useRef<MujocoModel | null>(null);
   const prevRenderOptionsKeyRef = useRef<string | null>(null);
+  const prevHiddenVersionRef = useRef<number | null>(null);
   const renderOptionsKey = getRenderOptionsKey(renderOptions);
 
   const geomBuilder = useMemo(() => {
@@ -57,15 +59,17 @@ export function SceneRenderer({ renderOptions, ...props }: SceneRendererProps) {
     const group = groupRef.current;
     if (!model || !group) return;
 
-    // Skip if model hasn't changed
+    // Skip if neither the model, render options, nor the hidden-body set changed
     if (
       prevModelRef.current === model &&
-      prevRenderOptionsKeyRef.current === renderOptionsKey
+      prevRenderOptionsKeyRef.current === renderOptionsKey &&
+      prevHiddenVersionRef.current === hiddenBodiesVersion
     ) {
       return;
     }
     prevModelRef.current = model;
     prevRenderOptionsKeyRef.current = renderOptionsKey;
+    prevHiddenVersionRef.current = hiddenBodiesVersion;
 
     // Clear previous bodies
     while (group.children.length > 0) {
@@ -92,7 +96,7 @@ export function SceneRenderer({ renderOptions, ...props }: SceneRendererProps) {
       refs.push(bodyGroup);
     }
     bodyRefs.current = refs;
-  }, [status, geomBuilder, mjModelRef, renderOptionsKey]);
+  }, [status, geomBuilder, mjModelRef, renderOptionsKey, hiddenBodiesRef, hiddenBodiesVersion]);
 
   const syncBodiesToData = useCallback(() => {
     const data = mjDataRef.current;

package/src/core/MujocoCanvas.tsx

@@ -32,6 +32,7 @@ export const MujocoCanvas = forwardRef<MujocoSimAPI, MujocoCanvasProps>(
       speed,
       interpolate,
       renderOptions,
+      hiddenBodies,
       loadingFallback,
       children,
       ...canvasProps
@@ -75,6 +76,7 @@ export const MujocoCanvas = forwardRef<MujocoSimAPI, MujocoCanvasProps>(
           speed={speed}
           interpolate={interpolate}
           renderOptions={renderOptions}
+          hiddenBodies={hiddenBodies}
         >
           {children}
         </MujocoSimProvider>

package/src/core/MujocoSimProvider.tsx

@@ -441,6 +441,8 @@ export interface MujocoSimContextValue {
   errorRef: React.RefObject<string | null>;
   bodyRegistryRef: React.RefObject<Map<string, { definition: SceneObject; hasCustomChildren: boolean }>>;
   hiddenBodiesRef: React.RefObject<Set<string>>;
+  /** Bumped whenever the hidden-body set changes, forcing SceneRenderer to rebuild. */
+  hiddenBodiesVersion: number;
   requestBodyReload: () => void;
   status: 'loading' | 'ready' | 'error';
 }
@@ -547,6 +549,7 @@ interface MujocoSimProviderProps {
   speed?: number;
   interpolate?: boolean;
   renderOptions?: MujocoRenderOptions;
+  hiddenBodies?: readonly string[];
   children: React.ReactNode;
 }
 
@@ -565,6 +568,7 @@ export function MujocoSimProvider({
   speed,
   interpolate,
   renderOptions,
+  hiddenBodies,
   children,
 }: MujocoSimProviderProps) {
   const { gl, camera, scene } = useThree();
@@ -602,6 +606,8 @@ export function MujocoSimProvider({
   const errorRef = useRef<string | null>(null);
   const bodyRegistryRef = useRef(new Map<string, { definition: SceneObject; hasCustomChildren: boolean }>());
   const hiddenBodiesRef = useRef(new Set<string>());
+  const providedHiddenBodiesRef = useRef<Set<string>>(new Set(hiddenBodies ?? []));
+  const [hiddenBodiesVersion, setHiddenBodiesVersion] = useState(0);
   const bodyReloadTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   configRef.current = config;
@@ -629,16 +635,43 @@ export function MujocoSimProvider({
     model.opt.timestep = timestep;
   }, [timestep]);
 
+  // Sync hiddenBodies prop. Rebuilds the render meshes (not the model) when the
+  // set changes so a toggle can never be lost to SceneRenderer's own rebuilds.
+  const hiddenBodiesKey = (hiddenBodies ?? []).join('');
+  useEffect(() => {
+    const next = new Set(hiddenBodies ?? []);
+    const prev = providedHiddenBodiesRef.current;
+    let unchanged = next.size === prev.size;
+    if (unchanged) {
+      for (const name of next) {
+        if (!prev.has(name)) { unchanged = false; break; }
+      }
+    }
+    if (unchanged) return;
+    providedHiddenBodiesRef.current = next;
+    recomputeHiddenBodies();
+    setHiddenBodiesVersion(v => v + 1);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [hiddenBodiesKey]);
+
+  // Recompute the set of bodies SceneRenderer must skip: bodies whose rendering
+  // a <Body> replaces with custom children, plus any named via the hiddenBodies
+  // prop. SceneRenderer reads this ref on every build.
+  function recomputeHiddenBodies() {
+    hiddenBodiesRef.current.clear();
+    for (const [name, entry] of bodyRegistryRef.current) {
+      if (entry.hasCustomChildren) hiddenBodiesRef.current.add(name);
+    }
+    for (const name of providedHiddenBodiesRef.current) hiddenBodiesRef.current.add(name);
+  }
+
   // --- Build merged config (base + body registry) ---
   function buildMergedConfig(baseConfig: SceneConfig): SceneConfig {
+    recomputeHiddenBodies();
     if (bodyRegistryRef.current.size === 0) return baseConfig;
     const registeredNames = new Set(bodyRegistryRef.current.keys());
     const baseObjects = (baseConfig.sceneObjects ?? []).filter(o => !registeredNames.has(o.name));
     const registeredBodies = Array.from(bodyRegistryRef.current.values()).map(e => e.definition);
-    hiddenBodiesRef.current.clear();
-    for (const [name, entry] of bodyRegistryRef.current) {
-      if (entry.hasCustomChildren) hiddenBodiesRef.current.add(name);
-    }
     return { ...baseConfig, sceneObjects: [...baseObjects, ...registeredBodies] };
   }
 
@@ -1967,10 +2000,11 @@ export function MujocoSimProvider({
       errorRef,
       bodyRegistryRef,
       hiddenBodiesRef,
+      hiddenBodiesVersion,
       requestBodyReload,
       status,
     }),
-    [api, status, requestBodyReload]
+    [api, status, requestBodyReload, hiddenBodiesVersion]
   );
 
   return (

package/src/hooks/useIkController.ts

@@ -61,7 +61,20 @@ export const useIkController = createControllerHook<IkConfig, IkContextValue>(
     const ikTargetRef = useRef<THREE.Group>(new THREE.Group());
     const siteIdRef = useRef(-1);
     const controlGroupRef = useRef<ControlGroupInfo | null>(null);
-    const genericIkRef = useRef<GenericIK>(new GenericIK(mujocoRef.current));
+    // The solver must always call into the module that owns the live
+    // model/data. Capturing the module once at mount breaks when the provider
+    // remounts (e.g. StrictMode double-mount): embind then rejects the model
+    // with "Expected null or instance of MjModel, got an instance of MjModel".
+    const genericIkRef = useRef<GenericIK | null>(null);
+    const genericIkModuleRef = useRef<unknown>(null);
+    const getGenericIk = useCallback(() => {
+      const module = mujocoRef.current;
+      if (!genericIkRef.current || genericIkModuleRef.current !== module) {
+        genericIkRef.current = new GenericIK(module);
+        genericIkModuleRef.current = module;
+      }
+      return genericIkRef.current;
+    }, [mujocoRef]);
     const firstIkEnableRef = useRef(true);
     const needsInitialSync = useRef(true);
 
@@ -119,7 +132,7 @@ export const useIkController = createControllerHook<IkConfig, IkContextValue>(
         const data = mjDataRef.current;
         const controlGroup = controlGroupRef.current;
         if (!model || !data || !controlGroup || siteIdRef.current === -1) return null;
-        return genericIkRef.current.solve(
+        return getGenericIk().solve(
           model, data, siteIdRef.current, controlGroup.qposAdr,
           targetPosition, targetQuaternion, currentQ,
           {
@@ -135,7 +148,7 @@ export const useIkController = createControllerHook<IkConfig, IkContextValue>(
           },
         );
       },
-      [config, mjModelRef, mjDataRef],
+      [config, mjModelRef, mjDataRef, getGenericIk],
     );
     const ikSolveFnRef = useRef<IKSolveFn>(ikSolveFn);
     ikSolveFnRef.current = ikSolveFn;

package/src/index.ts

@@ -97,11 +97,13 @@ export { useBodyState } from './hooks/useBodyState';
 export { useBodyPose, useGeomPose, useSitePose } from './hooks/usePose';
 export type { PoseReadout, PoseResourceKind } from './hooks/usePose';
 export { useCtrl } from './hooks/useCtrl';
-export { controlGroup, useControlGroup } from './hooks/useControlGroup';
+export { controlGroup, defineControls, useControlGroup, useControls } from './hooks/useControlGroup';
 export type {
   ControlGroup,
   ControlGroupHandle,
   ControlGroupSetOptions,
+  ControlsHandle,
+  DefinedControls,
   UseControlGroupOptions,
 } from './hooks/useControlGroup';
 export { useControlWriter } from './hooks/useControlWriter';

package/src/rendering/GeomBuilder.ts

@@ -155,16 +155,40 @@ export class GeomBuilder {
             const fAdr = mjModel.mesh_faceadr[mId];
             const fNum = mjModel.mesh_facenum[mId];
 
-            geo = new THREE.BufferGeometry();
-            // 'position' attribute = vertices
-            geo.setAttribute('position', new THREE.Float32BufferAttribute(mjModel.mesh_vert.subarray(vAdr * 3, (vAdr + vNum) * 3), 3));
-            // 'index' = faces (triangles connecting vertices)
-            geo.setIndex(Array.from(mjModel.mesh_face.subarray(fAdr * 3, (fAdr + fNum) * 3)));
-            const smoothingTolerance = this.getMeshNormalSmoothingTolerance();
-            if (smoothingTolerance !== null) {
-                geo = mergeVertices(geo, smoothingTolerance);
+            const tAdr = mjModel.mesh_texcoordadr?.[mId] ?? -1;
+            if (map && tAdr >= 0 && mjModel.mesh_texcoord && mjModel.mesh_facetexcoord) {
+                // Textured mesh. MuJoCo indexes texcoords per face corner
+                // (mesh_facetexcoord), independently of the vertex indices, so
+                // the geometry must be de-indexed to carry a 'uv' attribute.
+                const corners = fNum * 3;
+                const positions = new Float32Array(corners * 3);
+                const uvs = new Float32Array(corners * 2);
+                for (let c = 0; c < corners; c++) {
+                    const v = vAdr + mjModel.mesh_face[fAdr * 3 + c];
+                    positions[c * 3] = mjModel.mesh_vert[v * 3];
+                    positions[c * 3 + 1] = mjModel.mesh_vert[v * 3 + 1];
+                    positions[c * 3 + 2] = mjModel.mesh_vert[v * 3 + 2];
+                    const t = tAdr + mjModel.mesh_facetexcoord[fAdr * 3 + c];
+                    uvs[c * 2] = mjModel.mesh_texcoord[t * 2];
+                    // MuJoCo stores V with image-top origin; flip back to GL convention.
+                    uvs[c * 2 + 1] = 1 - mjModel.mesh_texcoord[t * 2 + 1];
+                }
+                geo = new THREE.BufferGeometry();
+                geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+                geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+                geo.computeVertexNormals();
+            } else {
+                geo = new THREE.BufferGeometry();
+                // 'position' attribute = vertices
+                geo.setAttribute('position', new THREE.Float32BufferAttribute(mjModel.mesh_vert.subarray(vAdr * 3, (vAdr + vNum) * 3), 3));
+                // 'index' = faces (triangles connecting vertices)
+                geo.setIndex(Array.from(mjModel.mesh_face.subarray(fAdr * 3, (fAdr + fNum) * 3)));
+                const smoothingTolerance = this.getMeshNormalSmoothingTolerance();
+                if (smoothingTolerance !== null) {
+                    geo = mergeVertices(geo, smoothingTolerance);
+                }
+                geo.computeVertexNormals(); // Auto-calculate smooth lighting normals
             }
-            geo.computeVertexNormals(); // Auto-calculate smooth lighting normals
         }
 
         // 5. Construct the final Mesh

package/src/types.ts

@@ -291,6 +291,9 @@ export interface MujocoModel {
   mesh_vert: Float32Array;
   mesh_face: Int32Array;
   mesh_normal: Float32Array;
+  mesh_texcoordadr?: Int32Array;
+  mesh_texcoord?: Float32Array;
+  mesh_facetexcoord?: Int32Array;
 
   // Site
   site_bodyid: Int32Array;
@@ -1843,6 +1846,13 @@ export type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
   speed?: number;
   interpolate?: boolean;
   renderOptions?: MujocoRenderOptions;
+  /**
+   * Names of model bodies whose geometry should not be rendered. The bodies stay
+   * in the compiled model and continue to simulate — only their meshes are
+   * skipped at scene-build time, so body/joint/actuator indices are unchanged.
+   * Applied on every (re)build, so toggling names cannot be lost to a rebuild.
+   */
+  hiddenBodies?: readonly string[];
 };
 
 // ---- Hook Return Types ----