Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/__init__.py

@@ -0,0 +1,2 @@
+from .scenes import *
+from .tasks import *

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/minimal_template.py

@@ -0,0 +1,66 @@
+from typing import Any, Dict, Union
+
+import numpy as np
+import sapien
+import torch
+
+from mani_skill.agents.robots import Fetch, Panda
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs.types import SimConfig
+
+
+@register_env("CustomEnv-v1", max_episode_steps=200)
+class CustomEnv(BaseEnv):
+
+    SUPPORTED_ROBOTS = ["panda", "fetch"]
+    agent: Union[Panda, Fetch]
+
+    def __init__(self, *args, robot_uids="panda", robot_init_qpos_noise=0.02, **kwargs):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig()
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at(eye=[0.3, 0, 0.6], target=[-0.1, 0, 0.1])
+        return [
+            CameraConfig("base_camera", pose=pose, width=128, height=128, fov=np.pi / 2)
+        ]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([0.6, 0.7, 0.6], [0.0, 0.0, 0.35])
+        return CameraConfig("render_camera", pose=pose, width=512, height=512, fov=1)
+
+    def _load_agent(self, options: dict):
+        super()._load_agent(options, sapien.Pose(p=[0, 0, 0]))
+
+    def _load_scene(self, options: dict):
+        pass
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        pass
+
+    def evaluate(self):
+        return {
+            "success": torch.zeros(self.num_envs, device=self.device, dtype=bool),
+            "fail": torch.zeros(self.num_envs, device=self.device, dtype=bool),
+        }
+
+    def _get_obs_extra(self, info: Dict):
+        return dict()
+
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        return torch.zeros(self.num_envs, device=self.device)
+
+    def compute_normalized_dense_reward(
+        self, obs: Any, action: torch.Tensor, info: Dict
+    ):
+        max_reward = 1.0
+        return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/sapien_env.py

@@ -0,0 +1,1357 @@
+import copy
+import gc
+import os
+from functools import cached_property
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import dacite
+import gymnasium as gym
+import numpy as np
+import sapien
+import sapien.physx as physx
+import sapien.render
+import sapien.utils.viewer.control_window
+import torch
+from gymnasium.vector.utils import batch_space
+
+from mani_skill import PACKAGE_ASSET_DIR, logger
+from mani_skill.agents import REGISTERED_AGENTS
+from mani_skill.agents.base_agent import BaseAgent
+from mani_skill.agents.multi_agent import MultiAgent
+from mani_skill.envs.scene import ManiSkillScene
+from mani_skill.envs.utils.observations import (
+    parse_obs_mode_to_struct,
+    sensor_data_to_pointcloud,
+)
+from mani_skill.envs.utils.randomization.batched_rng import BatchedRNG
+from mani_skill.envs.utils.system.backend import parse_sim_and_render_backend
+from mani_skill.sensors.base_sensor import BaseSensor, BaseSensorConfig
+from mani_skill.sensors.camera import (
+    Camera,
+    CameraConfig,
+    parse_camera_configs,
+    update_camera_configs_from_dict,
+)
+from mani_skill.sensors.depth_camera import StereoDepthCamera, StereoDepthCameraConfig
+from mani_skill.utils import common, gym_utils, sapien_utils
+from mani_skill.utils.structs import Actor, Articulation
+from mani_skill.utils.structs.pose import Pose
+from mani_skill.utils.structs.types import Array, SimConfig
+from mani_skill.utils.visualization.misc import tile_images
+from mani_skill.viewer import create_viewer
+
+
+class BaseEnv(gym.Env):
+    """Superclass for ManiSkill environments.
+
+    Args:
+        num_envs: number of parallel environments to run. By default this is 1, which means a CPU simulation is used. If greater than 1,
+            then we initialize the GPU simulation setup. Note that not all environments are faster when simulated on the GPU due to limitations of
+            GPU simulations. For example, environments with many moving objects are better simulated by parallelizing across CPUs.
+
+        obs_mode: observation mode to be used. Must be one of ("state", "state_dict", "none", "sensor_data", "rgb", "depth", "segmentation", "rgbd", "rgb+depth", "rgb+depth+segmentation", "rgb+segmentation", "depth+segmentation", "pointcloud")
+            The obs_mode is mostly for convenience to automatically optimize/setup all sensors/cameras for the given observation mode to render the correct data and try to ignore unecesary rendering.
+            For the most advanced use cases (e.g. you have 1 RGB only camera and 1 depth only camera)
+
+        reward_mode: reward mode to use. Must be one of ("normalized_dense", "dense", "sparse", "none"). With "none" the reward returned is always 0
+
+        control_mode: control mode of the agent.
+            "*" represents all registered controllers, and the action space will be a dict.
+
+        render_mode: render mode registered in @SUPPORTED_RENDER_MODES.
+
+        shader_dir (Optional[str]): shader directory. Defaults to None.
+            Setting this will override the shader used for all cameras in the environment. This is legacy behavior kept for backwards compatibility.
+            The proper way to change the shaders used for cameras is to either change the environment code or pass in sensor_configs/human_render_camera_configs with the desired shaders.
+
+
+            Previously the options are "default", "rt", "rt-fast". "rt" means ray-tracing which results
+            in more photorealistic renders but is slow, "rt-fast" is a lower quality but faster version of "rt".
+
+        enable_shadow (bool): whether to enable shadow for lights. Defaults to False.
+
+        sensor_configs (dict): configurations of sensors to override any environment defaults.
+            If the key is one of sensor names (e.g. a camera), the config value will be applied to the corresponding sensor.
+            Otherwise, the value will be applied to all sensors (but overridden by sensor-specific values). For possible configurations
+            see the documentation see :doc:`the sensors documentation </user_guide/tutorials/sensors/index>`.
+
+        human_render_camera_configs (dict): configurations of human rendering cameras to override any environment defaults. Similar usage as @sensor_configs.
+
+        viewer_camera_configs (dict): configurations of the viewer camera in the GUI to override any environment defaults. Similar usage as @sensor_configs.
+
+        robot_uids (Union[str, BaseAgent, List[Union[str, BaseAgent]]]): List of robots to instantiate and control in the environment.
+
+        sim_config (Union[SimConfig, dict]): Configurations for simulation if used that override the environment defaults. If given
+            a dictionary, it can just override specific attributes e.g. ``sim_config=dict(scene_config=dict(solver_iterations=25))``. If
+            passing in a SimConfig object, while typed, will override every attribute including the task defaults. Some environments
+            define their own recommended default sim configurations via the ``self._default_sim_config`` attribute that generally should not be
+            completely overriden.
+
+        reconfiguration_freq (int): How frequently to call reconfigure when environment is reset via `self.reset(...)`
+            Generally for most users who are not building tasks this does not need to be changed. The default is 0, which means
+            the environment reconfigures upon creation, and never again.
+
+        sim_backend (str): By default this is "auto". If sim_backend is "auto", then if ``num_envs == 1``, we use the PhysX CPU sim backend, otherwise
+            we use the PhysX GPU sim backend and automatically pick a GPU to use.
+            Can also be "physx_cpu" or "physx_cuda" to force usage of a particular sim backend.
+            To select a particular GPU to run the simulation on, you can pass "cuda:n" where n is the ID of the GPU,
+            similar to the way PyTorch selects GPUs.
+            Note that if this is "physx_cpu", num_envs can only be equal to 1.
+
+        render_backend (str): By default this is "gpu". If render_backend is "gpu", then we auto select a GPU to render with.
+            It can be "cuda:n" where n is the ID of the GPU to render with. If this is "cpu", then we render on the CPU.
+
+        parallel_in_single_scene (bool): By default this is False. If True, rendered images and the GUI will show all objects in one view.
+            This is only really useful for generating cool videos showing all environments at once but it is not recommended
+            otherwise as it slows down simulation and rendering.
+
+        enhanced_determinism (bool): By default this is False and env resets will reset the episode RNG only when a seed / seed list is given.
+            If True, the environment will reset the episode RNG upon each reset regardless of whether a seed is provided.
+            Generally enhanced_determinisim is not needed and users are recommended to pass seeds into the env reset function instead.
+    """
+
+    # fmt: off
+    SUPPORTED_ROBOTS: List[Union[str, Tuple[str]]] = None
+    """Override this to enforce which robots or tuples of robots together are supported in the task. During env creation,
+    setting robot_uids auto loads all desired robots into the scene, but not all tasks are designed to support some robot setups"""
+    SUPPORTED_OBS_MODES = ("state", "state_dict", "none", "sensor_data", "any_textures", "pointcloud")
+    """The string observation modes the environment supports. Note that "none" and "any_texture" are special keys. none indicates no observation data is generated.
+    "any_texture" indicates that any combination of image textures generated by cameras are supported e.g. rgb+depth, normal+segmentation, albedo+rgb+depth etc.
+    For a full list of supported textures see """
+    SUPPORTED_REWARD_MODES = ("normalized_dense", "dense", "sparse", "none")
+    SUPPORTED_RENDER_MODES = ("human", "rgb_array", "sensors", "all")
+    """The supported render modes. Human opens up a GUI viewer. rgb_array returns an rgb array showing the current environment state.
+    sensors returns an rgb array but only showing all data collected by sensors as images put together"""
+
+    metadata = {"render_modes": SUPPORTED_RENDER_MODES}
+
+    scene: ManiSkillScene = None
+    """the main scene, which manages all sub scenes. In CPU simulation there is only one sub-scene"""
+
+    agent: BaseAgent
+
+    action_space: gym.Space
+    """the batched action space of the environment, which is also the action space of the agent"""
+    single_action_space: gym.Space
+    """the unbatched action space of the environment"""
+
+    _sensors: Dict[str, BaseSensor]
+    """all sensors configured in this environment"""
+    _sensor_configs: Dict[str, BaseSensorConfig]
+    """all sensor configurations parsed from self._sensor_configs and agent._sensor_configs"""
+    _agent_sensor_configs: Dict[str, BaseSensorConfig]
+    """all agent sensor configs parsed from agent._sensor_configs"""
+    _human_render_cameras: Dict[str, Camera]
+    """cameras used for rendering the current environment retrievable via `env.render_rgb_array()`. These are not used to generate observations"""
+    _default_human_render_camera_configs: Dict[str, CameraConfig]
+    """all camera configurations for cameras used for human render"""
+    _human_render_camera_configs: Dict[str, CameraConfig]
+    """all camera configurations parsed from self._human_render_camera_configs"""
+
+    _hidden_objects: List[Union[Actor, Articulation]] = []
+    """list of objects that are hidden during rendering when generating visual observations / running render_cameras()"""
+
+    _main_rng: np.random.RandomState = None
+    """main rng generator that generates episode seed sequences. For internal use only"""
+    _batched_main_rng: BatchedRNG = None
+    """the batched main RNG that generates episode seed sequences. For internal use only"""
+    _main_seed: List[int] = None
+    """main seed list for _main_rng and _batched_main_rng. _main_rng uses _main_seed[0]. For internal use only"""
+    _episode_rng: np.random.RandomState = None
+    """the numpy RNG that you can use to generate random numpy data. It is not recommended to use this. Instead use the _batched_episode_rng which helps ensure GPU and CPU simulation generate the same data with the same seeds."""
+    _batched_episode_rng: BatchedRNG = None
+    """the recommended batched episode RNG to generate random numpy data consistently between single and parallel environments"""
+    _episode_seed: np.ndarray = None
+    """episode seed list for _episode_rng and _batched_episode_rng. _episode_rng uses _episode_seed[0]."""
+    _batched_rng_backend = "numpy:random_state"
+    """the backend to use for the batched RNG"""
+    _enhanced_determinism: bool = False
+    """whether to reset the episode RNG upon each reset regardless of whether a seed is provided"""
+
+    _parallel_in_single_scene: bool = False
+    """whether all objects are placed in one scene for the purpose of rendering all objects together instead of in parallel"""
+
+    _sim_device: sapien.Device = None
+    """the sapien device object the simulation runs on"""
+
+    _render_device: sapien.Device = None
+    """the sapien device object the renderer runs on"""
+
+    _viewer: Union[sapien.utils.Viewer, None] = None
+
+    _sample_video_link: Optional[str] = None
+    """a link to a sample video of the task. This is mostly used for automatic documentation generation"""
+
+    def __init__(
+        self,
+        num_envs: int = 1,
+        obs_mode: Optional[str] = None,
+        reward_mode: Optional[str] = None,
+        control_mode: Optional[str] = None,
+        render_mode: Optional[str] = None,
+        shader_dir: Optional[str] = None,
+        enable_shadow: bool = False,
+        sensor_configs: Optional[dict] = dict(),
+        human_render_camera_configs: Optional[dict] = dict(),
+        viewer_camera_configs: Optional[dict] = dict(),
+        robot_uids: Union[str, BaseAgent, List[Union[str, BaseAgent]]] = None,
+        sim_config: Union[SimConfig, dict] = dict(),
+        reconfiguration_freq: Optional[int] = None,
+        sim_backend: str = "auto",
+        render_backend: str = "gpu",
+        parallel_in_single_scene: bool = False,
+        enhanced_determinism: bool = False,
+    ):
+        self._enhanced_determinism = enhanced_determinism
+
+        self.num_envs = num_envs
+        self.reconfiguration_freq = reconfiguration_freq if reconfiguration_freq is not None else 0
+        self._reconfig_counter = 0
+        if shader_dir is not None:
+            logger.warn("shader_dir argument will be deprecated after ManiSkill v3.0.0 official release. Please use sensor_configs/human_render_camera_configs to set shaders.")
+            sensor_configs |= dict(shader_pack=shader_dir)
+            human_render_camera_configs |= dict(shader_pack=shader_dir)
+            viewer_camera_configs |= dict(shader_pack=shader_dir)
+        self._custom_sensor_configs = sensor_configs
+        self._custom_human_render_camera_configs = human_render_camera_configs
+        self._custom_viewer_camera_configs = viewer_camera_configs
+        self._parallel_in_single_scene = parallel_in_single_scene
+        self.robot_uids = robot_uids
+        if isinstance(robot_uids, tuple) and len(robot_uids) == 1:
+            self.robot_uids = robot_uids[0]
+        if self.SUPPORTED_ROBOTS is not None:
+            if self.robot_uids not in self.SUPPORTED_ROBOTS:
+                logger.warn(f"{self.robot_uids} is not in the task's list of supported robots. Code may not run as intended")
+
+        if sim_backend == "auto":
+            if num_envs > 1:
+                sim_backend = "physx_cuda"
+            else:
+                sim_backend = "physx_cpu"
+        self.backend = parse_sim_and_render_backend(sim_backend, render_backend)
+        # determine the sim and render devices
+        self.device = self.backend.device
+        self._sim_device = self.backend.sim_device
+        self._render_device = self.backend.render_device
+        if self.device.type == "cuda":
+            if not physx.is_gpu_enabled():
+                physx.enable_gpu()
+
+        # raise a number of nicer errors
+        if sim_backend == "cpu" and num_envs > 1:
+            raise RuntimeError("""Cannot set the sim backend to 'cpu' and have multiple environments.
+            If you want to do CPU sim backends and have environment vectorization you must use multi-processing across CPUs.
+            This can be done via the gymnasium's AsyncVectorEnv API""")
+
+        if shader_dir is not None:
+            if "rt" == shader_dir[:2]:
+                if num_envs > 1 and parallel_in_single_scene == False:
+                    raise RuntimeError("""Currently you cannot run ray-tracing on more than one environment in a single process""")
+
+        assert not parallel_in_single_scene or (obs_mode not in ["sensor_data", "pointcloud", "rgb", "depth", "rgbd"]), \
+            "Parallel rendering from parallel cameras is only supported when the gui/viewer is not used. parallel_in_single_scene must be False if using parallel rendering. If True only state based observations are supported."
+
+        if isinstance(sim_config, SimConfig):
+            sim_config = sim_config.dict()
+        merged_gpu_sim_config = self._default_sim_config.dict()
+        common.dict_merge(merged_gpu_sim_config, sim_config)
+        self.sim_config = dacite.from_dict(data_class=SimConfig, data=merged_gpu_sim_config, config=dacite.Config(strict=True))
+        """the final sim config after merging user overrides with the environment default"""
+        physx.set_gpu_memory_config(**self.sim_config.gpu_memory_config.dict())
+        sapien.render.set_log_level(os.getenv("MS_RENDERER_LOG_LEVEL", "warn"))
+
+        # Set simulation and control frequency
+        self._sim_freq = self.sim_config.sim_freq
+        self._control_freq = self.sim_config.control_freq
+        assert self._sim_freq % self._control_freq == 0, f"sim_freq({self._sim_freq}) is not divisible by control_freq({self._control_freq})."
+        self._sim_steps_per_control = self._sim_freq // self._control_freq
+
+        # Observation mode
+        if obs_mode is None:
+            obs_mode = self.SUPPORTED_OBS_MODES[0]
+        if obs_mode not in self.SUPPORTED_OBS_MODES:
+            # we permit any combination of visual observation textures e.g. rgb+normal, depth+segmentation, etc.
+            if "any_textures" in self.SUPPORTED_OBS_MODES:
+                # the parse_visual_obs_mode_to_struct will check if the textures requested are valid
+                pass
+            else:
+                raise NotImplementedError(f"Unsupported obs mode: {obs_mode}. Must be one of {self.SUPPORTED_OBS_MODES}")
+        self._obs_mode = obs_mode
+        self.obs_mode_struct = parse_obs_mode_to_struct(self._obs_mode)
+        """dataclass describing what observation data is being requested by the user, detailing if state data is requested and what visual data is requested"""
+
+        # Reward mode
+        if reward_mode is None:
+            reward_mode = self.SUPPORTED_REWARD_MODES[0]
+        if reward_mode not in self.SUPPORTED_REWARD_MODES:
+            raise NotImplementedError("Unsupported reward mode: {}".format(reward_mode))
+        self._reward_mode = reward_mode
+
+        # Control mode
+        self._control_mode = control_mode
+        # TODO(jigu): Support dict action space
+        if control_mode == "*":
+            raise NotImplementedError("Multiple controllers are not supported yet.")
+
+        # Render mode
+        self.render_mode = render_mode
+        self._viewer = None
+
+        # Lighting
+        self.enable_shadow = enable_shadow
+
+        # Use a fixed (main) seed to enhance determinism
+        self._main_seed = None
+        self._set_main_rng([2022 + i for i in range(self.num_envs)])
+        self._elapsed_steps = (
+            torch.zeros(self.num_envs, device=self.device, dtype=torch.int32)
+        )
+        obs, _ = self.reset(seed=[2022 + i for i in range(self.num_envs)], options=dict(reconfigure=True))
+
+        self._init_raw_obs = common.to_cpu_tensor(obs)
+        """the raw observation returned by the env.reset (a cpu torch tensor/dict of tensors). Useful for future observation wrappers to use to auto generate observation spaces"""
+        self._init_raw_state = common.to_cpu_tensor(self.get_state_dict())
+        """the initial raw state returned by env.get_state. Useful for reconstructing state dictionaries from flattened state vectors"""
+
+        if self.agent is not None:
+            self.action_space = self.agent.action_space
+            """the batched action space of the environment, which is also the action space of the agent"""
+            self.single_action_space = self.agent.single_action_space
+            """the unbatched action space of the environment"""
+            self._orig_single_action_space = copy.deepcopy(self.single_action_space)
+            """the original unbatched action space of the environment"""
+        else:
+            self.action_space = None
+        # initialize the cached properties
+        self.single_observation_space
+        self.observation_space
+
+    def update_obs_space(self, obs: torch.Tensor):
+        """A convenient function to auto generate observation spaces if you modify them.
+        Call this function if you modify the observations returned by env.step and env.reset via an observation wrapper.
+
+        The recommended way to use this is in a observation wrapper is as so
+
+        .. code-block:: python
+
+            import gymnasium as gym
+            from mani_skill.envs.sapien_env import BaseEnv
+            class YourObservationWrapper(gym.ObservationWrapper):
+                def __init__(self, env):
+                    super().__init__(env)
+                    self.base_env.update_obs_space(self.observation(self.base_env._init_raw_obs))
+                @property
+                def base_env(self) -> BaseEnv:
+                    return self.env.unwrapped
+                def observation(self, obs):
+                    # your code for transforming the observation
+        """
+        self._init_raw_obs = obs
+        del self.single_observation_space
+        del self.observation_space
+        self.single_observation_space
+        self.observation_space
+
+    @cached_property
+    def single_observation_space(self) -> gym.Space:
+        """the unbatched observation space of the environment"""
+        return gym_utils.convert_observation_to_space(common.to_numpy(self._init_raw_obs), unbatched=True)
+
+    @cached_property
+    def observation_space(self) -> gym.Space:
+        """the batched observation space of the environment"""
+        return batch_space(self.single_observation_space, n=self.num_envs)
+
+    @property
+    def gpu_sim_enabled(self):
+        """Whether the gpu simulation is enabled."""
+        return self.scene.gpu_sim_enabled
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig()
+    def _load_agent(self, options: dict, initial_agent_poses: Optional[Union[sapien.Pose, Pose]] = None):
+        agents = []
+        robot_uids = self.robot_uids
+        if not isinstance(initial_agent_poses, list):
+            initial_agent_poses = [initial_agent_poses]
+        if robot_uids == "none" or robot_uids == ("none", ):
+            self.agent = None
+            return
+        if robot_uids is not None:
+            if not isinstance(robot_uids, tuple):
+                robot_uids = [robot_uids]
+            for i, robot_uid in enumerate(robot_uids):
+                if isinstance(robot_uid, type(BaseAgent)):
+                    agent_cls = robot_uid
+                else:
+                    if robot_uid not in REGISTERED_AGENTS:
+                        raise RuntimeError(
+                            f"Agent {robot_uid} not found in the dict of registered agents. If the id is not a typo then make sure to apply the @register_agent() decorator."
+                        )
+                    agent_cls = REGISTERED_AGENTS[robot_uid].agent_cls
+                agent: BaseAgent = agent_cls(
+                    self.scene,
+                    self._control_freq,
+                    self._control_mode,
+                    agent_idx=i if len(robot_uids) > 1 else None,
+                    initial_pose=initial_agent_poses[i] if initial_agent_poses is not None else None,
+                )
+                agents.append(agent)
+        if len(agents) == 1:
+            self.agent = agents[0]
+        else:
+            self.agent = MultiAgent(agents)
+
+    @property
+    def _default_sensor_configs(
+        self,
+    ) -> Union[
+        BaseSensorConfig, Sequence[BaseSensorConfig], Dict[str, BaseSensorConfig]
+    ]:
+        """Add default (non-agent) sensors to the environment by returning sensor configurations. These can be overriden by the user at
+        env creation time"""
+        return []
+    @property
+    def _default_human_render_camera_configs(
+        self,
+    ) -> Union[
+        CameraConfig, Sequence[CameraConfig], Dict[str, CameraConfig]
+    ]:
+        """Add default cameras for rendering when using render_mode='rgb_array'. These can be overriden by the user at env creation time """
+        return []
+
+    @property
+    def _default_viewer_camera_configs(
+        self,
+    ) -> CameraConfig:
+        """Default configuration for the viewer camera, controlling shader, fov, etc. By default if there is a human render camera called "render_camera" then the viewer will use that camera's pose."""
+        return CameraConfig(uid="viewer", pose=sapien.Pose([0, 0, 1]), width=1920, height=1080, shader_pack="default", near=0.0, far=1000, fov=np.pi / 2)
+
+    @property
+    def sim_freq(self) -> int:
+        """The frequency (Hz) of the simulation loop"""
+        return self._sim_freq
+
+    @property
+    def control_freq(self):
+        """The frequency (Hz) of the control loop"""
+        return self._control_freq
+
+    @property
+    def sim_timestep(self):
+        """The timestep (dt) of the simulation loop"""
+        return 1.0 / self._sim_freq
+
+    @property
+    def control_timestep(self):
+        """The timestep (dt) of the control loop"""
+        return 1.0 / self._control_freq
+
+    @property
+    def control_mode(self) -> str:
+        """The control mode of the agent"""
+        return self.agent.control_mode
+
+    @property
+    def elapsed_steps(self) -> torch.Tensor:
+        """The number of steps that have elapsed in the environment"""
+        return self._elapsed_steps
+
+    # ---------------------------------------------------------------------------- #
+    # Observation
+    # ---------------------------------------------------------------------------- #
+    @property
+    def obs_mode(self) -> str:
+        """The current observation mode. This affects the observation returned by env.get_obs()"""
+        return self._obs_mode
+
+    def get_obs(self, info: Optional[Dict] = None):
+        """
+        Return the current observation of the environment. User may call this directly to get the current observation
+        as opposed to taking a step with actions in the environment.
+
+        Note that some tasks use info of the current environment state to populate the observations to avoid having to
+        compute slow operations twice. For example a state based observation may wish to include a boolean indicating
+        if a robot is grasping an object. Computing this boolean correctly is slow, so it is preferable to generate that
+        data in the info object by overriding the `self.evaluate` function.
+
+        Args:
+            info (Dict): The info object of the environment. Generally should always be the result of `self.get_info()`.
+                If this is None (the default), this function will call `self.get_info()` itself
+        """
+        if info is None:
+            info = self.get_info()
+        if self._obs_mode == "none":
+            # Some cases do not need observations, e.g., MPC
+            return dict()
+        elif self._obs_mode == "state":
+            state_dict = self._get_obs_state_dict(info)
+            obs = common.flatten_state_dict(state_dict, use_torch=True, device=self.device)
+        elif self._obs_mode == "state_dict":
+            obs = self._get_obs_state_dict(info)
+        elif self._obs_mode == "pointcloud":
+            obs = self._get_obs_with_sensor_data(info)
+            obs = sensor_data_to_pointcloud(obs, self._sensors)
+        elif self._obs_mode == "sensor_data":
+            # return raw texture data dependent on choice of shader
+            obs = self._get_obs_with_sensor_data(info, apply_texture_transforms=False)
+        else:
+            obs = self._get_obs_with_sensor_data(info)
+
+        # flatten parts of the state observation if requested
+        if self.obs_mode_struct.state:
+            if isinstance(obs, dict):
+                data = dict(agent=obs.pop("agent"), extra=obs.pop("extra"))
+                obs["state"] = common.flatten_state_dict(data, use_torch=True, device=self.device)
+        return obs
+
+    def _get_obs_state_dict(self, info: Dict):
+        """Get (ground-truth) state-based observations."""
+        return dict(
+            agent=self._get_obs_agent(),
+            extra=self._get_obs_extra(info),
+        )
+
+    def _get_obs_agent(self):
+        """Get observations about the agent's state. By default it is proprioceptive observations which include qpos and qvel.
+        Controller state is also included although most default controllers do not have any state."""
+        return self.agent.get_proprioception()
+
+    def _get_obs_extra(self, info: Dict):
+        """Get task-relevant extra observations. Usually defined on a task by task basis"""
+        return dict()
+
+    def capture_sensor_data(self):
+        """Capture data from all sensors (non-blocking)"""
+        for sensor in self._sensors.values():
+            sensor.capture()
+
+    def get_sensor_images(self) -> Dict[str, Dict[str, torch.Tensor]]:
+        """Get image (RGB) visualizations of what sensors currently sense. This function calls self._get_obs_sensor_data() internally which automatically hides objects and updates the render"""
+        return self.scene.get_sensor_images(self._get_obs_sensor_data())
+
+    def get_sensor_params(self) -> Dict[str, Dict[str, torch.Tensor]]:
+        """Get all sensor parameters."""
+        params = dict()
+        for name, sensor in self._sensors.items():
+            params[name] = sensor.get_params()
+        return params
+
+    def _get_obs_sensor_data(self, apply_texture_transforms: bool = True) -> dict:
+        """get only data from sensors. Auto hides any objects that are designated to be hidden"""
+        for obj in self._hidden_objects:
+            obj.hide_visual()
+        self.scene.update_render(update_sensors=True, update_human_render_cameras=False)
+        self.capture_sensor_data()
+        sensor_obs = dict()
+        for name, sensor in self.scene.sensors.items():
+            if isinstance(sensor, Camera):
+                if self.obs_mode in ["state", "state_dict"]:
+                    # normally in non visual observation modes we do not render sensor observations. But some users may want to render sensor data for debugging or various algorithms
+                    sensor_obs[name] = sensor.get_obs(position=False, segmentation=False, apply_texture_transforms=apply_texture_transforms)
+                else:
+                    sensor_obs[name] = sensor.get_obs(
+                        rgb=self.obs_mode_struct.visual.rgb,
+                        depth=self.obs_mode_struct.visual.depth,
+                        position=self.obs_mode_struct.visual.position,
+                        segmentation=self.obs_mode_struct.visual.segmentation,
+                        normal=self.obs_mode_struct.visual.normal,
+                        albedo=self.obs_mode_struct.visual.albedo,
+                        apply_texture_transforms=apply_texture_transforms
+                    )
+        # explicitly synchronize and wait for cuda kernels to finish
+        # this prevents the GPU from making poor scheduling decisions when other physx code begins to run
+        torch.cuda.synchronize()
+        return sensor_obs
+    def _get_obs_with_sensor_data(self, info: Dict, apply_texture_transforms: bool = True) -> dict:
+        """Get the observation with sensor data"""
+        return dict(
+            agent=self._get_obs_agent(),
+            extra=self._get_obs_extra(info),
+            sensor_param=self.get_sensor_params(),
+            sensor_data=self._get_obs_sensor_data(apply_texture_transforms),
+        )
+
+    @property
+    def robot_link_names(self):
+        """Get link ids for the robot. This is used for segmentation observations."""
+        return self.agent.robot_link_names
+
+    # -------------------------------------------------------------------------- #
+    # Reward mode
+    # -------------------------------------------------------------------------- #
+    @property
+    def reward_mode(self):
+        return self._reward_mode
+
+    def get_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        if self._reward_mode == "sparse":
+            reward = self.compute_sparse_reward(obs=obs, action=action, info=info)
+        elif self._reward_mode == "dense":
+            reward = self.compute_dense_reward(obs=obs, action=action, info=info)
+        elif self._reward_mode == "normalized_dense":
+            reward = self.compute_normalized_dense_reward(
+                obs=obs, action=action, info=info
+            )
+        elif self._reward_mode == "none":
+            reward = torch.zeros((self.num_envs, ), dtype=torch.float, device=self.device)
+        else:
+            raise NotImplementedError(self._reward_mode)
+        return reward
+
+    def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        """
+        Computes the sparse reward. By default this function tries to use the success/fail information in
+        returned by the evaluate function and gives +1 if success, -1 if fail, 0 otherwise"""
+        if "success" in info:
+            if "fail" in info:
+                if isinstance(info["success"], torch.Tensor):
+                    reward = info["success"].to(torch.float) - info["fail"].to(torch.float)
+                else:
+                    reward = info["success"] - info["fail"]
+            else:
+                reward = info["success"]
+        else:
+            if "fail" in info:
+                reward = -info["fail"]
+            else:
+                reward = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)
+        return reward
+
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        raise NotImplementedError()
+
+    def compute_normalized_dense_reward(
+        self, obs: Any, action: torch.Tensor, info: Dict
+    ):
+        raise NotImplementedError()
+
+    # -------------------------------------------------------------------------- #
+    # Reconfigure
+    # -------------------------------------------------------------------------- #
+    def _reconfigure(self, options = dict()):
+        """Reconfigure the simulation scene instance.
+        This function clears the previous scene and creates a new one.
+
+        Note this function is not always called when an environment is reset, and
+        should only be used if any agents, assets, sensors, lighting need to change
+        to save compute time.
+
+        Tasks like PegInsertionSide and TurnFaucet will call this each time as the peg
+        shape changes each time and the faucet model changes each time respectively.
+        """
+
+        self._clear()
+        # load everything into the scene first before initializing anything
+        self._setup_scene()
+
+        self._load_agent(options)
+
+        self._load_scene(options)
+        self._load_lighting(options)
+
+        self.scene._setup(enable_gpu=self.gpu_sim_enabled)
+        # for GPU sim, we have to setup sensors after we call setup gpu in order to enable loading mounted sensors as they depend on GPU buffer data
+        self._setup_sensors(options)
+        if self._viewer is not None:
+            self._setup_viewer()
+        self._reconfig_counter = self.reconfiguration_freq
+
+        # delete various cached properties and reinitialize
+        # TODO (stao): The code is 3 lines because you have to initialize it once somewhere...
+        self.segmentation_id_map
+        del self.segmentation_id_map
+        self.segmentation_id_map
+
+    def _after_reconfigure(self, options):
+        """Add code here that should run immediately after self._reconfigure is called. The torch RNG context is still active so RNG is still
+        seeded here by self._episode_seed. This is useful if you need to run something that only happens after reconfiguration but need the
+        GPU initialized so that you can check e.g. collisons, poses etc."""
+
+    def _load_scene(self, options: dict):
+        """Loads all objects like actors and articulations into the scene. Called by `self._reconfigure`. Given options argument
+        is the same options dictionary passed to the self.reset function"""
+
+    # TODO (stao): refactor this into sensor API
+    def _setup_sensors(self, options: dict):
+        """Setup sensor configurations and the sensor objects in the scene. Called by `self._reconfigure`"""
+
+        # First create all the configurations
+        self._sensor_configs = dict()
+
+        # Add task/external sensors
+        self._sensor_configs.update(parse_camera_configs(self._default_sensor_configs))
+
+        # Add agent sensors
+        self._agent_sensor_configs = dict()
+        if self.agent is not None:
+            self._agent_sensor_configs = parse_camera_configs(self.agent._sensor_configs)
+            self._sensor_configs.update(self._agent_sensor_configs)
+
+        # Add human render camera configs
+        self._human_render_camera_configs = parse_camera_configs(
+            self._default_human_render_camera_configs
+        )
+
+        self._viewer_camera_config = parse_camera_configs(
+            self._default_viewer_camera_configs
+        )
+
+        # Override camera configurations with user supplied configurations
+        if self._custom_sensor_configs is not None:
+            update_camera_configs_from_dict(
+                self._sensor_configs, self._custom_sensor_configs
+            )
+        if self._custom_human_render_camera_configs is not None:
+            update_camera_configs_from_dict(
+                self._human_render_camera_configs,
+                self._custom_human_render_camera_configs,
+            )
+        if self._custom_viewer_camera_configs is not None:
+            update_camera_configs_from_dict(
+                self._viewer_camera_config,
+                self._custom_viewer_camera_configs,
+            )
+        self._viewer_camera_config = self._viewer_camera_config["viewer"]
+
+        # Now we instantiate the actual sensor objects
+        self._sensors = dict()
+
+        for uid, sensor_config in self._sensor_configs.items():
+            if uid in self._agent_sensor_configs:
+                articulation = self.agent.robot
+            else:
+                articulation = None
+            if isinstance(sensor_config, StereoDepthCameraConfig):
+                sensor_cls = StereoDepthCamera
+            elif isinstance(sensor_config, CameraConfig):
+                sensor_cls = Camera
+            self._sensors[uid] = sensor_cls(
+                sensor_config,
+                self.scene,
+                articulation=articulation,
+            )
+
+        # Cameras for rendering only
+        self._human_render_cameras = dict()
+        for uid, camera_config in self._human_render_camera_configs.items():
+            self._human_render_cameras[uid] = Camera(
+                camera_config,
+                self.scene,
+            )
+
+        self.scene.sensors = self._sensors
+        self.scene.human_render_cameras = self._human_render_cameras
+
+    def _load_lighting(self, options: dict):
+        """Loads lighting into the scene. Called by `self._reconfigure`. If not overriden will set some simple default lighting"""
+
+        shadow = self.enable_shadow
+        self.scene.set_ambient_light([0.3, 0.3, 0.3])
+        self.scene.add_directional_light(
+            [1, 1, -1], [1, 1, 1], shadow=shadow, shadow_scale=5, shadow_map_size=2048
+        )
+        self.scene.add_directional_light([0, 0, -1], [1, 1, 1])
+    # -------------------------------------------------------------------------- #
+    # Reset
+    # -------------------------------------------------------------------------- #
+    def reset(self, seed: Union[None, int, list[int]] = None, options: Union[None, dict] = None):
+        """Reset the ManiSkill environment with given seed(s) and options. Typically seed is either None (for unseeded reset) or an int (seeded reset).
+        For GPU parallelized environments you can also pass a list of seeds for each parallel environment to seed each one separately.
+
+        If options["env_idx"] is given, will only reset the selected parallel environments. If
+        options["reconfigure"] is True, will call self._reconfigure() which deletes the entire physx scene and reconstructs everything.
+        Users building custom tasks generally do not need to override this function.
+
+        Returns the first observation and a info dictionary. The info dictionary is of type
+
+
+        .. highlight:: python
+        .. code-block:: python
+
+            {
+                "reconfigure": bool # (True if the env reconfigured. False otherwise)
+            }
+
+
+
+        Note that ManiSkill always holds two RNG states, a main RNG, and an episode RNG. The main RNG is used purely to sample an episode seed which
+        helps with reproducibility of episodes and is for internal use only. The episode RNG is used by the environment/task itself to
+        e.g. randomize object positions, randomize assets etc. Episode RNG is accessible by using `self._batched_episode_rng` which is numpy based and `torch.rand`
+        which can be used to generate random data on the GPU directly and is seeded. Note that it is recommended to use `self._batched_episode_rng`
+        if you need to ensure during reconfiguration the same objects are loaded. Reproducibility and seeding when there is GPU and CPU simulation can be tricky and we recommend reading
+        the documentation for more recommendations and details on RNG https://maniskill.readthedocs.io/en/latest/user_guide/concepts/rng.html
+
+        Upon environment creation via gym.make, the main RNG is set with fixed seeds of 2022 to 2022 + num_envs - 1 (seed is just 2022 if there is only one environment)
+        During each reset call, if seed is None, main RNG is unchanged and an episode seed is sampled from the main RNG to create the episode RNG.
+        If seed is not None, main RNG is set to that seed and the episode seed is also set to that seed. This design means the main RNG determines
+        the episode RNG deterministically.
+
+        """
+        if options is None:
+            options = dict()
+        reconfigure = options.get("reconfigure", False)
+        reconfigure = reconfigure or (
+            self._reconfig_counter == 0 and self.reconfiguration_freq != 0
+        )
+        if "env_idx" in options:
+            env_idx = options["env_idx"]
+            if len(env_idx) != self.num_envs and reconfigure:
+                raise RuntimeError("Cannot do a partial reset and reconfigure the environment. You must do one or the other.")
+        else:
+            env_idx = torch.arange(0, self.num_envs, device=self.device)
+
+        self._set_main_rng(seed)
+
+        if reconfigure:
+            self._set_episode_rng(seed if seed is not None else self._batched_main_rng.randint(2**31), env_idx)
+            with torch.random.fork_rng():
+                torch.manual_seed(seed=self._episode_seed[0])
+                self._reconfigure(options)
+                self._after_reconfigure(options)
+            # Set the episode rng again after reconfiguration to guarantee seed reproducibility
+            self._set_episode_rng(self._episode_seed, env_idx)
+        else:
+            self._set_episode_rng(seed, env_idx)
+
+        # TODO (stao): Reconfiguration when there is partial reset might not make sense and certainly broken here now.
+        # Solution to resolve that would be to ensure tasks that do reconfigure more than once are single-env only / cpu sim only
+        # or disable partial reset features explicitly for tasks that have a reconfiguration frequency
+        self.scene._reset_mask = torch.zeros(
+            self.num_envs, dtype=torch.bool, device=self.device
+        )
+        self.scene._reset_mask[env_idx] = True
+        self._elapsed_steps[env_idx] = 0
+
+        self._clear_sim_state()
+        if self.reconfiguration_freq != 0:
+            self._reconfig_counter -= 1
+
+        if self.agent is not None:
+            self.agent.reset()
+
+        if seed is not None or self._enhanced_determinism:
+            with torch.random.fork_rng():
+                torch.manual_seed(self._episode_seed[0])
+                self._initialize_episode(env_idx, options)
+        else:
+            self._initialize_episode(env_idx, options)
+        # reset the reset mask back to all ones so any internal code in maniskill can continue to manipulate all scenes at once as usual
+        self.scene._reset_mask = torch.ones(
+            self.num_envs, dtype=bool, device=self.device
+        )
+        if self.gpu_sim_enabled:
+            # ensure all updates to object poses and configurations are applied on GPU after task initialization
+            self.scene._gpu_apply_all()
+            self.scene.px.gpu_update_articulation_kinematics()
+            self.scene._gpu_fetch_all()
+
+        # we reset controllers here because some controllers depend on the agent/articulation qpos/poses
+        if self.agent is not None:
+            if isinstance(self.agent.controller, dict):
+                for controller in self.agent.controller.values():
+                    controller.reset()
+            else:
+                self.agent.controller.reset()
+
+        info = self.get_info()
+        obs = self.get_obs(info)
+
+        info["reconfigure"] = reconfigure
+        return obs, info
+
+    def _set_main_rng(self, seed):
+        """Set the main random generator which is only used to set the seed of the episode RNG to improve reproducibility.
+
+        Note that while _set_main_rng and _set_episode_rng are setting a seed and numpy random state, when using GPU sim
+        parallelization it is highly recommended to use torch random functions as they will make things run faster. The use
+        of torch random functions when building tasks in ManiSkill are automatically seeded via `torch.random.fork`
+        """
+        if seed is None:
+            if self._main_seed is not None:
+                return
+            seed = np.random.RandomState().randint(2**31, size=(self.num_envs,))
+        if not np.iterable(seed):
+            seed = [seed]
+        self._main_seed = seed
+        self._main_rng = np.random.RandomState(self._main_seed[0])
+        if len(self._main_seed) == 1 and self.num_envs > 1:
+            self._main_seed = self._main_seed + np.random.RandomState(self._main_seed[0]).randint(2**31, size=(self.num_envs - 1,)).tolist()
+        self._batched_main_rng = BatchedRNG.from_seeds(self._main_seed, backend=self._batched_rng_backend)
+
+    def _set_episode_rng(self, seed: Union[None, list[int]], env_idx: torch.Tensor):
+        """Set the random generator for current episode."""
+        if seed is not None or self._enhanced_determinism:
+            env_idx = common.to_numpy(env_idx)
+            if seed is None:
+                self._episode_seed[env_idx] = self._batched_main_rng[env_idx].randint(2**31)
+            else:
+                if not np.iterable(seed):
+                    seed = [seed]
+                self._episode_seed = common.to_numpy(seed, dtype=np.int64)
+                if len(self._episode_seed) == 1 and self.num_envs > 1:
+                    self._episode_seed = np.concatenate((self._episode_seed, np.random.RandomState(self._episode_seed[0]).randint(2**31, size=(self.num_envs - 1,))))
+            # we keep _episode_rng for backwards compatibility but recommend using _batched_episode_rng for randomization
+            if seed is not None or self._batched_episode_rng is None:
+                self._batched_episode_rng = BatchedRNG.from_seeds(self._episode_seed, backend=self._batched_rng_backend)
+            else:
+                self._batched_episode_rng[env_idx] = BatchedRNG.from_seeds(self._episode_seed[env_idx], backend=self._batched_rng_backend)
+            self._episode_rng = self._batched_episode_rng[0]
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        """Initialize the episode, e.g., poses of actors and articulations, as well as task relevant data like randomizing
+        goal positions
+        """
+
+    def _clear_sim_state(self):
+        """Clear simulation state (velocities)"""
+        for actor in self.scene.actors.values():
+            if actor.px_body_type == "dynamic":
+                actor.set_linear_velocity(torch.zeros(3, device=self.device))
+                actor.set_angular_velocity(torch.zeros(3, device=self.device))
+        for articulation in self.scene.articulations.values():
+            articulation.set_qvel(torch.zeros(articulation.max_dof, device=self.device))
+            articulation.set_root_linear_velocity(torch.zeros(3, device=self.device))
+            articulation.set_root_angular_velocity(torch.zeros(3, device=self.device))
+        if self.gpu_sim_enabled:
+            self.scene._gpu_apply_all()
+            self.scene._gpu_fetch_all()
+            # TODO (stao): This may be an unnecessary fetch and apply.
+
+    # -------------------------------------------------------------------------- #
+    # Step
+    # -------------------------------------------------------------------------- #
+
+    def step(self, action: Union[None, np.ndarray, torch.Tensor, Dict]):
+        """
+        Take a step through the environment with an action. Actions are automatically clipped to the action space.
+
+        If ``action`` is None, the environment will proceed forward in time without sending any actions/control signals to the agent
+        """
+        action = self._step_action(action)
+        self._elapsed_steps += 1
+        info = self.get_info()
+        obs = self.get_obs(info)
+        reward = self.get_reward(obs=obs, action=action, info=info)
+        if "success" in info:
+
+            if "fail" in info:
+                terminated = torch.logical_or(info["success"], info["fail"])
+            else:
+                terminated = info["success"].clone()
+        else:
+            if "fail" in info:
+                terminated = info["fail"].clone()
+            else:
+                terminated = torch.zeros(self.num_envs, dtype=bool, device=self.device)
+
+        return (
+            obs,
+            reward,
+            terminated,
+            torch.zeros(self.num_envs, dtype=bool, device=self.device),
+            info,
+        )
+
+    def _step_action(
+        self, action: Union[None, np.ndarray, torch.Tensor, Dict]
+    ) -> Union[None, torch.Tensor]:
+        set_action = False
+        action_is_unbatched = False
+        if action is None:  # simulation without action
+            pass
+        elif isinstance(action, np.ndarray) or isinstance(action, torch.Tensor):
+            action = common.to_tensor(action, device=self.device)
+            if action.shape == self._orig_single_action_space.shape:
+                action_is_unbatched = True
+            set_action = True
+        elif isinstance(action, dict):
+            if "control_mode" in action:
+                if action["control_mode"] != self.agent.control_mode:
+                    self.agent.set_control_mode(action["control_mode"])
+                    self.agent.controller.reset()
+                action = common.to_tensor(action["action"], device=self.device)
+                if action.shape == self._orig_single_action_space.shape:
+                    action_is_unbatched = True
+            else:
+                assert isinstance(
+                    self.agent, MultiAgent
+                ), "Received a dictionary for an action but there are not multiple robots in the environment"
+                # assume this is a multi-agent action
+                action = common.to_tensor(action, device=self.device)
+                for k, a in action.items():
+                    if a.shape == self._orig_single_action_space[k].shape:
+                        action_is_unbatched = True
+                        break
+            set_action = True
+        else:
+            raise TypeError(type(action))
+
+        if set_action:
+            if self.num_envs == 1 and action_is_unbatched:
+                action = common.batch(action)
+            self.agent.set_action(action)
+            if self._sim_device.is_cuda():
+                self.scene.px.gpu_apply_articulation_target_position()
+                self.scene.px.gpu_apply_articulation_target_velocity()
+        self._before_control_step()
+        for _ in range(self._sim_steps_per_control):
+            if self.agent is not None:
+                self.agent.before_simulation_step()
+            self._before_simulation_step()
+            self.scene.step()
+            self._after_simulation_step()
+        self._after_control_step()
+        if self.gpu_sim_enabled:
+            self.scene._gpu_fetch_all()
+        return action
+
+    def evaluate(self) -> dict:
+        """
+        Evaluate whether the environment is currently in a success state by returning a dictionary with a "success" key or
+        a failure state via a "fail" key
+
+        This function may also return additional data that has been computed (e.g. is the robot grasping some object) that may be
+        reused when generating observations and rewards.
+
+        By default if not overriden this function returns an empty dictionary
+        """
+        return dict()
+
+    def get_info(self) -> dict:
+        """
+        Get info about the current environment state, include elapsed steps and evaluation information
+        """
+        info = dict(
+            elapsed_steps=self.elapsed_steps
+            if not self.gpu_sim_enabled
+            else self._elapsed_steps.clone()
+        )
+        info.update(self.evaluate())
+        return info
+
+    def _before_control_step(self):
+        """Code that runs before each action has been taken via env.step(action).
+        On GPU simulation this is called before observations are fetched from the GPU buffers."""
+    def _after_control_step(self):
+        """Code that runs after each action has been taken.
+        On GPU simulation this is called right before observations are fetched from the GPU buffers."""
+
+    def _before_simulation_step(self):
+        """Code to run right before each physx_system.step is called"""
+    def _after_simulation_step(self):
+        """Code to run right after each physx_system.step is called"""
+
+    # -------------------------------------------------------------------------- #
+    # Simulation and other gym interfaces
+    # -------------------------------------------------------------------------- #
+    def _set_scene_config(self):
+        physx.set_shape_config(contact_offset=self.sim_config.scene_config.contact_offset, rest_offset=self.sim_config.scene_config.rest_offset)
+        physx.set_body_config(solver_position_iterations=self.sim_config.scene_config.solver_position_iterations, solver_velocity_iterations=self.sim_config.scene_config.solver_velocity_iterations, sleep_threshold=self.sim_config.scene_config.sleep_threshold)
+        physx.set_scene_config(gravity=self.sim_config.scene_config.gravity, bounce_threshold=self.sim_config.scene_config.bounce_threshold, enable_pcm=self.sim_config.scene_config.enable_pcm, enable_tgs=self.sim_config.scene_config.enable_tgs, enable_ccd=self.sim_config.scene_config.enable_ccd, enable_enhanced_determinism=self.sim_config.scene_config.enable_enhanced_determinism, enable_friction_every_iteration=self.sim_config.scene_config.enable_friction_every_iteration, cpu_workers=self.sim_config.scene_config.cpu_workers )
+        physx.set_default_material(**self.sim_config.default_materials_config.dict())
+
+    def _setup_scene(self):
+        """Setup the simulation scene instance.
+        The function should be called in reset(). Called by `self._reconfigure`"""
+        self._set_scene_config()
+        if self._sim_device.is_cuda():
+            physx_system = physx.PhysxGpuSystem(device=self._sim_device)
+            # Create the scenes in a square grid
+            sub_scenes = []
+            scene_grid_length = int(np.ceil(np.sqrt(self.num_envs)))
+            for scene_idx in range(self.num_envs):
+                scene_x, scene_y = (
+                    scene_idx % scene_grid_length - scene_grid_length // 2,
+                    scene_idx // scene_grid_length - scene_grid_length // 2,
+                )
+                scene = sapien.Scene(
+                    systems=[physx_system, sapien.render.RenderSystem(self._render_device)]
+                )
+                physx_system.set_scene_offset(
+                    scene,
+                    [
+                        scene_x * self.sim_config.spacing,
+                        scene_y * self.sim_config.spacing,
+                        0,
+                    ],
+                )
+                sub_scenes.append(scene)
+        else:
+            physx_system = physx.PhysxCpuSystem()
+            sub_scenes = [
+                sapien.Scene([physx_system, sapien.render.RenderSystem(self._render_device)])
+            ]
+        # create a "global" scene object that users can work with that is linked with all other scenes created
+        self.scene = ManiSkillScene(
+            sub_scenes,
+            sim_config=self.sim_config,
+            device=self.device,
+            parallel_in_single_scene=self._parallel_in_single_scene,
+            backend=self.backend
+        )
+        self.scene.px.timestep = 1.0 / self._sim_freq
+
+    def _clear(self):
+        """Clear the simulation scene instance and other buffers.
+        The function can be called in reset() before a new scene is created.
+        Called by `self._reconfigure` and when the environment is closed/deleted
+        """
+        self._close_viewer()
+        self.agent = None
+        self._sensors = dict()
+        self._human_render_cameras = dict()
+        self.scene = None
+        self._hidden_objects = []
+        gc.collect() # force gc to collect which releases most GPU memory
+
+    def close(self):
+        self._clear()
+
+    def _close_viewer(self):
+        if self._viewer is None:
+            return
+        self._viewer.close()
+        self._viewer = None
+
+    @cached_property
+    def segmentation_id_map(self):
+        """
+        Returns a dictionary mapping every ID to the appropriate Actor or Link object
+        """
+        res = dict()
+        for actor in self.scene.actors.values():
+            res[actor._objs[0].per_scene_id] = actor
+        for art in self.scene.articulations.values():
+            for link in art.links:
+                res[link._objs[0].entity.per_scene_id] = link
+        return res
+
+    def add_to_state_dict_registry(self, object: Union[Actor, Articulation]):
+        self.scene.add_to_state_dict_registry(object)
+    def remove_from_state_dict_registry(self, object: Union[Actor, Articulation]):
+        self.scene.remove_from_state_dict_registry(object)
+
+    def get_state_dict(self):
+        """
+        Get environment state dictionary. Override to include task information (e.g., goal)
+        """
+        return self.scene.get_sim_state()
+
+    def get_state(self):
+        """
+        Get environment state as a flat vector, which is just a ordered flattened version of the state_dict.
+
+        Users should not override this function
+        """
+        return common.flatten_state_dict(self.get_state_dict(), use_torch=True)
+
+    def set_state_dict(self, state: Dict, env_idx: torch.Tensor = None):
+        """
+        Set environment state with a state dictionary. Override to include task information (e.g., goal)
+
+        Note that it is recommended to keep around state dictionaries as opposed to state vectors. With state vectors we assume
+        the order of data in the vector is the same exact order that would be returned by flattening the state dictionary you get from
+        `env.get_state_dict()` or the result of `env.get_state()`
+        """
+        self.scene.set_sim_state(state, env_idx)
+        if self.gpu_sim_enabled:
+            self.scene._gpu_apply_all()
+            self.scene.px.gpu_update_articulation_kinematics()
+            self.scene._gpu_fetch_all()
+
+    def set_state(self, state: Array, env_idx: torch.Tensor = None):
+        """
+        Set environment state with a flat state vector. Internally this reconstructs the state dictionary and calls `env.set_state_dict`
+
+        Users should not override this function
+        """
+        state_dict = dict()
+        state_dict["actors"] = dict()
+        state_dict["articulations"] = dict()
+        KINEMATIC_DIM = 13  # [pos, quat, lin_vel, ang_vel]
+        start = 0
+        for actor_id in self._init_raw_state["actors"].keys():
+            state_dict["actors"][actor_id] = state[:, start : start + KINEMATIC_DIM]
+            start += KINEMATIC_DIM
+        for art_id, art_state in self._init_raw_state["articulations"].items():
+            size = art_state.shape[-1]
+            state_dict["articulations"][art_id] = state[:, start : start + size]
+            start += size
+        self.set_state_dict(state_dict, env_idx)
+
+    # -------------------------------------------------------------------------- #
+    # Visualization
+    # -------------------------------------------------------------------------- #
+    @property
+    def viewer(self):
+        return self._viewer
+
+    def _setup_viewer(self):
+        """Setup the interactive viewer.
+
+        The function should be called after a new scene is configured.
+        In subclasses, this function can be overridden to set viewer cameras.
+
+        Called by `self._reconfigure`
+        """
+        self._viewer.set_scene(self.scene.sub_scenes[0])
+        control_window: sapien.utils.viewer.control_window.ControlWindow = (
+            sapien_utils.get_obj_by_type(
+                self._viewer.plugins, sapien.utils.viewer.control_window.ControlWindow
+            )
+        )
+        control_window.show_joint_axes = False
+        control_window.show_camera_linesets = False
+        if "render_camera" in self._human_render_cameras:
+            self._viewer.set_camera_pose(
+                self._human_render_cameras["render_camera"].camera.global_pose[0].sp
+            )
+
+    def render_human(self):
+        """render the environment by opening a GUI viewer. This also returns the viewer object. Any objects registered in the _hidden_objects list will be shown"""
+        for obj in self._hidden_objects:
+            obj.show_visual()
+        if self._viewer is None:
+            self._viewer = create_viewer(self._viewer_camera_config)
+            self._setup_viewer()
+        if self.gpu_sim_enabled and self.scene._gpu_sim_initialized:
+            self.scene.px.sync_poses_gpu_to_cpu()
+        self._viewer.render()
+        for obj in self._hidden_objects:
+            obj.hide_visual()
+        return self._viewer
+
+    def render_rgb_array(self, camera_name: str = None):
+        """Returns an RGB array / image of size (num_envs, H, W, 3) of the current state of the environment.
+        This is captured by any of the registered human render cameras. If a camera_name is given, only data from that camera is returned.
+        Otherwise all camera data is captured and returned as a single batched image. Any objects registered in the _hidden_objects list will be shown"""
+        for obj in self._hidden_objects:
+            obj.show_visual()
+        self.scene.update_render(update_sensors=False, update_human_render_cameras=True)
+        images = []
+        render_images = self.scene.get_human_render_camera_images(camera_name)
+        for image in render_images.values():
+            images.append(image)
+        if len(images) == 0:
+            return None
+        if len(images) == 1:
+            return images[0]
+        for obj in self._hidden_objects:
+            obj.hide_visual()
+        return tile_images(images)
+
+    def render_sensors(self):
+        """
+        Renders all sensors that the agent can use and see and displays them in a human readable image format.
+        Any objects registered in the _hidden_objects list will not be shown
+        """
+        images = []
+        sensor_images = self.get_sensor_images()
+        for image in sensor_images.values():
+            for img in image.values():
+                images.append(img)
+        return tile_images(images)
+
+    def render_all(self):
+        """Renders all human render cameras and sensors together"""
+        images = []
+        for obj in self._hidden_objects:
+            obj.show_visual()
+        self.scene.update_render(update_sensors=True, update_human_render_cameras=True)
+        render_images = self.scene.get_human_render_camera_images()
+        # note that get_sensor_images function will update the render and hide objects itself
+        sensor_images = self.get_sensor_images()
+        for image in render_images.values():
+            images.append(image)
+        for image in sensor_images.values():
+            for img in image.values():
+                images.append(img)
+        return tile_images(images)
+
+    def render(self):
+        """
+        Either opens a viewer if ``self.render_mode`` is "human", or returns an array that you can use to save videos.
+
+        If ``self.render_mode`` is "rgb_array", usually a higher quality image is rendered for the purpose of viewing only.
+
+        If ``self.render_mode`` is "sensors", all visual observations the agent can see is provided
+
+        If ``self.render_mode`` is "all", this is then a combination of "rgb_array" and "sensors"
+        """
+        if self.render_mode is None:
+            raise RuntimeError("render_mode is not set.")
+        if self.render_mode == "human":
+            return self.render_human()
+        elif self.render_mode == "rgb_array":
+            res = self.render_rgb_array()
+            return res
+        elif self.render_mode == "sensors":
+            res = self.render_sensors()
+            return res
+        elif self.render_mode == "all":
+            return self.render_all()
+        else:
+            raise NotImplementedError(f"Unsupported render mode {self.render_mode}.")
+
+    # TODO (stao): re implement later
+    # ---------------------------------------------------------------------------- #
+    # Advanced
+    # ---------------------------------------------------------------------------- #
+
+    # def gen_scene_pcd(self, num_points: int = int(1e5)) -> np.ndarray:
+    #     """Generate scene point cloud for motion planning, excluding the robot"""
+    #     meshes = []
+    #     articulations = self.scene.get_all_articulations()
+    #     if self.agent is not None:
+    #         articulations.pop(articulations.index(self.agent.robot))
+    #     for articulation in articulations:
+    #         articulation_mesh = merge_meshes(get_articulation_meshes(articulation))
+    #         if articulation_mesh:
+    #             meshes.append(articulation_mesh)
+
+    #     for actor in self.scene.get_all_actors():
+    #         actor_mesh = merge_meshes(get_component_meshes(actor))
+    #         if actor_mesh:
+    #             meshes.append(
+    #                 actor_mesh.apply_transform(
+    #                     actor.get_pose().to_transformation_matrix()
+    #                 )
+    #             )
+
+    #     scene_mesh = merge_meshes(meshes)
+    #     scene_pcd = scene_mesh.sample(num_points)
+    #     return scene_pcd
+
+
+    # Printing metrics/info
+    def print_sim_details(self):
+        """Debug tool to call to simply print a bunch of details about the running environment, including the task ID, number of environments, sim backend, etc."""
+        sensor_settings_str = []
+        for uid, cam in self._sensors.items():
+            if isinstance(cam, Camera):
+                config = cam.config
+                sensor_settings_str.append(f"RGBD({config.width}x{config.height})")
+        sensor_settings_str = ", ".join(sensor_settings_str)
+        sim_backend = self.backend.sim_backend
+        print(
+        "# -------------------------------------------------------------------------- #"
+        )
+        print(
+            f"Task ID: {self.spec.id}, {self.num_envs} parallel environments, sim_backend={sim_backend}"
+        )
+        print(
+            f"obs_mode={self.obs_mode}, control_mode={self.control_mode}"
+        )
+        print(
+            f"render_mode={self.render_mode}, sensor_details={sensor_settings_str}"
+        )
+        print(
+            f"sim_freq={self.sim_freq}, control_freq={self.control_freq}"
+        )
+        print(f"observation space: {self.observation_space}")
+        print(f"(single) action space: {self.single_action_space}")
+        print(
+            "# -------------------------------------------------------------------------- #"
+        )

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/scene.py

@@ -0,0 +1,1163 @@
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import sapien
+import sapien.physx as physx
+import sapien.render
+import torch
+from sapien.render import RenderCameraComponent
+
+from mani_skill.envs.utils.system.backend import BackendInfo
+from mani_skill.render import SAPIEN_RENDER_SYSTEM
+from mani_skill.sensors.base_sensor import BaseSensor
+from mani_skill.sensors.camera import Camera
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.structs.actor import Actor
+from mani_skill.utils.structs.articulation import Articulation
+from mani_skill.utils.structs.drive import Drive
+from mani_skill.utils.structs.link import Link
+from mani_skill.utils.structs.pose import Pose
+from mani_skill.utils.structs.render_camera import RenderCamera
+from mani_skill.utils.structs.types import Array, Device, SimConfig
+
+# try and determine which render system is used by the installed sapien package
+if SAPIEN_RENDER_SYSTEM == "3.1":
+    from sapien.wrapper.scene import get_camera_shader_pack
+
+    GlobalShaderPack = None
+    sapien.render.RenderCameraGroup = "oldtype"  # type: ignore
+
+
+@dataclass
+class StateDictRegistry:
+    actors: Dict[str, Actor]
+    articulations: Dict[str, Articulation]
+
+
+class ManiSkillScene:
+    """
+    Class that manages a list of sub-scenes (sapien.Scene). In CPU simulation there should only be one sub-scene.
+    In GPU simulation, there can be many sub-scenes, and this wrapper ensures that use calls to many of the original sapien.Scene API
+    are applied to all sub-scenes. This includes calls to change object poses, velocities, drive targets etc.
+
+    This wrapper also helps manage GPU states if GPU simulation is used
+    """
+
+    def __init__(
+        self,
+        sub_scenes: Optional[List[sapien.Scene]] = None,
+        sim_config: SimConfig = SimConfig(),
+        debug_mode: bool = True,
+        device: Device = None,
+        parallel_in_single_scene: bool = False,
+        backend: BackendInfo = None,
+    ):
+        if sub_scenes is None:
+            sub_scenes = [sapien.Scene()]
+        self.sub_scenes = sub_scenes
+        self.px: Union[physx.PhysxCpuSystem, physx.PhysxGpuSystem] = self.sub_scenes[
+            0
+        ].physx_system
+        assert all(
+            isinstance(s.physx_system, type(self.px)) for s in self.sub_scenes
+        ), "all sub-scenes must use the same simulation backend"
+        self.gpu_sim_enabled = (
+            True if isinstance(self.px, physx.PhysxGpuSystem) else False
+        )
+        """whether the sub scenes are using the GPU or CPU backend"""
+        self.sim_config = sim_config
+        self._gpu_sim_initialized = False
+        self.debug_mode = debug_mode
+        self.device = device
+        self.backend = backend  # references the backend object stored in BaseEnv class
+
+        self.render_system_group: sapien.render.RenderSystemGroup = None
+        self.camera_groups: Dict[str, sapien.render.RenderCameraGroup] = dict()
+
+        self.actors: Dict[str, Actor] = dict()
+        self.articulations: Dict[str, Articulation] = dict()
+
+        self.actor_views: Dict[str, Actor] = dict()
+        """views of actors in any sub-scenes created by using Actor.merge and queryable as if it were a single Actor"""
+        self.articulation_views: Dict[str, Articulation] = dict()
+        """views of articulations in any sub-scenes created by using Articulation.merge and queryable as if it were a single Articulation"""
+
+        self.sensors: Dict[str, BaseSensor] = dict()
+        self.human_render_cameras: Dict[str, Camera] = dict()
+        self._sensors_initialized = False
+        self._human_render_cameras_initialized = False
+
+        self._reset_mask = torch.ones(len(sub_scenes), dtype=bool, device=self.device)
+        """Used internally by various objects like Actor, Link, and Controllers to auto mask out sub-scenes so they do not get modified during
+        partial env resets"""
+
+        self._needs_fetch = False
+        """Used internally to raise some errors ahead of time of when there may be undefined behaviors"""
+
+        self.pairwise_contact_queries: Dict[
+            str, physx.PhysxGpuContactPairImpulseQuery
+        ] = dict()
+        """dictionary mapping pairwise contact query keys to GPU contact queries. Used in GPU simulation only to cache queries as
+        query creation will pause any GPU sim computation"""
+        self._pairwise_contact_query_unique_hashes: Dict[str, int] = dict()
+        """maps keys in self.pairwise_contact_queries to unique hashes dependent on the actual objects involved in the query.
+        This is used to determine automatically when to rebuild contact queries as keys for self.pairwise_contact_queries are kept
+        non-unique between episode resets in order to be easily rebuilt and deallocate old queries. This essentially acts as a way
+        to invalidate the cached queries."""
+
+        self.parallel_in_single_scene: bool = parallel_in_single_scene
+        """Whether rendering all parallel scenes in the viewer/gui is enabled"""
+
+        self.state_dict_registry: StateDictRegistry = StateDictRegistry(
+            actors=dict(), articulations=dict()
+        )
+        """state dict registry that map actor/articulation names to Actor/Articulation struct references. Only these structs are used for the environment state"""
+
+    # -------------------------------------------------------------------------- #
+    # Functions from sapien.Scene
+    # -------------------------------------------------------------------------- #
+    @property
+    def timestep(self):
+        """The current simulation timestep"""
+        return self.px.timestep
+
+    @timestep.setter
+    def timestep(self, timestep):
+        self.px.timestep = timestep
+
+    def set_timestep(self, timestep):
+        """Sets the current simulation timestep"""
+        self.timestep = timestep
+
+    def get_timestep(self):
+        """Returns the current simulation timestep"""
+        return self.timestep
+
+    def create_actor_builder(self):
+        """Creates an ActorBuilder object that can be used to build actors in this scene"""
+        from ..utils.building.actor_builder import ActorBuilder
+
+        return ActorBuilder().set_scene(self)
+
+    def create_articulation_builder(self):
+        """Creates an ArticulationBuilder object that can be used to build articulations in this scene"""
+        from ..utils.building.articulation_builder import ArticulationBuilder
+
+        return ArticulationBuilder().set_scene(self)
+
+    def create_urdf_loader(self):
+        """Creates a URDFLoader object that can be used to load URDF files into this scene"""
+        from ..utils.building.urdf_loader import URDFLoader
+
+        loader = URDFLoader()
+        loader.set_scene(self)
+        return loader
+
+    def create_mjcf_loader(self):
+        """Creates a MJCFLoader object that can be used to load MJCF files into this scene"""
+        from ..utils.building.mjcf_loader import MJCFLoader
+
+        loader = MJCFLoader()
+        loader.set_scene(self)
+        return loader
+
+    # def create_physical_material(
+    #     self, static_friction: float, dynamic_friction: float, restitution: float
+    # ):
+    #     return physx.PhysxMaterial(static_friction, dynamic_friction, restitution)
+
+    def remove_actor(self, actor: Actor):
+        """Removes an actor from the scene. Only works in CPU simulation."""
+        if self.gpu_sim_enabled:
+            raise NotImplementedError(
+                "Cannot remove actors after creating them in GPU sim at the moment"
+            )
+        else:
+            self.sub_scenes[0].remove_entity(actor._objs[0].entity)
+            self.actors.pop(actor.name)
+
+    def remove_articulation(self, articulation: Articulation):
+        """Removes an articulation from the scene. Only works in CPU simulation."""
+        if self.gpu_sim_enabled:
+            raise NotImplementedError(
+                "Cannot remove articulations after creating them in GPU sim at the moment"
+            )
+        else:
+            entities = [l.entity for l in articulation._objs[0].links]
+            for e in entities:
+                self.sub_scenes[0].remove_entity(e)
+            self.articulations.pop(articulation.name)
+
+    def add_camera(
+        self,
+        name,
+        pose,
+        width,
+        height,
+        near,
+        far,
+        fovy: Union[float, List, None] = None,
+        intrinsic: Union[Array, None] = None,
+        mount: Union[Actor, Link, None] = None,
+    ) -> RenderCamera:
+        """Add's a (mounted) camera to the scene"""
+        if SAPIEN_RENDER_SYSTEM == "3.1":
+            return self._sapien_31_add_camera(
+                name, pose, width, height, near, far, fovy, intrinsic, mount
+            )
+        else:
+            return self._sapien_add_camera(
+                name, pose, width, height, near, far, fovy, intrinsic, mount
+            )
+
+    def _sapien_add_camera(
+        self,
+        name,
+        pose,
+        width,
+        height,
+        near,
+        far,
+        fovy: Union[float, List, None] = None,
+        intrinsic: Union[Array, None] = None,
+        mount: Union[Actor, Link, None] = None,
+    ) -> RenderCamera:
+        """internal helper function to add (mounted) cameras"""
+        cameras = []
+        pose = Pose.create(pose)
+        # TODO (stao): support scene idxs property for cameras in the future
+        # move intrinsic to np and batch intrinsic if it is not batched
+        if intrinsic is not None:
+            intrinsic = common.to_numpy(intrinsic)
+            if len(intrinsic.shape) == 2:
+                intrinsic = intrinsic[None, :]
+                if len(self.sub_scenes) > 1:
+                    # repeat the intrinsic along batch dim
+                    intrinsic = intrinsic.repeat(len(self.sub_scenes), 0)
+            assert len(intrinsic) == len(
+                self.sub_scenes
+            ), "intrinsic matrix batch dim not equal to the number of sub-scenes"
+        for i, scene in enumerate(self.sub_scenes):
+            # Create camera component
+            camera = RenderCameraComponent(width, height)
+            if fovy is not None:
+                if isinstance(fovy, float) or isinstance(fovy, int):
+                    camera.set_fovy(fovy, compute_x=True)
+                else:
+                    camera.set_fovy(fovy[i], compute_x=True)
+            elif intrinsic is not None:
+                camera.set_focal_lengths(intrinsic[i, 0, 0], intrinsic[i, 1, 1])
+                camera.set_principal_point(intrinsic[i, 0, 2], intrinsic[i, 1, 2])
+            if isinstance(near, float) or isinstance(near, int):
+                camera.near = near
+            else:
+                camera.near = near[i]
+            if isinstance(far, float) or isinstance(far, int):
+                camera.far = far
+            else:
+                camera.far = far[i]
+
+            # mount camera to actor/link
+            if mount is not None:
+                if self.gpu_sim_enabled:
+                    if isinstance(mount, Actor):
+                        camera.set_gpu_pose_batch_index(
+                            mount._objs[i]
+                            .find_component_by_type(physx.PhysxRigidBodyComponent)
+                            .gpu_pose_index
+                        )
+                    elif isinstance(mount, Link):
+                        camera.set_gpu_pose_batch_index(mount._objs[i].gpu_pose_index)
+                    else:
+                        raise ValueError(
+                            f"Tried to mount camera on object of type {mount.__class__}"
+                        )
+                if isinstance(mount, Link):
+                    mount._objs[i].entity.add_component(camera)
+                else:
+                    mount._objs[i].add_component(camera)
+            else:
+                camera_mount = sapien.Entity()
+                camera_mount.add_component(camera)
+                scene.add_entity(camera_mount)
+                camera_mount.name = f"scene-{i}_{name}"
+            if len(pose) == 1:
+                camera.local_pose = pose.sp
+            else:
+                camera.local_pose = pose[i].sp
+            camera.name = f"scene-{i}_{name}"
+            cameras.append(camera)
+        return RenderCamera.create(cameras, self, mount=mount)
+
+    def _sapien_31_add_camera(
+        self,
+        name,
+        pose,
+        width,
+        height,
+        near,
+        far,
+        fovy: Union[float, List, None] = None,
+        intrinsic: Union[Array, None] = None,
+        mount: Union[Actor, Link, None] = None,
+    ) -> RenderCamera:
+        """internal helper function to add (mounted) cameras"""
+        cameras = []
+        pose = Pose.create(pose)
+        # TODO (stao): support scene idxs property for cameras in the future
+        # move intrinsic to np and batch intrinsic if it is not batched
+        if intrinsic is not None:
+            intrinsic = common.to_numpy(intrinsic)
+            if len(intrinsic.shape) == 2:
+                intrinsic = intrinsic[None, :]
+                if len(self.sub_scenes) > 1:
+                    # repeat the intrinsic along batch dim
+                    intrinsic = intrinsic.repeat(len(self.sub_scenes), 0)
+            assert len(intrinsic) == len(
+                self.sub_scenes
+            ), "intrinsic matrix batch dim not equal to the number of sub-scenes"
+
+        for i, scene in enumerate(self.sub_scenes):
+            # Create camera component
+            camera = RenderCameraComponent(
+                width, height, GlobalShaderPack or get_camera_shader_pack()
+            )
+            if fovy is not None:
+                if isinstance(fovy, (float, int)):
+                    camera.set_fovy(fovy, compute_x=True)
+                else:
+                    camera.set_fovy(fovy[i], compute_x=True)
+            elif intrinsic is not None:
+                camera.set_focal_lengths(intrinsic[i, 0, 0], intrinsic[i, 1, 1])
+                camera.set_principal_point(intrinsic[i, 0, 2], intrinsic[i, 1, 2])
+            if isinstance(near, (float, int)):
+                camera.near = near
+            else:
+                camera.near = near[i]
+            if isinstance(far, (float, int)):
+                camera.far = far
+            else:
+                camera.far = far[i]
+
+            # mount camera to actor/link
+            if mount is not None:
+                if isinstance(mount, Link):
+                    mount._objs[i].entity.add_component(camera)
+                else:
+                    mount._objs[i].add_component(camera)
+            else:
+                camera_mount = sapien.Entity()
+                camera_mount.set_pose(sapien.Pose([0, 0, 0]))
+                camera_mount.add_component(camera)
+                camera_mount.name = f"scene-{i}_{name}"
+                scene.add_entity(camera_mount)
+            if len(pose) == 1:
+                camera.local_pose = pose.sp
+            else:
+                camera.local_pose = pose[i].sp
+            camera.name = f"scene-{i}_{name}"
+            cameras.append(camera)
+            scene.update_render()
+        return RenderCamera.create(cameras, self, mount=mount)
+
+    # def remove_camera(self, camera):
+    #     self.remove_entity(camera.entity)
+
+    # def get_cameras(self):
+    #     return self.render_system.cameras
+
+    # def get_mounted_cameras(self):
+    #     return self.get_cameras()
+
+    def step(self):
+        self.px.step()
+
+    def update_render(
+        self, update_sensors: bool = True, update_human_render_cameras: bool = True
+    ):
+        """
+        Updates the renderer based on the current simulation state. Note that on the first call if a sensor/human render camera is required to be updated,
+        GPU memory will be allocated for the sensor/human render camera respectively.
+
+        Arguments:
+            update_sensors (bool): Whether to update the sensors.
+            update_human_render_cameras (bool): Whether to update the human render cameras.
+        """
+        if SAPIEN_RENDER_SYSTEM == "3.1":
+            self._sapien_31_update_render(
+                update_sensors=update_sensors,
+                update_human_render_cameras=update_human_render_cameras,
+            )
+        else:
+            self._sapien_update_render(
+                update_sensors=update_sensors,
+                update_human_render_cameras=update_human_render_cameras,
+            )
+
+    def _sapien_update_render(
+        self, update_sensors: bool = True, update_human_render_cameras: bool = True
+    ):
+        # note that this design is such that no GPU memory is allocated for memory unless requested for, which can occur
+        # after the e.g. physx GPU simulation is initialized.
+        if self.gpu_sim_enabled:
+            if not self.parallel_in_single_scene:
+                if self.render_system_group is None:
+                    self._setup_gpu_rendering()
+                if not self._sensors_initialized and update_sensors:
+                    self._gpu_setup_sensors(self.sensors)
+                    self._sensors_initialized = True
+                if (
+                    not self._human_render_cameras_initialized
+                    and update_human_render_cameras
+                ):
+                    self._gpu_setup_sensors(self.human_render_cameras)
+                    self._human_render_cameras_initialized = True
+                self.render_system_group.update_render()
+            else:
+                self.px.sync_poses_gpu_to_cpu()
+                self.sub_scenes[0].update_render()
+        else:
+            self.sub_scenes[0].update_render()
+
+    def _sapien_31_update_render(
+        self, update_sensors: bool = True, update_human_render_cameras: bool = True
+    ):
+        if self.gpu_sim_enabled:
+            if self.render_system_group is None:
+                # TODO (stao): for new render system support the parallel in single scene rendering option
+                for scene in self.sub_scenes:
+                    scene.update_render()
+                self._setup_gpu_rendering()
+            if not self._sensors_initialized and update_sensors:
+                self._gpu_setup_sensors(self.sensors)
+                self._sensors_initialized = True
+            if (
+                not self._human_render_cameras_initialized
+                and update_human_render_cameras
+            ):
+                self._gpu_setup_sensors(self.human_render_cameras)
+                self._human_render_cameras_initialized = True
+
+            manager: sapien.render.GpuSyncManager = self.render_system_group
+            manager.sync()
+        else:
+            self.sub_scenes[0].update_render()
+
+    def get_contacts(self):
+        # TODO (stao): deprecate this API
+        return self.px.get_contacts()
+
+    def get_all_actors(self):
+        """
+        Returns list of all sapien.Entity objects that have rigid dynamic and static components across all sub scenes
+        """
+        return [
+            c.entity
+            for c in self.px.rigid_dynamic_components + self.px.rigid_static_components
+        ]
+
+    def get_all_articulations(self):
+        """
+        Returns list of all physx articulation objects across all sub scenes
+        """
+        return [
+            c.articulation for c in self.px.articulation_link_components if c.is_root
+        ]
+
+    def create_drive(
+        self,
+        body0: Union[Actor, Link],
+        pose0: Union[sapien.Pose, Pose],
+        body1: Union[Actor, Link],
+        pose1: Union[sapien.Pose, Pose],
+    ):
+        # body0 and body1 should be in parallel.
+        return Drive.create_from_actors_or_links(
+            self, body0, pose0, body1, pose1, body0._scene_idxs
+        )
+
+    # def create_connection(
+    #     self,
+    #     body0: Optional[Union[sapien.Entity, physx.PhysxRigidBaseComponent]],
+    #     pose0: sapien.Pose,
+    #     body1: Union[sapien.Entity, physx.PhysxRigidBaseComponent],
+    #     pose1: sapien.Pose,
+    # ):
+    #     if body0 is None:
+    #         c0 = None
+    #     elif isinstance(body0, sapien.Entity):
+    #         c0 = next(
+    #             c
+    #             for c in body0.components
+    #             if isinstance(c, physx.PhysxRigidBaseComponent)
+    #         )
+    #     else:
+    #         c0 = body0
+
+    #     assert body1 is not None
+    #     if isinstance(body1, sapien.Entity):
+    #         e1 = body1
+    #         c1 = next(
+    #             c
+    #             for c in body1.components
+    #             if isinstance(c, physx.PhysxRigidBaseComponent)
+    #         )
+    #     else:
+    #         e1 = body1.entity
+    #         c1 = body1
+
+    #     connection = physx.PhysxDistanceJointComponent(c1)
+    #     connection.parent = c0
+    #     connection.pose_in_child = pose1
+    #     connection.pose_in_parent = pose0
+    #     e1.add_component(connection)
+    #     connection.set_limit(0, 0)
+    #     return connection
+
+    # def create_gear(
+    #     self,
+    #     body0: Optional[Union[sapien.Entity, physx.PhysxRigidBaseComponent]],
+    #     pose0: sapien.Pose,
+    #     body1: Union[sapien.Entity, physx.PhysxRigidBaseComponent],
+    #     pose1: sapien.Pose,
+    # ):
+    #     if body0 is None:
+    #         c0 = None
+    #     elif isinstance(body0, sapien.Entity):
+    #         c0 = next(
+    #             c
+    #             for c in body0.components
+    #             if isinstance(c, physx.PhysxRigidBaseComponent)
+    #         )
+    #     else:
+    #         c0 = body0
+
+    #     assert body1 is not None
+    #     if isinstance(body1, sapien.Entity):
+    #         e1 = body1
+    #         c1 = next(
+    #             c
+    #             for c in body1.components
+    #             if isinstance(c, physx.PhysxRigidBaseComponent)
+    #         )
+    #     else:
+    #         e1 = body1.entity
+    #         c1 = body1
+
+    #     gear = physx.PhysxGearComponent(c1)
+    #     gear.parent = c0
+    #     gear.pose_in_child = pose1
+    #     gear.pose_in_parent = pose0
+    #     e1.add_component(gear)
+    #     return gear
+
+    # @property
+    # def render_id_to_visual_name(self):
+    #     # TODO
+    #     return
+
+    @property
+    def ambient_light(self):
+        return self.sub_scenes[0].ambient_light
+
+    @ambient_light.setter
+    def ambient_light(self, color):
+        for scene in self.sub_scenes:
+            scene.render_system.ambient_light = color
+
+    def set_ambient_light(self, color):
+        self.ambient_light = color
+
+    def add_point_light(
+        self,
+        position,
+        color,
+        shadow=False,
+        shadow_near=0.1,
+        shadow_far=10.0,
+        shadow_map_size=2048,
+        scene_idxs: Optional[List[int]] = None,
+    ):
+        if scene_idxs is None:
+            scene_idxs = list(range(len(self.sub_scenes)))
+        for scene_idx in scene_idxs:
+            if self.parallel_in_single_scene:
+                scene = self.sub_scenes[0]
+            else:
+                scene = self.sub_scenes[scene_idx]
+            entity = sapien.Entity()
+            entity.name = "point_light"
+            light = sapien.render.RenderPointLightComponent()
+            entity.add_component(light)
+            light.color = color
+            light.shadow = shadow
+            light.shadow_near = shadow_near
+            light.shadow_far = shadow_far
+            light.shadow_map_size = shadow_map_size
+            if self.parallel_in_single_scene:
+                light.pose = sapien.Pose(position + self.scene_offsets_np[scene_idx])
+            else:
+                light.pose = sapien.Pose(position)
+
+            scene.add_entity(entity)
+        return light
+
+    def add_directional_light(
+        self,
+        direction,
+        color,
+        shadow=False,
+        position=[0, 0, 0],
+        shadow_scale=10.0,
+        shadow_near=-10.0,
+        shadow_far=10.0,
+        shadow_map_size=2048,
+        scene_idxs: Optional[List[int]] = None,
+    ):
+        if scene_idxs is None:
+            scene_idxs = list(range(len(self.sub_scenes)))
+        for scene_idx in scene_idxs:
+            if self.parallel_in_single_scene:
+                scene = self.sub_scenes[0]
+            else:
+                scene = self.sub_scenes[scene_idx]
+            entity = sapien.Entity()
+            entity.name = "directional_light"
+            light = sapien.render.RenderDirectionalLightComponent()
+            entity.add_component(light)
+            light.color = color
+            light.shadow = shadow
+            light.shadow_near = shadow_near
+            light.shadow_far = shadow_far
+            light.shadow_half_size = shadow_scale
+            light.shadow_map_size = shadow_map_size
+            if self.parallel_in_single_scene:
+                light_position = position + self.scene_offsets_np[scene_idx]
+            else:
+                light_position = position
+            light.pose = sapien.Pose(
+                light_position, sapien.math.shortest_rotation([1, 0, 0], direction)
+            )
+            scene.add_entity(entity)
+            if self.parallel_in_single_scene:
+                # for directional lights adding multiple does not make much sense
+                # and for parallel gui rendering setup accurate lighting does not matter as it is only
+                # for demo purposes
+                break
+        return
+
+    def add_spot_light(
+        self,
+        position,
+        direction,
+        inner_fov: float,
+        outer_fov: float,
+        color,
+        shadow=False,
+        shadow_near=0.1,
+        shadow_far=10.0,
+        shadow_map_size=2048,
+        scene_idxs: Optional[List[int]] = None,
+    ):
+        if scene_idxs is None:
+            scene_idxs = list(range(len(self.sub_scenes)))
+        for scene_idx in scene_idxs:
+            if self.parallel_in_single_scene:
+                scene = self.sub_scenes[0]
+            else:
+                scene = self.sub_scenes[scene_idx]
+            entity = sapien.Entity()
+            entity.name = "spot_light"
+            light = sapien.render.RenderSpotLightComponent()
+            entity.add_component(light)
+            light.color = color
+            light.shadow = shadow
+            light.shadow_near = shadow_near
+            light.shadow_far = shadow_far
+            light.shadow_map_size = shadow_map_size
+            light.inner_fov = inner_fov
+            light.outer_fov = outer_fov
+            if self.parallel_in_single_scene:
+                light_position = position + self.scene_offsets_np[scene_idx]
+            else:
+                light_position = position
+            light.pose = sapien.Pose(
+                light_position, sapien.math.shortest_rotation([1, 0, 0], direction)
+            )
+            scene.add_entity(entity)
+        return
+
+    def add_area_light_for_ray_tracing(
+        self,
+        pose: sapien.Pose,
+        color,
+        half_width: float,
+        half_height: float,
+        scene_idxs=None,
+    ):
+        lighting_scenes = (
+            self.sub_scenes
+            if scene_idxs is None
+            else [self.sub_scenes[i] for i in scene_idxs]
+        )
+        for scene in lighting_scenes:
+            entity = sapien.Entity()
+            light = sapien.render.RenderParallelogramLightComponent()
+            entity.add_component(light)
+            light.set_shape(half_width, half_height)
+            light.color = color
+            light.pose = pose
+            scene.add_entity(entity)
+        return
+
+    # def remove_light(self, light):
+    #     self.remove_entity(light.entity)
+
+    # def set_environment_map(self, cubemap: str):
+    #     if isinstance(cubemap, str):
+    #         self.render_system.cubemap = sapien.render.RenderCubemap(cubemap)
+    #     else:
+    #         self.render_system.cubemap = cubemap
+
+    # def set_environment_map_from_files(
+    #     self, px: str, nx: str, py: str, ny: str, pz: str, nz: str
+    # ):
+    #     self.render_system.cubemap = sapien.render.RenderCubemap(px, nx, py, ny, pz, nz)
+
+    # ---------------------------------------------------------------------------- #
+    # Additional useful properties / functions
+    # ---------------------------------------------------------------------------- #
+    @property
+    def num_envs(self):
+        return len(self.sub_scenes)
+
+    def get_pairwise_contact_impulses(
+        self, obj1: Union[Actor, Link], obj2: Union[Actor, Link]
+    ):
+        """
+        Get the impulse vectors between two actors/links. Returns impulse vector of shape (N, 3)
+        where N is the number of environments and 3 is the dimension of the impulse vector itself,
+        representing x, y, and z direction of impulse.
+
+        Note that dividing the impulse value by self.px.timestep yields the pairwise contact force in Newtons. The equivalent API for that
+        is self.get_pairwise_contact_force(obj1, obj2). It is generally recommended to use the force values since they are independent of the
+        timestep (dt = 1 / sim_freq) of the simulation.
+
+        Args:
+            obj1: Actor | Link
+            obj2: Actor | Link
+        """
+        # TODO (stao): Is there any optimization improvement when putting all queries all together and fetched together
+        # vs multiple smaller queries? If so, might be worth exposing a helpful API for that instead of having user
+        # write this code below themselves.
+        if self.gpu_sim_enabled:
+            query_hash = hash((obj1, obj2))
+            query_key = obj1.name + obj2.name
+
+            # we rebuild the potentially expensive contact query if it has not existed previously
+            # or if it has, the managed objects are a different set
+            rebuild_query = (query_key not in self.pairwise_contact_queries) or (
+                query_key in self._pairwise_contact_query_unique_hashes
+                and self._pairwise_contact_query_unique_hashes[query_key] != query_hash
+            )
+            if rebuild_query:
+                body_pairs = list(zip(obj1._bodies, obj2._bodies))
+                self.pairwise_contact_queries[
+                    query_key
+                ] = self.px.gpu_create_contact_pair_impulse_query(body_pairs)
+                self._pairwise_contact_query_unique_hashes[query_key] = query_hash
+
+            query = self.pairwise_contact_queries[query_key]
+            self.px.gpu_query_contact_pair_impulses(query)
+            # query.cuda_impulses is shape (num_unique_pairs * num_envs, 3)
+            pairwise_contact_impulses = query.cuda_impulses.torch().clone()
+            return pairwise_contact_impulses
+        else:
+            contacts = self.px.get_contacts()
+            pairwise_contact_impulses = sapien_utils.get_pairwise_contact_impulse(
+                contacts, obj1._bodies[0].entity, obj2._bodies[0].entity
+            )
+            return common.to_tensor(pairwise_contact_impulses)[None, :]
+
+    def get_pairwise_contact_forces(
+        self, obj1: Union[Actor, Link], obj2: Union[Actor, Link]
+    ):
+        """
+        Get the force vectors between two actors/links. Returns force vector of shape (N, 3)
+        where N is the number of environments and 3 is the dimension of the force vector itself,
+        representing x, y, and z direction of force.
+
+        Args:
+            obj1: Actor | Link
+            obj2: Actor | Link
+        """
+        return self.get_pairwise_contact_impulses(obj1, obj2) / self.px.timestep
+
+    @cached_property
+    def scene_offsets(self):
+        """torch tensor of shape (num_envs, 3) representing the offset of each scene in the world frame"""
+        return torch.tensor(
+            np.array(
+                [self.px.get_scene_offset(sub_scene) for sub_scene in self.sub_scenes]
+            ),
+            device=self.device,
+        )
+
+    @cached_property
+    def scene_offsets_np(self):
+        """numpy array of shape (num_envs, 3) representing the offset of each scene in the world frame"""
+        return np.array(
+            [self.px.get_scene_offset(sub_scene) for sub_scene in self.sub_scenes]
+        )
+
+    # -------------------------------------------------------------------------- #
+    # Simulation state (required for MPC)
+    # -------------------------------------------------------------------------- #
+
+    def add_to_state_dict_registry(self, object: Union[Actor, Articulation]):
+        if isinstance(object, Actor):
+            assert (
+                object.name not in self.state_dict_registry.actors
+            ), f"Object {object.name} already in state dict registry"
+            self.state_dict_registry.actors[object.name] = object
+        elif isinstance(object, Articulation):
+            assert (
+                object.name not in self.state_dict_registry.articulations
+            ), f"Object {object.name} already in state dict registry"
+            self.state_dict_registry.articulations[object.name] = object
+        else:
+            raise ValueError(f"Expected Actor or Articulation, got {object}")
+
+    def remove_from_state_dict_registry(self, object: Union[Actor, Articulation]):
+        if isinstance(object, Actor):
+            assert (
+                object.name in self.state_dict_registry.actors
+            ), f"Object {object.name} not in state dict registry"
+            del self.state_dict_registry.actors[object.name]
+        elif isinstance(object, Articulation):
+            assert (
+                object.name in self.state_dict_registry.articulations
+            ), f"Object {object.name} not in state dict registry"
+            del self.state_dict_registry.articulations[object.name]
+        else:
+            raise ValueError(f"Expected Actor or Articulation, got {object}")
+
+    def get_sim_state(self) -> torch.Tensor:
+        """Get simulation state. Returns a dictionary with two nested dictionaries "actors" and "articulations".
+        In the nested dictionaries they map the actor/articulation name to a vector of shape (N, D) for N parallel
+        environments and D dimensions of padded state per environment.
+
+        Note that static actor data are not included. It is expected that an environment reconstructs itself in a deterministic manner such that
+        the same static actors always have the same states"""
+        state_dict = dict()
+        state_dict["actors"] = dict()
+        state_dict["articulations"] = dict()
+        for actor in self.state_dict_registry.actors.values():
+            if actor.px_body_type == "static":
+                continue
+            state_dict["actors"][actor.name] = actor.get_state().clone()
+        for articulation in self.state_dict_registry.articulations.values():
+            state_dict["articulations"][
+                articulation.name
+            ] = articulation.get_state().clone()
+        if len(state_dict["actors"]) == 0:
+            del state_dict["actors"]
+        if len(state_dict["articulations"]) == 0:
+            del state_dict["articulations"]
+        return state_dict
+
+    def set_sim_state(self, state: Dict, env_idx: torch.Tensor = None):
+        if env_idx is not None:
+            prev_reset_mask = self._reset_mask.clone()
+            # safe guard against setting the wrong states
+            self._reset_mask[:] = False
+            self._reset_mask[env_idx] = True
+
+        if "actors" in state:
+            for actor_id, actor_state in state["actors"].items():
+                if len(actor_state.shape) == 1:
+                    actor_state = actor_state[None, :]
+                # do not pass in env_idx to avoid redundant reset mask changes
+                self.state_dict_registry.actors[actor_id].set_state(actor_state, None)
+        if "articulations" in state:
+            for art_id, art_state in state["articulations"].items():
+                if len(art_state.shape) == 1:
+                    art_state = art_state[None, :]
+                self.state_dict_registry.articulations[art_id].set_state(
+                    art_state, None
+                )
+        if env_idx is not None:
+            self._reset_mask = prev_reset_mask
+
+    # ---------------------------------------------------------------------------- #
+    # GPU Simulation Management
+    # ---------------------------------------------------------------------------- #
+    def _setup(self, enable_gpu: bool):
+        """
+        Start the CPU/GPU simulation and allocate all buffers and initialize objects
+        """
+        if enable_gpu:
+            if SAPIEN_RENDER_SYSTEM == "3.1":
+                for scene in self.sub_scenes:
+                    scene.update_render()
+            self.px.gpu_init()
+        self.non_static_actors: List[Actor] = []
+        # find non static actors, and set data indices that are now available after gpu_init was called
+        for actor in self.actors.values():
+            if actor.px_body_type == "static":
+                continue
+            self.non_static_actors.append(actor)
+            if enable_gpu:
+                actor._body_data_index  # only need to access this attribute to populate it
+
+        for articulation in self.articulations.values():
+            articulation._data_index
+            for link in articulation.links:
+                link._body_data_index
+        for actor in self.non_static_actors:
+            actor.set_pose(actor.initial_pose)
+        for articulation in self.articulations.values():
+            articulation.set_pose(articulation.initial_pose)
+
+        if enable_gpu:
+            self.px.cuda_rigid_body_data.torch()[:, 7:] = torch.zeros_like(
+                self.px.cuda_rigid_body_data.torch()[:, 7:]
+            )  # zero out all velocities
+            self.px.cuda_articulation_qvel.torch()[:, :] = torch.zeros_like(
+                self.px.cuda_articulation_qvel.torch()
+            )  # zero out all q velocities
+
+            self.px.gpu_apply_rigid_dynamic_data()
+            self.px.gpu_apply_articulation_root_pose()
+            self.px.gpu_apply_articulation_root_velocity()
+            self.px.gpu_apply_articulation_qvel()
+
+            self._gpu_sim_initialized = True
+            self.px.gpu_update_articulation_kinematics()
+            self._gpu_fetch_all()
+
+    def _gpu_apply_all(self):
+        """
+        Calls gpu_apply to update all body data, qpos, qvel, qf, and root poses
+        """
+        assert (
+            not self._needs_fetch
+        ), "Once _gpu_apply_all is called, you must call _gpu_fetch_all before calling _gpu_apply_all again\
+            as otherwise there is undefined behavior that is likely impossible to debug"
+        self.px.gpu_apply_rigid_dynamic_data()
+        self.px.gpu_apply_articulation_qpos()
+        self.px.gpu_apply_articulation_qvel()
+        self.px.gpu_apply_articulation_qf()
+        self.px.gpu_apply_articulation_root_pose()
+        self.px.gpu_apply_articulation_root_velocity()
+        self.px.gpu_apply_articulation_target_position()
+        self.px.gpu_apply_articulation_target_velocity()
+        self._needs_fetch = True
+
+    def _gpu_fetch_all(self):
+        """
+        Queries simulation for all relevant GPU data. Note that this has some overhead.
+        Should only be called at most once per simulation step as this automatically queries all data for all
+        objects built in the scene.
+        """
+        if len(self.non_static_actors) > 0:
+            self.px.gpu_fetch_rigid_dynamic_data()
+
+        if len(self.articulations) > 0:
+            self.px.gpu_fetch_articulation_link_pose()
+            self.px.gpu_fetch_articulation_link_velocity()
+            self.px.gpu_fetch_articulation_qpos()
+            self.px.gpu_fetch_articulation_qvel()
+            self.px.gpu_fetch_articulation_qacc()
+            self.px.gpu_fetch_articulation_target_qpos()
+            self.px.gpu_fetch_articulation_target_qvel()
+
+        self._needs_fetch = False
+
+    # ---------------------------------------------------------------------------- #
+    # CPU/GPU sim Rendering Code
+    # ---------------------------------------------------------------------------- #
+    def _get_all_render_bodies(
+        self,
+    ) -> List[Tuple[sapien.render.RenderBodyComponent, int]]:
+        all_render_bodies = []
+        for actor in self.actors.values():
+            if actor.px_body_type == "static":
+                continue
+            all_render_bodies += [
+                (
+                    entity.find_component_by_type(sapien.render.RenderBodyComponent),
+                    entity.find_component_by_type(
+                        physx.PhysxRigidDynamicComponent
+                    ).gpu_pose_index,
+                )
+                for entity in actor._objs
+            ]
+        for articulation in self.articulations.values():
+            all_render_bodies += [
+                (
+                    px_link.entity.find_component_by_type(
+                        sapien.render.RenderBodyComponent
+                    ),
+                    px_link.gpu_pose_index,
+                )
+                for link in articulation.links
+                for px_link in link._objs
+            ]
+        return all_render_bodies
+
+    def _setup_gpu_rendering(self):
+        if SAPIEN_RENDER_SYSTEM == "3.1":
+            self._sapien_31_setup_gpu_rendering()
+        else:
+            self._sapien_setup_gpu_rendering()
+
+    def _sapien_setup_gpu_rendering(self):
+        """
+        Prepares the scene for GPU parallelized rendering to enable taking e.g. RGB images
+        """
+        for rb, gpu_pose_index in self._get_all_render_bodies():
+            if rb is not None:
+                for s in rb.render_shapes:
+                    s.set_gpu_pose_batch_index(gpu_pose_index)
+        self.render_system_group = sapien.render.RenderSystemGroup(
+            [s.render_system for s in self.sub_scenes]
+        )
+        self.render_system_group.set_cuda_poses(self.px.cuda_rigid_body_data)
+
+    def _sapien_31_setup_gpu_rendering(self):
+        """
+        Prepares the scene for GPU parallelized rendering to enable taking e.g. RGB images
+        """
+
+        px: physx.PhysxGpuSystem = self.px
+
+        shape_pose_indices = []
+        shapes = []
+        scene_id = 0
+        for scene in self.sub_scenes:
+            scene_id += 1
+            for body in scene.render_system.render_bodies:
+                b = body.entity.find_component_by_type(
+                    sapien.physx.PhysxRigidBodyComponent
+                )
+                if b is None:
+                    continue
+                for s in body.render_shapes:
+                    shape_pose_indices.append(b.gpu_pose_index)
+                    shapes.append(s)
+
+        cam_pose_indices = []
+        cams = []
+        for cameras in self.sensors.values():
+            assert isinstance(cameras, Camera), f"Expected Camera, got {cameras}"
+            for c in cameras.camera._render_cameras:
+                b = c.entity.find_component_by_type(
+                    sapien.physx.PhysxRigidBodyComponent
+                )
+                if b is None:
+                    continue
+                cam_pose_indices.append(b.gpu_pose_index)
+                cams.append(c)
+
+        sync_manager = sapien.render.GpuSyncManager()
+        sync_manager.set_cuda_poses(px.cuda_rigid_body_data)
+        sync_manager.set_render_shapes(shape_pose_indices, shapes)
+        sync_manager.set_cameras(cam_pose_indices, cams)
+
+        self.render_system_group = sync_manager
+
+    def _gpu_setup_sensors(self, sensors: Dict[str, BaseSensor]):
+        if SAPIEN_RENDER_SYSTEM == "3.1":
+            self._sapien_31_gpu_setup_sensors(sensors)
+        else:
+            self._sapien_gpu_setup_sensors(sensors)
+
+    def _sapien_gpu_setup_sensors(self, sensors: Dict[str, BaseSensor]):
+        for name, sensor in sensors.items():
+            if isinstance(sensor, Camera):
+                try:
+                    camera_group = self.render_system_group.create_camera_group(
+                        sensor.camera._render_cameras,
+                        list(sensor.config.shader_config.texture_names.keys()),
+                    )
+                except RuntimeError as e:
+                    raise RuntimeError(
+                        "Unable to create GPU parallelized camera group. "
+                        "If the error is about being unable to create a buffer, you are likely using too many Cameras. "
+                        "Either use less cameras (via less parallel envs) and/or reduce the size of the cameras. "
+                        "Another common cause is using a memory intensive shader, you can try using the 'minimal' shader "
+                        "which optimizes for GPU memory but disables some advanced functionalities. "
+                        "Another option is to avoid rendering with the rgb_array mode / using the human render cameras as "
+                        "they can be more memory intensive as they typically have higher resolutions for the purposes of visualization."
+                    ) from e
+                sensor.camera.camera_group = camera_group
+                self.camera_groups[name] = camera_group
+            else:
+                raise NotImplementedError(
+                    f"This sensor {sensor} of type {sensor.__class__} has not been implemented yet on the GPU"
+                )
+
+    def _sapien_31_gpu_setup_sensors(self, sensors: dict[str, BaseSensor]):
+        for name, sensor in sensors.items():
+            if isinstance(sensor, Camera):
+                batch_renderer = sapien.render.RenderManager(
+                    sapien.render.get_shader_pack(
+                        sensor.config.shader_config.shader_pack
+                    )
+                )
+                batch_renderer.set_size(sensor.config.width, sensor.config.height)
+                batch_renderer.set_cameras(sensor.camera._render_cameras)
+                sensor.camera.camera_group = self.camera_groups[name] = batch_renderer
+            else:
+                raise NotImplementedError(
+                    f"This sensor {sensor} of type {sensor.__class__} has not bget_picture_cuda implemented yet on the GPU"
+                )
+
+    def get_sensor_images(
+        self, obs: Dict[str, Any]
+    ) -> Dict[str, Dict[str, torch.Tensor]]:
+        """Get raw sensor data as images for visualization purposes."""
+        sensor_data = dict()
+        for name, sensor in self.sensors.items():
+            sensor_data[name] = sensor.get_images(obs[name])
+        return sensor_data
+
+    def get_human_render_camera_images(
+        self, camera_name: str = None
+    ) -> Dict[str, torch.Tensor]:
+        image_data = dict()
+        if self.gpu_sim_enabled:
+            if self.parallel_in_single_scene:
+                for name, camera in self.human_render_cameras.items():
+                    camera.camera._render_cameras[0].take_picture()
+                    rgb = camera.get_obs(
+                        rgb=True, depth=False, segmentation=False, position=False
+                    )["rgb"]
+                    image_data[name] = rgb
+            else:
+                for name, camera in self.human_render_cameras.items():
+                    if camera_name is not None and name != camera_name:
+                        continue
+                    assert camera.config.shader_config.shader_pack not in [
+                        "rt",
+                        "rt-fast",
+                        "rt-med",
+                    ], "ray tracing shaders do not work with parallel rendering"
+                    camera.capture()
+                    rgb = camera.get_obs(
+                        rgb=True, depth=False, segmentation=False, position=False
+                    )["rgb"]
+                    image_data[name] = rgb
+        else:
+            for name, camera in self.human_render_cameras.items():
+                if camera_name is not None and name != camera_name:
+                    continue
+                camera.capture()
+                rgb = camera.get_obs(
+                    rgb=True, depth=False, segmentation=False, position=False
+                )["rgb"]
+                image_data[name] = rgb
+        return image_data

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/__init__.py

@@ -0,0 +1,11 @@
+from .control import *
+from .dexterity import *
+from .digital_twins import *
+from .drawing import *
+from .empty_env import EmptyEnv
+from .fmb import *
+from .humanoid import *
+from .mobile_manipulation import *
+from .quadruped import *
+from .rotate_cube import RotateCubeEnv
+from .tabletop import *

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/__init__.py

@@ -0,0 +1,3 @@
+# isort: off
+from .rotate_valve import RotateValveEnv
+from .rotate_single_object_in_hand import RotateSingleObjectInHand

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_single_object_in_hand.py

@@ -0,0 +1,373 @@
+from typing import Any, Dict, List, Union
+
+import numpy as np
+import sapien
+import torch
+import torch.nn.functional as F
+
+from mani_skill import ASSET_DIR
+from mani_skill.agents.robots import AllegroHandRightTouch
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import actors
+from mani_skill.utils.building.actors import build_cube
+from mani_skill.utils.geometry.rotation_conversions import quaternion_apply
+from mani_skill.utils.io_utils import load_json
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.scene_builder.table import TableSceneBuilder
+from mani_skill.utils.structs.actor import Actor
+from mani_skill.utils.structs.pose import Pose, vectorize_pose
+from mani_skill.utils.structs.types import Array, GPUMemoryConfig, SimConfig
+
+
+class RotateSingleObjectInHand(BaseEnv):
+    agent: Union[AllegroHandRightTouch]
+    _clearance = 0.003
+    hand_init_height = 0.25
+
+    def __init__(
+        self,
+        *args,
+        robot_init_qpos_noise=0.02,
+        obj_init_pos_noise=0.02,
+        difficulty_level: int = -1,
+        num_envs=1,
+        reconfiguration_freq=None,
+        **kwargs,
+    ):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        self.obj_init_pos_noise = obj_init_pos_noise
+        self.obj_heights: torch.Tensor = torch.Tensor()
+        if (
+            not isinstance(difficulty_level, int)
+            or difficulty_level >= 4
+            or difficulty_level < 0
+        ):
+            raise ValueError(
+                f"Difficulty level must be a int within 0-3, but get {difficulty_level}"
+            )
+        self.difficulty_level = difficulty_level
+        if self.difficulty_level >= 2:
+            if reconfiguration_freq is None:
+                if num_envs == 1:
+                    reconfiguration_freq = 1
+                else:
+                    reconfiguration_freq = 0
+        super().__init__(
+            *args,
+            robot_uids="allegro_hand_right_touch",
+            num_envs=num_envs,
+            reconfiguration_freq=reconfiguration_freq,
+            **kwargs,
+        )
+
+        with torch.device(self.device):
+            self.prev_unit_vector = torch.zeros((self.num_envs, 3))
+            self.cum_rotation_angle = torch.zeros((self.num_envs,))
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            gpu_memory_config=GPUMemoryConfig(
+                max_rigid_contact_count=self.num_envs * max(1024, self.num_envs) * 8,
+                max_rigid_patch_count=self.num_envs * max(1024, self.num_envs) * 2,
+                found_lost_pairs_capacity=2**26,
+            )
+        )
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at(
+            eye=[0.15, 0, 0.45], target=[-0.1, 0, self.hand_init_height]
+        )
+        return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([0.2, 0.4, 0.6], [0.0, 0.0, 0.3])
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _load_scene(self, options: dict):
+        self.table_scene = TableSceneBuilder(
+            env=self, robot_init_qpos_noise=self.robot_init_qpos_noise
+        )
+        self.table_scene.build()
+
+        obj_heights = []
+        if self.difficulty_level == 0:
+            self.obj = build_cube(
+                self.scene,
+                half_size=0.04,
+                color=np.array([255, 255, 255, 255]) / 255,
+                name="cube",
+                body_type="dynamic",
+            )
+            obj_heights.append(0.03)
+        elif self.difficulty_level == 1:
+            half_sizes = (self._batched_episode_rng.randn() * 0.1 + 1) * 0.04
+            self._objs: List[Actor] = []
+            for i, half_size in enumerate(half_sizes):
+                builder = self.scene.create_actor_builder()
+                builder.add_box_collision(
+                    half_size=[half_size] * 3,
+                )
+                builder.add_box_visual(
+                    half_size=[half_size] * 3,
+                    material=sapien.render.RenderMaterial(
+                        base_color=np.array([255, 255, 255, 255]) / 255,
+                    ),
+                )
+                builder.set_scene_idxs([i])
+                self._objs.append(builder.build(name=f"cube-{i}"))
+                obj_heights.append(half_size)
+            self.obj = Actor.merge(self._objs, name="cube")
+        elif self.difficulty_level >= 2:
+            all_model_ids = np.array(
+                list(
+                    load_json(
+                        ASSET_DIR / "assets/mani_skill2_ycb/info_pick_v0.json"
+                    ).keys()
+                )
+            )
+            model_ids = self._batched_episode_rng.choice(all_model_ids)
+            self._objs: List[Actor] = []
+            for i, model_id in enumerate(model_ids):
+                builder = actors.get_actor_builder(self.scene, id=f"ycb:{model_id}")
+                builder.set_scene_idxs([i])
+                self._objs.append(builder.build(name=f"{model_id}-{i}"))
+            self.obj = Actor.merge(self._objs, name="ycb_object")
+        else:
+            raise ValueError(
+                f"Difficulty level must be an int within 0-4, but get {self.difficulty_level}"
+            )
+
+        if self.difficulty_level < 2:
+            # for levels 0 and 1 we already know object heights. For other levels we need to compute them
+            self.obj_heights = common.to_tensor(obj_heights, device=self.device)
+
+    def _after_reconfigure(self, options: dict):
+        if self.difficulty_level >= 2:
+            self.obj_heights = []
+            for obj in self._objs:
+                collision_mesh = obj.get_first_collision_mesh()
+                # this value is used to set object pose so the bottom is at z=0
+                self.obj_heights.append(-collision_mesh.bounding_box.bounds[0, 2])
+            self.obj_heights = common.to_tensor(self.obj_heights, device=self.device)
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        self._initialize_actors(env_idx)
+        self._initialize_agent(env_idx)
+
+    def _initialize_actors(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            # Initialize object pose
+            self.table_scene.initialize(env_idx)
+            pose = self.obj.pose
+            new_pos = torch.randn((b, 3)) * self.obj_init_pos_noise
+            # hand_init_height is robot hand position while the 0.03 is a margin to ensure
+            new_pos[:, 2] = (
+                torch.abs(new_pos[:, 2]) + self.hand_init_height + self.obj_heights
+            )
+            pose.raw_pose[:, 0:3] = new_pos
+            pose.raw_pose[:, 3:7] = torch.tensor([[1, 0, 0, 0]])
+            self.obj.set_pose(pose)
+
+            # Initialize object axis
+            if self.difficulty_level <= 2:
+                axis = torch.ones((b,), dtype=torch.long) * 2
+            else:
+                axis = torch.randint(0, 3, (b,), dtype=torch.long)
+            self.rot_dir = F.one_hot(axis, num_classes=3)
+
+            # Sample a unit vector on the tangent plane of rotating axis
+            vector_axis = (axis + 1) % 3
+            vector = F.one_hot(vector_axis, num_classes=3)
+
+            # Initialize task related cache
+            self.unit_vector = vector
+            self.prev_unit_vector = vector.clone()
+            self.success_threshold = torch.pi * 4
+            self.cum_rotation_angle = torch.zeros((b,))
+
+            # Controller parameters
+            stiffness = torch.tensor(self.agent.controller.config.stiffness)
+            damping = torch.tensor(self.agent.controller.config.damping)
+            force_limit = torch.tensor(self.agent.controller.config.force_limit)
+            self.controller_param = (
+                stiffness.expand(b, self.agent.robot.dof[0]),
+                damping.expand(b, self.agent.robot.dof[0]),
+                force_limit.expand(b, self.agent.robot.dof[0]),
+            )
+
+    def _initialize_agent(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            dof = self.agent.robot.dof
+            if isinstance(dof, torch.Tensor):
+                dof = dof[0]
+            init_qpos = torch.zeros((b, dof))
+            self.agent.reset(init_qpos)
+            self.agent.robot.set_pose(
+                Pose.create_from_pq(
+                    torch.tensor([0.0, 0, self.hand_init_height]),
+                    torch.tensor([-0.707, 0, 0.707, 0]),
+                )
+            )
+
+    def _get_obs_extra(self, info: Dict):
+        with torch.device(self.device):
+            obs = dict(rotate_dir=self.rot_dir)
+            if self.obs_mode_struct.use_state:
+                obs.update(
+                    obj_pose=vectorize_pose(self.obj.pose),
+                    obj_tip_vec=info["obj_tip_vec"].view(self.num_envs, 12),
+                )
+            return obs
+
+    def evaluate(self, **kwargs) -> dict:
+        with torch.device(self.device):
+            # 1. rotation angle
+            obj_pose = self.obj.pose
+            new_unit_vector = quaternion_apply(obj_pose.q, self.unit_vector)
+            new_unit_vector -= (
+                torch.sum(new_unit_vector * self.rot_dir, dim=-1, keepdim=True)
+                * self.rot_dir
+            )
+            new_unit_vector = new_unit_vector / torch.linalg.norm(
+                new_unit_vector, dim=-1, keepdim=True
+            )
+            angle = torch.acos(
+                torch.clip(
+                    torch.sum(new_unit_vector * self.prev_unit_vector, dim=-1), 0, 1
+                )
+            )
+            # We do not expect the rotation angle for a single step to be so large
+            angle = torch.clip(angle, -torch.pi / 20, torch.pi / 20)
+            self.prev_unit_vector = new_unit_vector
+
+            # 2. object velocity
+            obj_vel = torch.linalg.norm(self.obj.get_linear_velocity(), dim=-1)
+
+            # 3. object falling
+            obj_fall = (obj_pose.p[:, 2] < self.hand_init_height - 0.05).to(torch.bool)
+
+            # 4. finger object distance
+            tip_poses = [vectorize_pose(link.pose) for link in self.agent.tip_links]
+            tip_poses = torch.stack(tip_poses, dim=1)  # (b, 4, 7)
+            obj_tip_vec = tip_poses[..., :3] - obj_pose.p[:, None, :]  # (b, 4, 3)
+            obj_tip_dist = torch.linalg.norm(obj_tip_vec, dim=-1)  # (b, 4)
+
+            # 5. cum rotation angle
+            self.cum_rotation_angle += angle
+            success = self.cum_rotation_angle > self.success_threshold
+
+            # 6. controller effort
+            qpos_target = self.agent.controller._target_qpos
+            qpos_error = qpos_target - self.agent.robot.qpos
+            qvel = self.agent.robot.qvel
+            qf = qpos_error * self.controller_param[0] - qvel * self.controller_param[1]
+            qf = torch.clip(qf, -self.controller_param[2], self.controller_param[2])
+            power = torch.sum(qf * qvel, dim=-1)
+
+        return dict(
+            rotation_angle=angle,
+            obj_vel=obj_vel,
+            obj_fall=obj_fall,
+            obj_tip_vec=obj_tip_vec,
+            obj_tip_dist=obj_tip_dist,
+            success=success,
+            qf=qf,
+            power=power,
+            fail=obj_fall,
+        )
+
+    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+        # 1. rotation reward
+        angle = info["rotation_angle"]
+        reward = 20 * angle
+
+        # 2. velocity penalty
+        obj_vel = info["obj_vel"]
+        reward += -0.1 * obj_vel
+
+        # 3. falling penalty
+        obj_fall = info["obj_fall"]
+        reward += -50.0 * obj_fall
+
+        # 4. effort penalty
+        power = torch.abs(info["power"])
+        reward += -0.0003 * power
+
+        # 5. torque penalty
+        qf = info["qf"]
+        qf_norm = torch.linalg.norm(qf, dim=-1)
+        reward += -0.0003 * qf_norm
+
+        # 6. finger object distance reward
+        obj_tip_dist = info["obj_tip_dist"]
+        distance_rew = 0.1 / (0.02 + 4 * obj_tip_dist)
+        reward += torch.mean(torch.clip(distance_rew, 0, 1), dim=-1)
+
+        return reward
+
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+        # this should be equal to compute_dense_reward / max possible reward
+        return self.compute_dense_reward(obs=obs, action=action, info=info) / 4.0
+
+
+@register_env("RotateSingleObjectInHandLevel0-v1", max_episode_steps=300)
+class RotateSingleObjectInHandLevel0(RotateSingleObjectInHand):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            obj_init_pos_noise=0.02,
+            difficulty_level=0,
+            **kwargs,
+        )
+
+
+@register_env("RotateSingleObjectInHandLevel1-v1", max_episode_steps=300)
+class RotateSingleObjectInHandLevel1(RotateSingleObjectInHand):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            obj_init_pos_noise=0.02,
+            difficulty_level=1,
+            **kwargs,
+        )
+
+
+@register_env(
+    "RotateSingleObjectInHandLevel2-v1",
+    max_episode_steps=300,
+    asset_download_ids=["ycb"],
+)
+class RotateSingleObjectInHandLevel2(RotateSingleObjectInHand):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            obj_init_pos_noise=0.02,
+            difficulty_level=2,
+            **kwargs,
+        )
+
+
+@register_env(
+    "RotateSingleObjectInHandLevel3-v1",
+    max_episode_steps=300,
+    asset_download_ids=["ycb"],
+)
+class RotateSingleObjectInHandLevel3(RotateSingleObjectInHand):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            obj_init_pos_noise=0.02,
+            difficulty_level=3,
+            **kwargs,
+        )

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/dexterity/rotate_valve.py

@@ -0,0 +1,312 @@
+from typing import Any, Dict, List, Union
+
+import numpy as np
+import torch
+
+from mani_skill import logger
+from mani_skill.agents.robots import DClaw
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import sapien_utils
+from mani_skill.utils.building.articulations import build_robel_valve
+from mani_skill.utils.geometry.rotation_conversions import axis_angle_to_quaternion
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.scene_builder.table import TableSceneBuilder
+from mani_skill.utils.structs.articulation import Articulation
+from mani_skill.utils.structs.link import Link
+from mani_skill.utils.structs.pose import Pose, vectorize_pose
+from mani_skill.utils.structs.types import Array
+
+
+class RotateValveEnv(BaseEnv):
+    agent: Union[DClaw]
+    _clearance = 0.003
+
+    def __init__(
+        self,
+        *args,
+        robot_init_qpos_noise=0.02,
+        valve_init_pos_noise=0.02,
+        difficulty_level: int = -1,
+        **kwargs,
+    ):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        self.valve_init_pos_noise = valve_init_pos_noise
+
+        if (
+            not isinstance(difficulty_level, int)
+            or difficulty_level >= 5
+            or difficulty_level < 0
+        ):
+            raise ValueError(
+                f"Difficulty level must be a int within 0-4, but get {difficulty_level}"
+            )
+        self.difficulty_level = difficulty_level
+
+        # Task information
+        # For the simplest level 0, only quarter round will make it a success
+        # For the hardest level 4, rotate one rounds will make it a success
+        # For other intermediate level 1-3, the success threshold should be half round
+        if self.difficulty_level == 0:
+            self.success_threshold = torch.pi / 2
+        elif self.difficulty_level == 4:
+            self.success_threshold = torch.pi * 2
+        else:
+            self.success_threshold = torch.pi * 1
+
+        self.capsule_offset = 0.01
+
+        super().__init__(*args, robot_uids="dclaw", **kwargs)
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at(eye=[0.3, 0, 0.3], target=[-0.1, 0, 0.05])
+        return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([0.2, 0.4, 0.4], [0.0, 0.0, 0.1])
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _load_scene(self, options: dict):
+        self.table_scene = TableSceneBuilder(
+            env=self, robot_init_qpos_noise=self.robot_init_qpos_noise
+        )
+        self.table_scene.build()
+        self._load_articulations()
+
+    def _load_articulations(self):
+        # Robel valve
+        if self.difficulty_level == 0:
+            # Only tri-valve
+            valve_angles_list = [(0, np.pi / 3 * 2, np.pi / 3 * 4)] * self.num_envs
+        elif self.difficulty_level == 1:
+            base_angles = [
+                np.arange(0, np.pi * 2, np.pi * 2 / 3),
+                np.arange(0, np.pi * 2, np.pi / 2),
+                np.arange(0, np.pi * 2, np.pi * 2 / 5),
+            ]
+            valve_angles_list = (
+                base_angles * int(self.num_envs // 3)
+                + base_angles[: int(self.num_envs % 3)]
+            )
+        elif self.difficulty_level == 2:
+            num_valve_head = self._batched_episode_rng.randint(3, 6)
+            valve_angles_list = [
+                sample_valve_angles(num_head, self._batched_episode_rng[i])
+                for i, num_head in enumerate(num_valve_head)
+            ]
+        elif self.difficulty_level >= 3:
+            num_valve_head = self._batched_episode_rng.randint(3, 6)
+            valve_angles_list = [
+                sample_valve_angles(num_head, self._batched_episode_rng[i])
+                for i, num_head in enumerate(num_valve_head)
+            ]
+        else:
+            raise ValueError(
+                f"Difficulty level must be a int within 0-4, but get {self.difficulty_level}"
+            )
+
+        valves: List[Articulation] = []
+        capsule_lens = []
+        valve_links = []
+        for i, valve_angles in enumerate(valve_angles_list):
+            scene_idxs = [i]
+            if self.difficulty_level < 3:
+                valve, capsule_len = build_robel_valve(
+                    self.scene,
+                    valve_angles=valve_angles,
+                    scene_idxs=scene_idxs,
+                    name=f"valve_station_{i}",
+                )
+            else:
+                scales = self._batched_episode_rng[i].randn(2) * 0.1 + 1
+                valve, capsule_len = build_robel_valve(
+                    self.scene,
+                    valve_angles=valve_angles,
+                    scene_idxs=scene_idxs,
+                    name=f"valve_station_{i}",
+                    radius_scale=scales[0],
+                    capsule_radius_scale=scales[1],
+                )
+            valves.append(valve)
+            valve_links.append(valve.links_map["valve"])
+            capsule_lens.append(capsule_len)
+        self.valve = Articulation.merge(valves, "valve_station")
+        self.capsule_lens = torch.from_numpy(np.array(capsule_lens)).to(self.device)
+        self.valve_link = Link.merge(valve_links, name="valve")
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        self._initialize_actors(env_idx)
+        self._initialize_agent(env_idx)
+
+    def _initialize_actors(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            self.table_scene.initialize(env_idx)
+
+            # Initialize task related information
+            if self.difficulty_level <= 3:
+                self.rotate_direction = torch.ones(b)
+            else:
+                self.rotate_direction = 1 - torch.randint(0, 2, (b,)) * 2
+
+            # Initialize the valve
+            xyz = torch.zeros((b, 3))
+            xyz[:, :2].uniform_(-0.02, 0.02)
+            axis_angle = torch.zeros((b, 3))
+            axis_angle[:, 2].uniform_(torch.pi / 6, torch.pi * 5 / 6)
+            pose = Pose.create_from_pq(xyz, axis_angle_to_quaternion(axis_angle))
+            self.valve.set_pose(pose)
+
+            qpos = torch.rand((b, 1)) * torch.pi * 2 - torch.pi
+            self.valve.set_qpos(qpos)
+            self.rest_qpos = qpos
+
+    def _initialize_agent(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            dof = self.agent.robot.dof
+            if isinstance(dof, torch.Tensor):
+                dof = dof[0]
+
+            init_qpos = torch.zeros((b, dof))
+            # set root joint qpos to avoid robot-object collision after reset
+            init_qpos[:, self.agent.root_joint_indices] = torch.tensor(
+                [0.7, -0.7, -0.7]
+            )
+            init_qpos += torch.randn((b, dof)) * self.robot_init_qpos_noise
+            self.agent.reset(init_qpos)
+            self.agent.robot.set_pose(
+                Pose.create_from_pq(
+                    torch.tensor([0.0, 0, 0.28]), torch.tensor([0, 0, -1, 0])
+                )
+            )
+
+    def _get_obs_extra(self, info: Dict):
+        with torch.device(self.device):
+            valve_qpos = self.valve.qpos
+            valve_qvel = self.valve.qvel
+            obs = dict(
+                rotate_dir=self.rotate_direction.to(torch.float32),
+                valve_qpos=valve_qpos,
+                valve_qvel=valve_qvel,
+                valve_x=torch.cos(valve_qpos[:, 0]),
+                valve_y=torch.sin(valve_qpos[:, 0]),
+            )
+            if self.obs_mode_struct.use_state:
+                obs.update(
+                    valve_pose=vectorize_pose(self.valve.pose),
+                )
+            return obs
+
+    def evaluate(self, **kwargs) -> dict:
+        valve_rotation = (self.valve.qpos - self.rest_qpos)[:, 0]
+        success = valve_rotation * self.rotate_direction > self.success_threshold
+        return dict(success=success, valve_rotation=valve_rotation)
+
+    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+        rotation = info["valve_rotation"]
+        qvel = self.valve.qvel
+
+        # Distance between fingertips and the circle grouned by valve tips
+        tip_poses = self.agent.tip_poses  # (b, 3, 7)
+        tip_pos = tip_poses[:, :, :2]  # (b, 3, 2)
+        valve_pos = self.valve_link.pose.p[:, :2]  # (b, 2)
+        valve_tip_dist = torch.linalg.norm(tip_pos - valve_pos[:, None, :], dim=-1)
+        desired_valve_tip_dist = self.capsule_lens[:, None] - self.capsule_offset
+        error = torch.norm(valve_tip_dist - desired_valve_tip_dist, dim=-1)
+        reward = 1 - torch.tanh(error * 10)
+
+        directed_velocity = qvel[:, 0] * self.rotate_direction
+        reward += torch.tanh(5 * directed_velocity) * 4
+
+        motion_reward = torch.clip(rotation / torch.pi / 2, -1, 1)
+        reward += motion_reward
+
+        return reward
+
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+        # this should be equal to compute_dense_reward / max possible reward
+        return self.compute_dense_reward(obs=obs, action=action, info=info) / 6.0
+
+
+def sample_valve_angles(
+    num_head: int,
+    random_state: np.random.RandomState,
+    min_angle_diff=np.pi / 6,
+    num_max_attempts=500,
+):
+    for i in range(num_max_attempts):
+        angles = random_state.uniform(0, np.pi * 2, (num_head,))
+        angles = np.sort(angles)
+
+        # Append a 360 degree at the end of the list to check the last angle with the first one (0-degree)
+        diff = np.append(angles[1:], np.pi * 2) - angles
+        if np.min(diff) >= min_angle_diff:
+            return angles
+
+    logger.warn(
+        f"sample_valve_angles reach max attempts {num_max_attempts}. Will use the default valve angles."
+    )
+    return np.arange(0, np.pi * 2, np.pi * 2 / num_head)
+
+
+@register_env("RotateValveLevel0-v1", max_episode_steps=80)
+class RotateValveEnvLevel0(RotateValveEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            valve_init_pos_noise=0.02,
+            difficulty_level=0,
+            **kwargs,
+        )
+
+
+@register_env("RotateValveLevel1-v1", max_episode_steps=150)
+class RotateValveEnvLevel1(RotateValveEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            valve_init_pos_noise=0.02,
+            difficulty_level=1,
+            **kwargs,
+        )
+
+
+@register_env("RotateValveLevel2-v1", max_episode_steps=150)
+class RotateValveEnvLevel2(RotateValveEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            valve_init_pos_noise=0.02,
+            difficulty_level=2,
+            **kwargs,
+        )
+
+
+@register_env("RotateValveLevel3-v1", max_episode_steps=150)
+class RotateValveEnvLevel3(RotateValveEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            valve_init_pos_noise=0.02,
+            difficulty_level=3,
+            **kwargs,
+        )
+
+
+@register_env("RotateValveLevel4-v1", max_episode_steps=300)
+class RotateValveEnvLevel4(RotateValveEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            valve_init_pos_noise=0.02,
+            difficulty_level=4,
+            **kwargs,
+        )

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/empty_env.py

@@ -0,0 +1,51 @@
+from typing import Dict
+
+import numpy as np
+import sapien
+import torch
+
+from mani_skill.agents.robots.fetch.fetch import Fetch
+from mani_skill.agents.robots.panda.panda import Panda
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import sapien_utils
+from mani_skill.utils.building.ground import build_ground
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig
+
+
+@register_env("Empty-v1", max_episode_steps=200000)
+class EmptyEnv(BaseEnv):
+    SUPPORTED_REWARD_MODES = ["none"]
+    """
+    This is just a dummy environment for showcasing robots in a empty scene
+    """
+
+    def __init__(self, *args, robot_uids="panda", **kwargs):
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at([1.25, -1.25, 1.5], [0.0, 0.0, 0.2])
+        return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([1.25, -1.25, 1.5], [0.0, 0.0, 0.2])
+        return CameraConfig("render_camera", pose, 2048, 2048, 1, 0.01, 100)
+
+    def _load_agent(self, options: dict):
+        super()._load_agent(options, sapien.Pose())
+
+    def _load_scene(self, options: dict):
+        self.ground = build_ground(self.scene)
+        self.ground.set_collision_group_bit(group=2, bit_idx=30, bit=1)
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        pass
+
+    def evaluate(self):
+        return {}
+
+    def _get_obs_extra(self, info: Dict):
+        return dict()

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/__init__.py

@@ -0,0 +1,3 @@
+from .humanoid_pick_place import *
+from .humanoid_stand import HumanoidStandEnv
+from .transport_box import TransportBoxEnv

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/humanoid_stand.py

@@ -0,0 +1,129 @@
+from typing import Any, Dict, Union
+
+import numpy as np
+import sapien
+import torch
+
+from mani_skill.agents.robots import UnitreeG1Simplified, UnitreeH1Simplified
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building.ground import build_ground
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig
+
+
+class HumanoidStandEnv(BaseEnv):
+    SUPPORTED_REWARD_MODES = ["sparse", "none"]
+
+    def __init__(
+        self,
+        *args,
+        robot_uids="unitree_h1_simplified",
+        robot_init_qpos_noise=0.02,
+        **kwargs
+    ):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sensor_configs(self):
+        return []
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([1.0, 1.0, 2.5], [0.0, 0.0, 0.75])
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _load_scene(self, options: dict):
+        build_ground(self.scene)
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        pass
+
+    def evaluate(self):
+        is_standing = self.agent.is_standing()
+        self.agent.is_fallen()
+        return {"is_standing": is_standing, "fail": ~is_standing}
+
+    def _get_obs_extra(self, info: Dict):
+        return dict()
+
+    def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        return info["is_standing"]
+
+    # def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    #     return torch.zeros(self.num_envs, device=self.device)
+
+    # def compute_normalized_dense_reward(
+    #     self, obs: Any, action: torch.Tensor, info: Dict
+    # ):
+    #     max_reward = 1.0
+    #     return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward
+
+
+# Different robot embodiments require different configurations for optimal running and nicer render videos, we define those specifics below
+@register_env("UnitreeH1Stand-v1", max_episode_steps=1000)
+class UnitreeH1StandEnv(HumanoidStandEnv):
+    SUPPORTED_ROBOTS = ["unitree_h1_simplified"]
+    agent: Union[UnitreeH1Simplified]
+
+    def __init__(self, *args, robot_uids="unitree_h1_simplified", **kwargs):
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            gpu_memory_config=GPUMemoryConfig(
+                max_rigid_contact_count=2**22, max_rigid_patch_count=2**21
+            )
+        )
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([1.0, 1.0, 2.5], [0.0, 0.0, 0.75])
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        with torch.device(self.device):
+            b = len(env_idx)
+            standing_keyframe = self.agent.keyframes["standing"]
+            random_qpos = (
+                torch.randn(size=(b, self.agent.robot.dof[0]), dtype=torch.float) * 0.05
+            )
+            random_qpos += common.to_tensor(standing_keyframe.qpos, device=self.device)
+            self.agent.robot.set_qpos(random_qpos)
+            self.agent.robot.set_pose(sapien.Pose(p=[0, 0, 0.975]))
+
+
+@register_env("UnitreeG1Stand-v1", max_episode_steps=1000)
+class UnitreeG1StandEnv(HumanoidStandEnv):
+    SUPPORTED_ROBOTS = ["unitree_g1_simplified_legs"]
+    agent: Union[UnitreeG1Simplified]
+
+    def __init__(self, *args, robot_uids="unitree_g1_simplified_legs", **kwargs):
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            gpu_memory_config=GPUMemoryConfig(
+                max_rigid_contact_count=2**22, max_rigid_patch_count=2**21
+            )
+        )
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([1.0, 1.0, 2.0], [0.0, 0.0, 0.75])
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        with torch.device(self.device):
+            b = len(env_idx)
+            standing_keyframe = self.agent.keyframes["standing"]
+            random_qpos = (
+                torch.randn(size=(b, self.agent.robot.dof[0]), dtype=torch.float) * 0.05
+            )
+            random_qpos += common.to_tensor(standing_keyframe.qpos, device=self.device)
+            self.agent.robot.set_qpos(random_qpos)
+            self.agent.robot.set_pose(sapien.Pose(p=[0, 0, 0.755]))

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/humanoid/transport_box.py

@@ -0,0 +1,311 @@
+import copy
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+import numpy as np
+import sapien
+import torch
+from transforms3d.euler import euler2quat
+
+from mani_skill.agents.robots.unitree_g1.g1_upper_body import (
+    UnitreeG1UpperBodyWithHeadCamera,
+)
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.envs.utils import randomization
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import ground
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs.pose import Pose
+from mani_skill.utils.structs.types import GPUMemoryConfig, SceneConfig, SimConfig
+
+
+@register_env("UnitreeG1TransportBox-v1", max_episode_steps=100)
+class TransportBoxEnv(BaseEnv):
+    """
+    **Task Description:**
+    A G1 humanoid robot must find a box on a table and transport it to the other table and place it there.
+
+    **Randomizations:**
+    - the box's xy position is randomized in the region [-0.05, -0.05] x [0.2, 0.05]
+    - the box's z-axis rotation is randomized to a random angle in [0, np.pi/6]
+
+    **Success Conditions:**
+    - the box is resting on top of the other table
+    """
+
+    _sample_video_link = "https://github.com/haosulab/ManiSkill/raw/main/figures/environment_demos/UnitreeG1TransportBox-v1_rt.mp4"
+    SUPPORTED_ROBOTS = ["unitree_g1_simplified_upper_body_with_head_camera"]
+    agent: UnitreeG1UpperBodyWithHeadCamera
+
+    def __init__(self, *args, **kwargs):
+        self.init_robot_pose = copy.deepcopy(
+            UnitreeG1UpperBodyWithHeadCamera.keyframes["standing"].pose
+        )
+        self.init_robot_pose.p = [-0.1, 0, 0.755]
+        self.init_robot_qpos = UnitreeG1UpperBodyWithHeadCamera.keyframes[
+            "standing"
+        ].qpos.copy()
+        self.init_robot_qpos[4] = -1.25
+        self.init_robot_qpos[3] = 1.25
+        super().__init__(
+            *args,
+            robot_uids="unitree_g1_simplified_upper_body_with_head_camera",
+            **kwargs
+        )
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            gpu_memory_config=GPUMemoryConfig(
+                max_rigid_contact_count=2**22, max_rigid_patch_count=2**21
+            ),
+            scene_config=SceneConfig(contact_offset=0.02),
+        )
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at([1.0, 0.0, 1.6], [0, 0.0, 0.65])
+        return [
+            CameraConfig("base_camera", pose=pose, width=128, height=128, fov=np.pi / 3)
+        ]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at([1.0, 0.0, 1.6], [0, 0.0, 0.65])
+        return CameraConfig(
+            "render_camera", pose=pose, width=512, height=512, fov=np.pi / 3
+        )
+
+    def _load_agent(self, options: dict):
+        super()._load_agent(options, sapien.Pose(p=[0, 0, 1]))
+
+    def _load_scene(self, options: dict):
+        self.ground = ground.build_ground(self.scene, mipmap_levels=7)
+        # build two tables
+
+        model_dir = Path(
+            os.path.join(
+                os.path.dirname(__file__), "../../../utils/scene_builder/table/assets"
+            )
+        )
+        table_model_file = str(model_dir / "table.glb")
+        scale = 1.2
+        table_pose = sapien.Pose(q=euler2quat(0, 0, np.pi / 2))
+        builder = self.scene.create_actor_builder()
+        builder.add_visual_from_file(
+            filename=table_model_file,
+            scale=[scale] * 3,
+            pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)),
+        )
+        builder.add_box_collision(
+            pose=sapien.Pose(p=[0, 0, 0.630612274 / 2]),
+            half_size=(1.658057143 / 2, 0.829028571 / 2, 0.630612274 / 2),
+        )
+        builder.add_visual_from_file(
+            filename=table_model_file, scale=[scale] * 3, pose=table_pose
+        )
+        builder.initial_pose = sapien.Pose(p=[0, 0.66, 0])
+        self.table_1 = builder.build_static(name="table-1")
+        builder = self.scene.create_actor_builder()
+        builder.add_visual_from_file(
+            filename=table_model_file,
+            scale=[scale] * 3,
+            pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)),
+        )
+        builder.add_box_collision(
+            pose=sapien.Pose(p=[0, 0, 0.630612274 / 2]),
+            half_size=(1.658057143 / 2, 0.829028571 / 2, 0.630612274 / 2),
+        )
+        builder.add_visual_from_file(
+            filename=table_model_file, scale=[scale] * 3, pose=table_pose
+        )
+        builder.initial_pose = sapien.Pose(p=[0, -0.66, 0])
+        self.table_2 = builder.build_static(name="table-2")
+
+        builder = self.scene.create_actor_builder()
+        builder.add_box_collision(half_size=(0.18, 0.12, 0.12), density=200)
+        visual_file = os.path.join(
+            os.path.dirname(__file__), "assets/cardboard_box/textured.obj"
+        )
+        builder.add_visual_from_file(
+            filename=visual_file,
+            scale=[0.12] * 3,
+            pose=sapien.Pose(q=euler2quat(0, 0, np.pi / 2)),
+        )
+        builder.initial_pose = sapien.Pose(p=[-0.1, -0.37, 0.7508])
+        self.box = builder.build(name="box")
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        with torch.device(self.device):
+            b = len(env_idx)
+            self.agent.robot.set_qpos(self.init_robot_qpos)
+            self.agent.robot.set_pose(self.init_robot_pose)
+            xyz = torch.zeros((b, 3))
+            xyz[:, 2] = 0.7508
+            xyz[:, 0] = randomization.uniform(-0.05, 0.2, size=(b,))
+            xyz[:, 1] = randomization.uniform(-0.05, 0.05, size=(b,))
+            xyz[:, :2] += torch.tensor([-0.1, -0.37])
+            quat = randomization.random_quaternions(
+                n=b, device=self.device, lock_x=True, lock_y=True, bounds=(0, np.pi / 6)
+            )
+            self.box.set_pose(Pose.create_from_pq(xyz, quat))
+
+    def evaluate(self):
+        # left_hand_grasped_box = self.agent.left_hand_is_grasping(self.box, max_angle=110)
+        # right_hand_grasped_box = self.agent.right_hand_is_grasping(self.box, max_angle=110)
+        l_contact_forces = (
+            (
+                self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["left_five_link"], self.box
+                )
+                + self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["left_three_link"], self.box
+                )
+                + self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["left_palm_link"], self.box
+                )
+            )
+            .abs()
+            .sum(dim=1)
+        )
+        r_contact_forces = (
+            (
+                self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["right_five_link"], self.box
+                )
+                + self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["right_three_link"], self.box
+                )
+                + self.scene.get_pairwise_contact_forces(
+                    self.agent.robot.links_map["right_palm_link"], self.box
+                )
+            )
+            .abs()
+            .sum(dim=1)
+        )
+        left_hand_hit_box = l_contact_forces > 10
+        right_hand_hit_box = r_contact_forces > 10
+        # is grasping the box if both hands contact the box and the tcp of the hands are below the grasp points on the box.
+        box_grasped = (
+            left_hand_hit_box
+            & right_hand_hit_box
+            & (
+                self.agent.right_tcp.pose.p[:, 2]
+                < self.box_right_grasp_point.p[:, 2] + 0.04
+            )
+            & (
+                self.agent.left_tcp.pose.p[:, 2]
+                < self.box_left_grasp_point.p[:, 2] + 0.04
+            )
+        )
+
+        # simply requires box to be resting somewhere on the correct table
+        box_at_correct_table_z = (0.751 > self.box.pose.p[:, 2]) & (
+            self.box.pose.p[:, 2] > 0.750
+        )
+        box_at_correct_table_xy = (
+            (0.78 > self.box.pose.p[:, 0])
+            & (self.box.pose.p[:, 0] > -0.78)
+            & (1.0 > self.box.pose.p[:, 1])
+            & (self.box.pose.p[:, 1] > 0.3)
+        )
+        # box_at_correct_table = torch.linalg.norm(self.box.pose.p - torch.tensor([0, 0.66, 0.731], device=self.device), dim=1) < 0.05
+        box_at_correct_table = box_at_correct_table_z & box_at_correct_table_xy
+
+        facing_table_with_box = (-1.7 < self.agent.robot.qpos[:, 0]) & (
+            self.agent.robot.qpos[:, 0] < -1.4
+        )  # in this range the robot is probably facing the box on the left table.
+        return {
+            "success": ~box_grasped & box_at_correct_table,
+            "left_hand_hit_box": l_contact_forces > 0,
+            "right_hand_hit_box": r_contact_forces > 0,
+            "box_grasped": box_grasped,
+            "box_at_correct_table_xy": box_at_correct_table_xy,
+            "facing_table_with_box": facing_table_with_box,
+        }
+
+    def _get_obs_extra(self, info: Dict):
+        obs = dict(
+            right_tcp_pose=self.agent.right_tcp.pose.raw_pose,
+            left_tcp_pose=self.agent.left_tcp.pose.raw_pose,
+        )
+
+        if "state" in self.obs_mode:
+            obs.update(
+                box_pose=self.box.pose.raw_pose,
+                right_tcp_to_box_pos=self.box.pose.p - self.agent.right_tcp.pose.p,
+                left_tcp_to_box_pos=self.box.pose.p - self.agent.left_tcp.pose.p,
+            )
+        return obs
+
+    @property
+    def box_right_grasp_point(self):
+        return self.box.pose * Pose.create_from_pq(
+            torch.tensor([-0.165, 0.07, 0.05], device=self.device)
+        )
+
+    @property
+    def box_left_grasp_point(self):
+        return self.box.pose * Pose.create_from_pq(
+            torch.tensor([0.165, 0.07, 0.05], device=self.device)
+        )
+
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        # Stage 1, move to face the box on the table. Succeeds if facing_table_with_box
+        reward = 1 - torch.tanh((self.agent.robot.qpos[:, 0] + 1.4).abs())
+
+        # Stage 2, grasp the box stably. Succeeds if box_grasped
+        # encourage arms to go down essentially and for tcps to be close to the edge of the box
+        stage_2_reward = (
+            1
+            + (1 - torch.tanh((self.agent.robot.qpos[:, 3]).abs())) / 4
+            + (1 - torch.tanh((self.agent.robot.qpos[:, 4]).abs())) / 4
+            + (
+                1
+                - torch.tanh(
+                    3
+                    * torch.linalg.norm(
+                        self.agent.right_tcp.pose.p - self.box_right_grasp_point.p,
+                        dim=1,
+                    )
+                )
+            )
+            / 4
+            + (
+                1
+                - torch.tanh(
+                    3
+                    * torch.linalg.norm(
+                        self.agent.left_tcp.pose.p - self.box_left_grasp_point.p, dim=1
+                    )
+                )
+            )
+            / 4
+        )
+        reward[info["facing_table_with_box"]] = stage_2_reward[
+            info["facing_table_with_box"]
+        ]
+        # Stage 3 transport box to above the other table, Succeeds if box_at_correct_table_xy
+        stage_3_reward = (
+            2 + 1 - torch.tanh((self.agent.robot.qpos[:, 0] - 1.4).abs() / 5)
+        )
+        reward[info["box_grasped"]] = stage_3_reward[info["box_grasped"]]
+        # Stage 4 let go of the box. Succeeds if success (~box_grasped & box_at_correct_table)
+        stage_4_reward = (
+            3
+            + (1 - torch.tanh((self.agent.robot.qpos[:, 3] - 1.25).abs())) / 2
+            + (1 - torch.tanh((self.agent.robot.qpos[:, 4] + 1.25).abs())) / 2
+        )
+        reward[info["box_at_correct_table_xy"]] = stage_4_reward[
+            info["box_at_correct_table_xy"]
+        ]
+        # encourage agent to stay close to a target qposition?
+        reward[info["success"]] = 5
+        return reward
+
+    def compute_normalized_dense_reward(
+        self, obs: Any, action: torch.Tensor, info: Dict
+    ):
+        return self.compute_dense_reward(obs, action, info) / 5

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/mobile_manipulation/open_cabinet_drawer.py

@@ -0,0 +1,366 @@
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import sapien
+import sapien.physx as physx
+import torch
+import trimesh
+
+from mani_skill import PACKAGE_ASSET_DIR
+from mani_skill.agents.robots import Fetch
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.envs.utils import randomization
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import actors, articulations
+from mani_skill.utils.building.ground import build_ground
+from mani_skill.utils.geometry.geometry import transform_points
+from mani_skill.utils.io_utils import load_json
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs import Articulation, Link, Pose
+from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig
+
+CABINET_COLLISION_BIT = 29
+
+
+# TODO (stao): we need to cut the meshes of all the cabinets in this dataset for gpu sim, there may be some wierd physics
+# that may happen although it seems okay for state based RL
+@register_env(
+    "OpenCabinetDrawer-v1",
+    asset_download_ids=["partnet_mobility_cabinet"],
+    max_episode_steps=100,
+)
+class OpenCabinetDrawerEnv(BaseEnv):
+    """
+    **Task Description:**
+    Use the Fetch mobile manipulation robot to move towards a target cabinet and open the target drawer out.
+
+    **Randomizations:**
+    - Robot is randomly initialized 1.6 to 1.8 meters away from the cabinet and positioned to face it
+    - Robot's base orientation is randomized by -9 to 9 degrees
+    - The cabinet selected to manipulate is randomly sampled from all PartnetMobility cabinets that have drawers
+    - The drawer to open is randomly sampled from all drawers available to open
+
+    **Success Conditions:**
+    - The drawer is open at least 90% of the way, and the angular/linear velocities of the drawer link are small
+
+    **Goal Specification:**
+    - 3D goal position centered at the center of mass of the handle mesh on the drawer to open (also visualized in human renders with a sphere).
+    """
+
+    _sample_video_link = "https://github.com/haosulab/ManiSkill/raw/main/figures/environment_demos/OpenCabinetDrawer-v1_rt.mp4"
+
+    SUPPORTED_ROBOTS = ["fetch"]
+    agent: Union[Fetch]
+    handle_types = ["prismatic"]
+    TRAIN_JSON = (
+        PACKAGE_ASSET_DIR / "partnet_mobility/meta/info_cabinet_drawer_train.json"
+    )
+
+    min_open_frac = 0.75
+
+    def __init__(
+        self,
+        *args,
+        robot_uids="fetch",
+        robot_init_qpos_noise=0.02,
+        reconfiguration_freq=None,
+        num_envs=1,
+        **kwargs,
+    ):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        train_data = load_json(self.TRAIN_JSON)
+        self.all_model_ids = np.array(list(train_data.keys()))
+        # self.all_model_ids = np.array(["1004", "1004"])
+        if reconfiguration_freq is None:
+            # if not user set, we pick a number
+            if num_envs == 1:
+                reconfiguration_freq = 1
+            else:
+                reconfiguration_freq = 0
+        super().__init__(
+            *args,
+            robot_uids=robot_uids,
+            reconfiguration_freq=reconfiguration_freq,
+            num_envs=num_envs,
+            **kwargs,
+        )
+
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            spacing=5,
+            gpu_memory_config=GPUMemoryConfig(
+                max_rigid_contact_count=2**21, max_rigid_patch_count=2**19
+            ),
+        )
+
+    @property
+    def _default_sensor_configs(self):
+        return []
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at(eye=[-1.8, -1.3, 1.8], target=[-0.3, 0.5, 0])
+        return CameraConfig(
+            "render_camera", pose=pose, width=512, height=512, fov=1, near=0.01, far=100
+        )
+
+    def _load_agent(self, options: dict):
+        super()._load_agent(options, sapien.Pose(p=[1, 0, 0]))
+
+    def _load_scene(self, options: dict):
+        self.ground = build_ground(self.scene)
+        # temporarily turn off the logging as there will be big red warnings
+        # about the cabinets having oblong meshes which we ignore for now.
+        sapien.set_log_level("off")
+        self._load_cabinets(self.handle_types)
+        sapien.set_log_level("warn")
+        from mani_skill.agents.robots.fetch import FETCH_WHEELS_COLLISION_BIT
+
+        self.ground.set_collision_group_bit(
+            group=2, bit_idx=FETCH_WHEELS_COLLISION_BIT, bit=1
+        )
+        self.ground.set_collision_group_bit(
+            group=2, bit_idx=CABINET_COLLISION_BIT, bit=1
+        )
+
+    def _load_cabinets(self, joint_types: List[str]):
+        # we sample random cabinet model_ids with numpy as numpy is always deterministic based on seed, regardless of
+        # GPU/CPU simulation backends. This is useful for replaying demonstrations.
+        model_ids = self._batched_episode_rng.choice(self.all_model_ids)
+        link_ids = self._batched_episode_rng.randint(0, 2**31)
+
+        self._cabinets = []
+        handle_links: List[List[Link]] = []
+        handle_links_meshes: List[List[trimesh.Trimesh]] = []
+        for i, model_id in enumerate(model_ids):
+            # partnet-mobility is a dataset source and the ids are the ones we sampled
+            # we provide tools to easily create the articulation builder like so by querying
+            # the dataset source and unique ID
+            cabinet_builder = articulations.get_articulation_builder(
+                self.scene, f"partnet-mobility:{model_id}"
+            )
+            cabinet_builder.set_scene_idxs(scene_idxs=[i])
+            cabinet_builder.initial_pose = sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0])
+            cabinet = cabinet_builder.build(name=f"{model_id}-{i}")
+            self.remove_from_state_dict_registry(cabinet)
+            # this disables self collisions by setting the group 2 bit at CABINET_COLLISION_BIT all the same
+            # that bit is also used to disable collision with the ground plane
+            for link in cabinet.links:
+                link.set_collision_group_bit(
+                    group=2, bit_idx=CABINET_COLLISION_BIT, bit=1
+                )
+            self._cabinets.append(cabinet)
+            handle_links.append([])
+            handle_links_meshes.append([])
+
+            # TODO (stao): At the moment code for selecting semantic parts of articulations
+            # is not very simple. Will be improved in the future as we add in features that
+            # support part and mesh-wise annotations in a standard querable format
+            for link, joint in zip(cabinet.links, cabinet.joints):
+                if joint.type[0] in joint_types:
+                    handle_links[-1].append(link)
+                    # save the first mesh in the link object that correspond with a handle
+                    handle_links_meshes[-1].append(
+                        link.generate_mesh(
+                            filter=lambda _, render_shape: "handle"
+                            in render_shape.name,
+                            mesh_name="handle",
+                        )[0]
+                    )
+
+        # we can merge different articulations/links with different degrees of freedoms into a single view/object
+        # allowing you to manage all of them under one object and retrieve data like qpos, pose, etc. all together
+        # and with high performance. Note that some properties such as qpos and qlimits are now padded.
+        self.cabinet = Articulation.merge(self._cabinets, name="cabinet")
+        self.add_to_state_dict_registry(self.cabinet)
+        self.handle_link = Link.merge(
+            [links[link_ids[i] % len(links)] for i, links in enumerate(handle_links)],
+            name="handle_link",
+        )
+        # store the position of the handle mesh itself relative to the link it is apart of
+        self.handle_link_pos = common.to_tensor(
+            np.array(
+                [
+                    meshes[link_ids[i] % len(meshes)].bounding_box.center_mass
+                    for i, meshes in enumerate(handle_links_meshes)
+                ]
+            ),
+            device=self.device,
+        )
+
+        self.handle_link_goal = actors.build_sphere(
+            self.scene,
+            radius=0.02,
+            color=[0, 1, 0, 1],
+            name="handle_link_goal",
+            body_type="kinematic",
+            add_collision=False,
+            initial_pose=sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0]),
+        )
+
+    def _after_reconfigure(self, options):
+        # To spawn cabinets in the right place, we need to change their z position such that
+        # the bottom of the cabinet sits at z=0 (the floor). Luckily the partnet mobility dataset is made such that
+        # the negative of the lower z-bound of the collision mesh bounding box is the right value
+
+        # this code is in _after_reconfigure since retrieving collision meshes requires the GPU to be initialized
+        # which occurs after the initial reconfigure call (after self._load_scene() is called)
+        self.cabinet_zs = []
+        for cabinet in self._cabinets:
+            collision_mesh = cabinet.get_first_collision_mesh()
+            self.cabinet_zs.append(-collision_mesh.bounding_box.bounds[0, 2])
+        self.cabinet_zs = common.to_tensor(self.cabinet_zs, device=self.device)
+
+        # get the qmin qmax values of the joint corresponding to the selected links
+        target_qlimits = self.handle_link.joint.limits  # [b, 1, 2]
+        qmin, qmax = target_qlimits[..., 0], target_qlimits[..., 1]
+        self.target_qpos = qmin + (qmax - qmin) * self.min_open_frac
+
+    def handle_link_positions(self, env_idx: Optional[torch.Tensor] = None):
+        if env_idx is None:
+            return transform_points(
+                self.handle_link.pose.to_transformation_matrix().clone(),
+                common.to_tensor(self.handle_link_pos, device=self.device),
+            )
+        return transform_points(
+            self.handle_link.pose[env_idx].to_transformation_matrix().clone(),
+            common.to_tensor(self.handle_link_pos[env_idx], device=self.device),
+        )
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+
+        with torch.device(self.device):
+            b = len(env_idx)
+            xy = torch.zeros((b, 3))
+            xy[:, 2] = self.cabinet_zs[env_idx]
+            self.cabinet.set_pose(Pose.create_from_pq(p=xy))
+
+            # initialize robot
+            if self.robot_uids == "fetch":
+                qpos = torch.tensor(
+                    [
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        -np.pi / 4,
+                        0,
+                        np.pi / 4,
+                        0,
+                        np.pi / 3,
+                        0,
+                        0.015,
+                        0.015,
+                    ]
+                )
+                qpos = qpos.repeat(b).reshape(b, -1)
+                dist = randomization.uniform(1.6, 1.8, size=(b,))
+                theta = randomization.uniform(0.9 * torch.pi, 1.1 * torch.pi, size=(b,))
+                xy = torch.zeros((b, 2))
+                xy[:, 0] += torch.cos(theta) * dist
+                xy[:, 1] += torch.sin(theta) * dist
+                qpos[:, :2] = xy
+                noise_ori = randomization.uniform(
+                    -0.05 * torch.pi, 0.05 * torch.pi, size=(b,)
+                )
+                ori = (theta - torch.pi) + noise_ori
+                qpos[:, 2] = ori
+                self.agent.robot.set_qpos(qpos)
+                self.agent.robot.set_pose(sapien.Pose())
+            # close all the cabinets. We know beforehand that lower qlimit means "closed" for these assets.
+            qlimits = self.cabinet.get_qlimits()  # [b, self.cabinet.max_dof, 2])
+            self.cabinet.set_qpos(qlimits[env_idx, :, 0])
+            self.cabinet.set_qvel(self.cabinet.qpos[env_idx] * 0)
+
+            # NOTE (stao): This is a temporary work around for the issue where the cabinet drawers/doors might open
+            # themselves on the first step. It's unclear why this happens on GPU sim only atm.
+            # moreover despite setting qpos/qvel to 0, the cabinets might still move on their own a little bit.
+            # this may be due to oblong meshes.
+            if self.gpu_sim_enabled:
+                self.scene._gpu_apply_all()
+                self.scene.px.gpu_update_articulation_kinematics()
+                self.scene.px.step()
+                self.scene._gpu_fetch_all()
+
+            self.handle_link_goal.set_pose(
+                Pose.create_from_pq(p=self.handle_link_positions(env_idx))
+            )
+
+    def _after_control_step(self):
+        # after each control step, we update the goal position of the handle link
+        # for GPU sim we need to update the kinematics data to get latest pose information for up to date link poses
+        # and fetch it, followed by an apply call to ensure the GPU sim is up to date
+        if self.gpu_sim_enabled:
+            self.scene.px.gpu_update_articulation_kinematics()
+            self.scene._gpu_fetch_all()
+        self.handle_link_goal.set_pose(
+            Pose.create_from_pq(p=self.handle_link_positions())
+        )
+        if self.gpu_sim_enabled:
+            self.scene._gpu_apply_all()
+
+    def evaluate(self):
+        # even though self.handle_link is a different link across different articulations
+        # we can still fetch a joint that represents the parent joint of all those links
+        # and easily get the qpos value.
+        open_enough = self.handle_link.joint.qpos >= self.target_qpos
+        handle_link_pos = self.handle_link_positions()
+
+        link_is_static = (
+            torch.linalg.norm(self.handle_link.angular_velocity, axis=1) <= 1
+        ) & (torch.linalg.norm(self.handle_link.linear_velocity, axis=1) <= 0.1)
+        return {
+            "success": open_enough & link_is_static,
+            "handle_link_pos": handle_link_pos,
+            "open_enough": open_enough,
+        }
+
+    def _get_obs_extra(self, info: Dict):
+        obs = dict(
+            tcp_pose=self.agent.tcp.pose.raw_pose,
+        )
+
+        if "state" in self.obs_mode:
+            obs.update(
+                tcp_to_handle_pos=info["handle_link_pos"] - self.agent.tcp.pose.p,
+                target_link_qpos=self.handle_link.joint.qpos,
+                target_handle_pos=info["handle_link_pos"],
+            )
+        return obs
+
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        tcp_to_handle_dist = torch.linalg.norm(
+            self.agent.tcp.pose.p - info["handle_link_pos"], axis=1
+        )
+        reaching_reward = 1 - torch.tanh(5 * tcp_to_handle_dist)
+        amount_to_open_left = torch.div(
+            self.target_qpos - self.handle_link.joint.qpos, self.target_qpos
+        )
+        open_reward = 2 * (1 - amount_to_open_left)
+        reaching_reward[
+            amount_to_open_left < 0.999
+        ] = 2  # if joint opens even a tiny bit, we don't need reach reward anymore
+        # print(open_reward.shape)
+        open_reward[info["open_enough"]] = 3  # give max reward here
+        reward = reaching_reward + open_reward
+        reward[info["success"]] = 5.0
+        return reward
+
+    def compute_normalized_dense_reward(
+        self, obs: Any, action: torch.Tensor, info: Dict
+    ):
+        max_reward = 5.0
+        return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward
+
+
+@register_env("OpenCabinetDoor-v1", max_episode_steps=100)
+class OpenCabinetDoorEnv(OpenCabinetDrawerEnv):
+    TRAIN_JSON = (
+        PACKAGE_ASSET_DIR / "partnet_mobility/meta/info_cabinet_door_train.json"
+    )
+    handle_types = ["revolute", "revolute_unwrapped"]

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/tasks/rotate_cube.py

@@ -0,0 +1,403 @@
+from typing import Any, Dict, Tuple
+
+import numpy as np
+import torch
+import torch.random
+
+from mani_skill import PACKAGE_ASSET_DIR
+from mani_skill.agents.robots import TriFingerPro
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.envs.utils.randomization.pose import random_quaternions
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import ActorBuilder, actors
+from mani_skill.utils.building.ground import build_ground
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs import Actor, Articulation, Pose
+from mani_skill.utils.structs.types import Array, GPUMemoryConfig, SimConfig
+
+
+class RotateCubeEnv(BaseEnv):
+    """
+    Modified from https://github.com/NVIDIA-Omniverse/IsaacGymEnvs/blob/main/isaacgymenvs/tasks/trifinger.py
+    https://github.com/NVIDIA-Omniverse/IsaacGymEnvs/blob/main/isaacgymenvs/cfg/task/Trifinger.yaml
+    """
+
+    SUPPORTED_ROBOTS = ["trifingerpro"]
+
+    # Specify some supported robot types
+    agent: TriFingerPro
+
+    # Specify default simulation/gpu memory configurations.
+    sim_config = SimConfig(
+        gpu_memory_config=GPUMemoryConfig(
+            found_lost_pairs_capacity=2**25, max_rigid_patch_count=2**18
+        )
+    )
+
+    # set some commonly used values
+    goal_radius = 0.02
+    cube_half_size = 0.02
+
+    # radius of the area
+    ARENA_RADIUS = 0.195
+    size = 0.065  # m
+    max_len = 0.065
+    # 3D radius of the cuboid
+    radius_3d = max_len * np.sqrt(3) / 2
+    # compute distance from wall to the center
+    max_com_distance_to_center = ARENA_RADIUS - radius_3d
+    # minimum and maximum height for spawning the object
+    min_height = 0.065 / 2
+    max_height = 0.1
+
+    def __init__(
+        self,
+        *args,
+        robot_uids="trifingerpro",
+        robot_init_qpos_noise=0.02,
+        difficulty_level: int = 4,
+        **kwargs,
+    ):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+
+        if (
+            not isinstance(difficulty_level, int)
+            or difficulty_level >= 5
+            or difficulty_level < 0
+        ):
+            raise ValueError(
+                f"Difficulty level must be a int within 0-4, but get {difficulty_level}"
+            )
+
+        self.difficulty_level = difficulty_level
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    @property
+    def _default_sensor_configs(self):
+        pose = sapien_utils.look_at(eye=(0.7, 0.0, 0.7), target=(0.0, 0.0, 0.0))
+        return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        pose = sapien_utils.look_at(eye=(0.7, 0.0, 0.7), target=(0.0, 0.0, 0.0))
+        return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
+
+    def _load_scene(self, options: dict):
+        self.ground = build_ground(self.scene, altitude=0)
+        loader1 = self.scene.create_urdf_loader()
+        loader1.fix_root_link = True
+        loader1.name = "table"
+        urdf_path = f"{PACKAGE_ASSET_DIR}/robots/trifinger/table_without_border.urdf"
+        table: Articulation = loader1.load(urdf_path)
+
+        builder: ActorBuilder = self.scene.create_actor_builder()
+        high_table_boundary_file_name = f"{PACKAGE_ASSET_DIR}/robots/trifinger/robot_properties_fingers/meshes/high_table_boundary.stl"
+        builder.add_nonconvex_collision_from_file(
+            filename=high_table_boundary_file_name, scale=[1, 1, 1], material=None
+        )
+        builder.add_visual_from_file(filename=high_table_boundary_file_name)
+        table_boundary: Actor = builder.build_static("table2")
+
+        self.obj = actors.build_colorful_cube(
+            self.scene,
+            half_size=self.size / 2,
+            color=np.array([169, 42, 12, 255]) / 255,
+            name="cube",
+            body_type="dynamic",
+            add_collision=True,
+        )
+
+        self.obj_goal = actors.build_colorful_cube(
+            self.scene,
+            half_size=self.size / 2,
+            color=np.array([12, 160, 42, 255]) / 255,
+            name="cube_goal",
+            body_type="kinematic",
+            add_collision=False,
+        )
+        self._hidden_objects.append(self.obj_goal)
+
+    def _initialize_actors(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            xyz = torch.zeros((b, 3))
+            xyz[..., 2] = self.size / 2 + 0.005
+            obj_pose = Pose.create_from_pq(p=xyz, q=[1, 0, 0, 0])
+            self.obj.set_pose(obj_pose)
+            pos, orn = self._sample_object_goal_poses(
+                env_idx, difficulty=self.difficulty_level
+            )
+            self.obj_goal.set_pose(Pose.create_from_pq(p=pos, q=orn))
+            self.prev_norms = None
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        self._initialize_actors(env_idx)
+        self._initialize_agent(env_idx)
+
+    def _sample_object_goal_poses(self, env_idx: torch.Tensor, difficulty: int):
+        """Sample goal poses for the cube and sets them into the desired goal pose buffer.
+
+        Args:
+            instances: A tensor constraining indices of environment instances to reset.
+            difficulty: Difficulty level. The higher, the more difficult is the goal.
+
+        Possible levels are:
+            - 0: Random goal position on the table, no orientation.
+            - 1:  Random goal position on the table, including yaw orientation.
+            - 2: Fixed goal position in the air with x,y = 0.  No orientation.
+            - 3: Random goal position in the air, no orientation.
+            - 4: Random goal pose in the air, including orientation.
+        """
+        b = len(env_idx)
+        default_orn = torch.tensor(
+            [1.0, 0.0, 0.0, 0.0], dtype=torch.float, device=self.device
+        ).repeat(b, 1)
+
+        def random_xy() -> Tuple[torch.Tensor, torch.Tensor]:
+            """Returns sampled uniform positions in circle (https://stackoverflow.com/a/50746409)"""
+            # sample radius of circle
+            radius = torch.sqrt(torch.rand(b, dtype=torch.float, device=self.device))
+            radius *= self.max_com_distance_to_center
+            # sample theta of point
+            theta = 2 * np.pi * torch.rand(b, dtype=torch.float, device=self.device)
+            # x,y-position of the cube
+            x = radius * torch.cos(theta)
+            y = radius * torch.sin(theta)
+
+            return x, y
+
+        def random_z(min_height: float, max_height: float) -> torch.Tensor:
+            """Returns sampled height of the goal object."""
+            z = torch.rand(b, dtype=torch.float, device=self.device)
+            z = (max_height - min_height) * z + min_height
+            return z
+
+        if difficulty == 0:
+            # Random goal position on the table, no orientation.
+            pos_x, pos_y = random_xy()
+            pos_z = self.size / 2
+            orientation = default_orn
+        elif difficulty == 1:
+            # For initialization
+            pos_x, pos_y = random_xy()
+            pos_z = self.size / 2
+            orientation = random_quaternions(
+                b, lock_x=True, lock_y=True, device=self.device
+            )
+        elif difficulty == 2:
+            # Fixed goal position in the air with x,y = 0.  No orientation.
+            pos_x, pos_y = 0.0, 0.0
+            pos_z = self.min_height + 0.05
+            orientation = default_orn
+        elif difficulty == 3:
+            # Random goal position in the air, no orientation.
+            pos_x, pos_y = random_xy()
+            pos_z = random_z(min_height=self.min_height, max_height=self.max_height)
+            orientation = default_orn
+        elif difficulty == 4:
+            # Random goal pose in the air, including orientation.
+            # Note: Set minimum height such that the cube does not intersect with the
+            #       ground in any orientation
+
+            # pick x, y, z according to the maximum height / radius at the current point
+            # in the cirriculum
+            pos_x, pos_y = random_xy()
+            pos_z = random_z(min_height=self.radius_3d, max_height=self.max_height)
+            orientation = random_quaternions(b, device=self.device)
+        else:
+            msg = f"Invalid difficulty index for task: {difficulty}."
+            raise ValueError(msg)
+
+        pos_tensor = torch.zeros((b, 3), dtype=torch.float, device=self.device)
+        pos_tensor[:, 0] = pos_x
+        pos_tensor[:, 1] = pos_y
+        pos_tensor[:, 2] = pos_z
+        return pos_tensor, orientation
+
+    def evaluate(self):
+        obj_p = self.obj.pose.p
+        goal_p = self.obj_goal.pose.p
+        obj_q = self.obj.pose.q
+        goal_q = self.obj_goal.pose.q
+
+        is_obj_pos_close_to_goal = (
+            torch.linalg.norm(obj_p - goal_p, axis=1) < self.goal_radius
+        )
+
+        is_obj_q_close_to_goal = common.quat_diff_rad(obj_q, goal_q) < 0.1
+
+        is_success = is_obj_pos_close_to_goal & is_obj_q_close_to_goal
+
+        return {
+            "success": is_success,
+        }
+
+    def _initialize_agent(self, env_idx: torch.Tensor):
+        with torch.device(self.device):
+            b = len(env_idx)
+            dof = self.agent.robot.dof
+            if isinstance(dof, torch.Tensor):
+                dof = dof[0]
+
+            init_qpos = torch.zeros((b, dof))
+            init_qpos += torch.randn((b, dof)) * self.robot_init_qpos_noise
+            self.agent.reset(init_qpos)
+            self.agent.robot.set_pose(
+                Pose.create_from_pq(
+                    torch.tensor([0.0, 0, self.size / 2 + 0.022]),
+                    torch.tensor([1, 0, 0, 0]),
+                )
+            )
+
+    def _get_obs_extra(self, info: Dict):
+        obs = dict(
+            goal_pos=self.obj_goal.pose.p,
+            goal_q=self.obj_goal.pose.q,
+        )
+        if self.obs_mode_struct.use_state:
+            obs.update(
+                obj_p=self.obj.pose.p,
+                obj_q=self.obj.pose.q,
+            )
+        return obs
+
+    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+        obj_pos = self.obj.pose.p
+        obj_q = self.obj.pose.q
+        goal_pos = self.obj_goal.pose.p
+        goal_q = self.obj_goal.pose.q
+
+        object_dist_weight = 5
+        object_rot_weight = 5
+
+        # Reward penalising finger movement
+
+        tip_poses = self.agent.tip_poses
+        # shape (N, 3 + 4, 3 fingers)
+
+        finger_reach_object_dist_1 = torch.norm(
+            tip_poses[:, :3, 0] - obj_pos, p=2, dim=-1
+        )
+        finger_reach_object_dist_2 = torch.norm(
+            tip_poses[:, :3, 1] - obj_pos, p=2, dim=-1
+        )
+        finger_reach_object_dist_3 = torch.norm(
+            tip_poses[:, :3, 2] - obj_pos, p=2, dim=-1
+        )
+        finger_reach_object_reward1 = 1 - torch.tanh(5 * finger_reach_object_dist_1)
+        finger_reach_object_reward2 = 1 - torch.tanh(5 * finger_reach_object_dist_2)
+        finger_reach_object_reward3 = 1 - torch.tanh(5 * finger_reach_object_dist_3)
+        finger_reach_object_reward = (
+            object_dist_weight
+            * (
+                finger_reach_object_reward1
+                + finger_reach_object_reward2
+                + finger_reach_object_reward3
+            )
+            / 3
+        )
+
+        # Reward for object distance
+        object_dist = torch.norm(obj_pos - goal_pos, p=2, dim=-1)
+
+        init_xyz_tensor = torch.tensor(
+            [0, 0, 0.032], dtype=torch.float, device=self.device
+        ).reshape(1, 3)
+        init_z_dist = torch.norm(
+            init_xyz_tensor
+            - goal_pos[
+                ...,
+            ],
+            p=2,
+            dim=-1,
+        )
+
+        # object_dist_reward = object_dist_weight * dt * lgsk_kernel(object_dist, scale=50., eps=2.)
+
+        object_dist_reward = 1 - torch.tanh(5 * object_dist)
+        object_init_dist_reward = 1 - torch.tanh(5 * init_z_dist)
+        object_dist_reward -= object_init_dist_reward
+
+        init_z_tensor = torch.tensor(
+            [0.032], dtype=torch.float, device=self.device
+        ).reshape(1, 1)
+        object_z_dist = torch.norm(obj_pos[..., 2:3] - goal_pos[..., 2:3], p=2, dim=-1)
+        init_z_dist = torch.norm(init_z_tensor - goal_pos[..., 2:3], p=2, dim=-1)
+        object_lift_reward = 5 * ((1 - torch.tanh(5 * object_z_dist)))
+        object_init_z_reward = 5 * ((1 - torch.tanh(5 * init_z_dist)))
+
+        object_lift_reward -= object_init_z_reward
+
+        # extract quaternion orientation
+        angles = common.quat_diff_rad(obj_q, goal_q)
+        object_rot_reward = -1 * torch.abs(angles)
+        pose_reward = (
+            object_dist_weight * (object_dist_reward + object_lift_reward)
+            + object_rot_weight * object_rot_reward
+        )
+        total_reward = finger_reach_object_reward + pose_reward
+        total_reward = total_reward.clamp(-15, 15)
+        total_reward[info["success"]] = 15
+        return total_reward
+
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+        self.max_reward = 15
+        dense_reward = self.compute_dense_reward(obs=obs, action=action, info=info)
+        norm_dense_reward = dense_reward / (2 * self.max_reward) + 0.5
+        return norm_dense_reward
+
+
+@register_env("TriFingerRotateCubeLevel0-v1", max_episode_steps=250)
+class RotateCubeEnvLevel0(RotateCubeEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            difficulty_level=0,
+            **kwargs,
+        )
+
+
+@register_env("TriFingerRotateCubeLevel1-v1", max_episode_steps=250)
+class RotateCubeEnvLevel1(RotateCubeEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            difficulty_level=1,
+            **kwargs,
+        )
+
+
+@register_env("TriFingerRotateCubeLevel2-v1", max_episode_steps=250)
+class RotateCubeEnvLevel2(RotateCubeEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            difficulty_level=2,
+            **kwargs,
+        )
+
+
+@register_env("TriFingerRotateCubeLevel3-v1", max_episode_steps=250)
+class RotateCubeEnvLevel3(RotateCubeEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            difficulty_level=3,
+            **kwargs,
+        )
+
+
+@register_env("TriFingerRotateCubeLevel4-v1", max_episode_steps=250)
+class RotateCubeEnvLevel4(RotateCubeEnv):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            robot_init_qpos_noise=0.02,
+            difficulty_level=4,
+            **kwargs,
+        )

project/ManiSkill3/src/maniskill3_environment/mani_skill/envs/template.py

@@ -0,0 +1,205 @@
+"""
+Code for a minimal environment/task with just a robot being loaded. We recommend copying this template and modifying as you need.
+
+At a high-level, ManiSkill tasks can minimally be defined by what agents/actors are
+loaded, how agents/actors are randomly initialized during env resets, how goals are randomized and parameterized in observations, and success conditions
+
+Environment reset is comprised of running two functions, `self._reconfigure` and `self.initialize_episode`, which is auto
+run by ManiSkill. As a user, you can override a number of functions that affect reconfiguration and episode initialization.
+
+Reconfiguration will reset the entire environment scene and allow you to load/swap assets and agents.
+
+Episode initialization will reset the poses of all actors, articulations, and agents,
+in addition to initializing any task relevant data like a goal
+
+See comments for how to make your own environment and what each required function should do. If followed correctly you can easily build a
+task that can simulate on the CPU and be parallelized on the GPU without having to manage GPU memory and parallelization apart from some
+code that need to be written in batched mode (e.g. reward, success conditions)
+
+For a minimal implementation of a simple task, check out
+mani_skill /envs/tasks/push_cube.py which is annotated with comments to explain how it is implemented
+"""
+
+
+from typing import Any, Dict, Union
+
+import numpy as np
+import sapien
+import torch
+
+from mani_skill.agents.multi_agent import MultiAgent
+from mani_skill.agents.robots.fetch.fetch import Fetch
+from mani_skill.agents.robots.panda.panda import Panda
+from mani_skill.envs.sapien_env import BaseEnv
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import actors
+from mani_skill.utils.registration import register_env
+from mani_skill.utils.structs.types import GPUMemoryConfig, SimConfig
+
+
+# register the environment by a unique ID and specify a max time limit. Now once this file is imported you can do gym.make("CustomEnv-v0")
+@register_env("CustomEnv-v1", max_episode_steps=200)
+class CustomEnv(BaseEnv):
+    """
+    Task Description
+    ----------------
+    Add a task description here
+
+    Randomizations
+    --------------
+    - how is it randomized?
+    - how is that randomized?
+
+    Success Conditions
+    ------------------
+    - what is done to check if this task is solved?
+
+    Visualization: link to a video/gif of the task being solved
+    """
+
+    # here you can define a list of robots that this task is built to support and be solved by. This is so that
+    # users won't be permitted to use robots not predefined here. If SUPPORTED_ROBOTS is not defined then users can do anything
+    SUPPORTED_ROBOTS = ["panda", "fetch"]
+    # if you want to say you support multiple robots you can use SUPPORTED_ROBOTS = [["panda", "panda"], ["panda", "fetch"]] etc.
+
+    # to help with programming, you can assert what type of agents are supported like below, and any shared properties of self.agent
+    # become available to typecheckers and auto-completion. E.g. Panda and Fetch both share a property called .tcp (tool center point).
+    agent: Union[Panda, Fetch]
+    # if you want to do typing for multi-agent setups, use this below and specify what possible tuples of robots are permitted by typing
+    # this will then populate agent.agents (list of the instantiated agents) with the right typing
+    # agent: MultiAgent[Union[Tuple[Panda, Panda], Tuple[Panda, Panda, Panda]]]
+
+    # in the __init__ function you can pick a default robot your task should use e.g. the panda robot by setting a default for robot_uids argument
+    # note that if robot_uids is a list of robot uids, then we treat it as a multi-agent setup and load each robot separately.
+    def __init__(self, *args, robot_uids="panda", robot_init_qpos_noise=0.02, **kwargs):
+        self.robot_init_qpos_noise = robot_init_qpos_noise
+        super().__init__(*args, robot_uids=robot_uids, **kwargs)
+
+    # Specify default simulation/gpu memory configurations. Note that tasks need to tune their GPU memory configurations accordingly
+    # in order to save memory while also running with no errors. In general you can start with low values and increase them
+    # depending on the messages that show up when you try to run more environments in parallel. Since this is a python property
+    # you can also check self.num_envs to dynamically set configurations as well
+    @property
+    def _default_sim_config(self):
+        return SimConfig(
+            gpu_memory_config=GPUMemoryConfig(
+                found_lost_pairs_capacity=2**25, max_rigid_patch_count=2**18
+            )
+        )
+
+    """
+    Reconfiguration Code
+
+    below are all functions involved in reconfiguration during environment reset called in the same order. As a user
+    you can change these however you want for your desired task. These functions will only ever be called once in general. In CPU simulation,
+    for some tasks these may need to be called multiple times if you need to swap out object assets. In GPU simulation these will only ever be called once.
+    """
+
+    def _load_agent(self, options: dict):
+        # this code loads the agent into the current scene. You should use it to specify the initial pose(s) of the agent(s)
+        # such that they don't collide with other objects initially
+        super()._load_agent(options, sapien.Pose(p=[0, 0, 0]))
+
+    def _load_scene(self, options: dict):
+        # here you add various objects like actors and articulations. If your task was to push a ball, you may add a dynamic sphere object on the ground
+        pass
+
+    @property
+    def _default_sensor_configs(self):
+        # To customize the sensors that capture images/pointclouds for the environment observations,
+        # simply define a CameraConfig as done below for Camera sensors. You can add multiple sensors by returning a list
+        pose = sapien_utils.look_at(
+            eye=[0.3, 0, 0.6], target=[-0.1, 0, 0.1]
+        )  # sapien_utils.look_at is a utility to get the pose of a camera that looks at a target
+
+        # to see what all the sensors capture in the environment for observations, run env.render_sensors() which returns an rgb array you can visualize
+        return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
+
+    @property
+    def _default_human_render_camera_configs(self):
+        # this is just like _sensor_configs, but for adding cameras used for rendering when you call env.render()
+        # when render_mode="rgb_array" or env.render_rgb_array()
+        # Another feature here is that if there is a camera called render_camera, this is the default view shown initially when a GUI is opened
+        pose = sapien_utils.look_at([0.6, 0.7, 0.6], [0.0, 0.0, 0.35])
+        return [CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)]
+
+    def _setup_sensors(self, options: dict):
+        # default code here will setup all sensors. You can add additional code to change the sensors e.g.
+        # if you want to randomize camera positions
+        return super()._setup_sensors()
+
+    def _load_lighting(self, options: dict):
+        # default code here will setup all lighting. You can add additional code to change the lighting e.g.
+        # if you want to randomize lighting in the scene
+        return super()._load_lighting()
+
+    """
+    Episode Initialization Code
+
+    below are all functions involved in episode initialization during environment reset called in the same order. As a user
+    you can change these however you want for your desired task. Note that these functions are given a env_idx variable.
+
+    `env_idx` is a torch Tensor representing the indices of the parallel environments that are being initialized/reset. This is used
+    to support partial resets where some parallel envs might be reset while others are still running (useful for faster RL and evaluation).
+    Generally you only need to really use it to determine batch sizes via len(env_idx). ManiSkill helps handle internally a lot of masking
+    you might normally need to do when working with GPU simulation. For specific details check out the push_cube.py code
+    """
+
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
+        pass
+
+    """
+    Modifying observations, goal parameterization, and success conditions for your task
+
+    the code below all impact some part of `self.step` function
+    """
+
+    def evaluate(self, obs: Any):
+        # this function is used primarily to determine success and failure of a task, both of which are optional. If a dictionary is returned
+        # containing "success": bool array indicating if the env is in success state or not, that is used as the terminated variable returned by
+        # self.step. Likewise if it contains "fail": bool array indicating the opposite (failure state or not) the same occurs. If both are given
+        # then a logical OR is taken so terminated = success | fail. If neither are given, terminated is always all False.
+        #
+        # You may also include additional keys which will populate the info object returned by self.step and that will be given to
+        # `_get_obs_extra` and `_compute_dense_reward`. Note that as everything is batched, you must return a batched array of
+        # `self.num_envs` booleans (or 0/1 values) for success an dfail as done in the example below
+        return {
+            "success": torch.zeros(self.num_envs, device=self.device, dtype=bool),
+            "fail": torch.zeros(self.num_envs, device=self.device, dtype=bool),
+        }
+
+    def _get_obs_extra(self, info: Dict):
+        # should return an dict of additional observation data for your tasks
+        # this will be included as part of the observation in the "extra" key when obs_mode="state_dict" or any of the visual obs_modes
+        # and included as part of a flattened observation when obs_mode="state". Moreover, you have access to the info object
+        # which is generated by the `evaluate` function above
+        return dict()
+
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+        # you can optionally provide a dense reward function by returning a scalar value here. This is used when reward_mode="dense"
+        # note that as everything is batched, you must return a batch of of self.num_envs rewards as done in the example below.
+        # Moreover, you have access to the info object which is generated by the `evaluate` function above
+        return torch.zeros(self.num_envs, device=self.device)
+
+    def compute_normalized_dense_reward(
+        self, obs: Any, action: torch.Tensor, info: Dict
+    ):
+        # this should be equal to compute_dense_reward / max possible reward
+        max_reward = 1.0
+        return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward
+
+    def get_state_dict(self):
+        # this function is important in order to allow accurate replaying of trajectories. Make sure to specify any
+        # non simulation state related data such as a random 3D goal position you generated
+        # alternatively you can skip this part if the environment's rewards, observations, eval etc. are dependent on simulation data only
+        # e.g. self.your_custom_actor.pose.p will always give you your actor's 3D position
+        state = super().get_state_dict()
+        # state["goal_pos"] = add_your_non_sim_state_data_here
+        return state
+
+    def set_state_dict(self, state):
+        # this function complements get_state and sets any non simulation state related data correctly so the environment behaves
+        # the exact same in terms of output rewards, observations, success etc. should you reset state to a given state and take the same actions
+        self.goal_pos = state["goal_pos"]
+        super().set_state_dict(state)

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/assets/data.py

@@ -0,0 +1,216 @@
+"""
+Asset sources and tooling for managing the assets
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from mani_skill import ASSET_DIR, PACKAGE_ASSET_DIR
+from mani_skill.utils import io_utils
+
+
+@dataclass
+class DataSource:
+    source_type: str
+    """what kind of data is this"""
+    url: Optional[str] = None
+    hf_repo_id: Optional[str] = None
+    github_url: Optional[str] = None
+    target_path: Optional[str] = None
+    """the folder where the file will be downloaded to"""
+    checksum: Optional[str] = None
+    zip_dirname: Optional[str] = None
+    """what to rename a zip files generated directory to"""
+    filename: Optional[str] = None
+    """name to change the downloaded file to. If None, will not change the name"""
+    output_dir: str = ASSET_DIR
+
+
+DATA_SOURCES: Dict[str, DataSource] = {}
+"""Data sources map data source IDs to their respective DataSource objects which contain info on what the data is and where to download it"""
+DATA_GROUPS: Dict[str, List[str]] = {}
+"""Data groups map group ids (typically environment IDs) to a list of data source/group IDs for easy group management. data groups can be done hierarchicaly"""
+
+
+def is_data_source_downloaded(data_source_id: str):
+    data_source = DATA_SOURCES[data_source_id]
+    return os.path.exists(data_source.output_dir / data_source.target_path)
+
+
+def initialize_data_sources():
+    DATA_SOURCES["ycb"] = DataSource(
+        source_type="task_assets",
+        url="https://huggingface.co/datasets/haosulab/ManiSkill2/resolve/main/data/mani_skill2_ycb.zip",
+        target_path="assets/mani_skill2_ycb",
+        checksum="eb6f30642c90203715c178f67bf2288887ef6e7d05a9f3f1e713efcf7c2a541c",
+    )
+    DATA_SOURCES["pick_clutter_ycb_configs"] = DataSource(
+        source_type="task_assets",
+        url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/pick_clutter/ycb_train_5k.json.gz",
+        target_path="tasks/pick_clutter",
+        checksum="70ec176c7036f326ea7813b77f8c03bea9db5960198498957a49b2895a9ec338",
+    )
+    DATA_SOURCES["assembling_kits"] = DataSource(
+        source_type="task_assets",
+        url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/assembling_kits_v1.zip",
+        target_path="tasks/assembling_kits",
+        checksum="e3371f17a07a012edaa3a0b3604fb1577f3fb921876c3d5ed59733dd75a6b4a0",
+    )
+    DATA_SOURCES["panda_avoid_obstacles"] = DataSource(
+        source_type="task_assets",
+        url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/avoid_obstacles/panda_train_2k.json.gz",
+        target_path="tasks/avoid_obstacles",
+        checksum="44dae9a0804172515c290c1f49a1e7e72d76e40201a2c5c7d4a3ccd43b4d5be4",
+    )
+
+    DATA_SOURCES["bridge_v2_real2sim"] = DataSource(
+        source_type="task_assets",
+        url="https://huggingface.co/datasets/haosulab/ManiSkill_bridge_v2_real2sim/resolve/main/bridge_v2_real2sim_dataset.zip",
+        target_path="tasks/bridge_v2_real2sim_dataset",
+        checksum="618512a205b4528cafecdad14b1788ed1130879f3064deb406516ed5b9c5ba92",
+    )
+
+    # ---------------------------------------------------------------------------- #
+    # PartNet-mobility
+    # ---------------------------------------------------------------------------- #
+    category_uids = {}
+    for category in ["cabinet_drawer", "cabinet_door", "chair", "bucket", "faucet"]:
+        model_json = (
+            PACKAGE_ASSET_DIR / f"partnet_mobility/meta/info_{category}_train.json"
+        )
+        model_ids = set(io_utils.load_json(model_json).keys())
+        category_uids[category] = []
+        for model_id in model_ids:
+            uid = f"partnet_mobility/{model_id}"
+            DATA_SOURCES[uid] = DataSource(
+                source_type="objects",
+                url=f"https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/partnet_mobility/dataset/{model_id}.zip",
+                target_path=ASSET_DIR / "partnet_mobility" / "dataset" / model_id,
+            )
+            category_uids[category].append(uid)
+
+    DATA_GROUPS["partnet_mobility_cabinet"] = set(
+        category_uids["cabinet_drawer"] + category_uids["cabinet_door"]
+    )
+    DATA_GROUPS["partnet_mobility_chair"] = category_uids["chair"]
+    DATA_GROUPS["partnet_mobility_bucket"] = category_uids["bucket"]
+    DATA_GROUPS["partnet_mobility_faucet"] = category_uids["faucet"]
+    DATA_GROUPS["partnet_mobility"] = set(
+        category_uids["cabinet_drawer"]
+        + category_uids["cabinet_door"]
+        + category_uids["chair"]
+        + category_uids["bucket"]
+        + category_uids["faucet"]
+    )
+
+    # DATA_GROUPS["OpenCabinetDrawer-v1"] = category_uids["cabinet_drawer"]
+    # DATA_GROUPS["OpenCabinetDoor-v1"] = category_uids["cabinet_door"]
+    # DATA_GROUPS["PushChair-v1"] = category_uids["chair"]
+    # DATA_GROUPS["MoveBucket-v1"] = category_uids["bucket"]
+    # DATA_GROUPS["TurnFaucet-v1"] = category_uids["faucet"]
+
+    # ---------------------------------------------------------------------------- #
+    # Interactable Scene Datasets
+    # ---------------------------------------------------------------------------- #
+    DATA_SOURCES["ReplicaCAD"] = DataSource(
+        source_type="scene",
+        hf_repo_id="haosulab/ReplicaCAD",
+        target_path="scene_datasets/replica_cad_dataset",
+    )
+
+    DATA_SOURCES["ReplicaCADRearrange"] = DataSource(
+        source_type="scene",
+        url="https://huggingface.co/datasets/haosulab/ReplicaCADRearrange/resolve/main/rearrange.zip",
+        target_path="scene_datasets/replica_cad_dataset/rearrange",
+    )
+
+    DATA_SOURCES["AI2THOR"] = DataSource(
+        source_type="scene",
+        url="https://huggingface.co/datasets/haosulab/AI2THOR/resolve/main/ai2thor.zip",
+        target_path="scene_datasets/ai2thor",
+    )
+
+    DATA_SOURCES["RoboCasa"] = DataSource(
+        source_type="scene",
+        url="https://huggingface.co/datasets/haosulab/RoboCasa/resolve/main/robocasa_dataset.zip",
+        target_path="scene_datasets/robocasa_dataset",
+    )
+
+    # Robots
+    DATA_SOURCES["xmate3_robotiq"] = DataSource(
+        source_type="robot",
+        url="https://storage1.ucsd.edu/datasets/ManiSkill2022-assets/xmate3_robotiq.zip",
+        target_path="robots/xmate3_robotiq",
+        checksum="ddda102a20eb41e28a0a501702e240e5d7f4084221a44f580e729f08b7c12d1a",
+    )
+    DATA_SOURCES["ur10e"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-UR10e/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/ur10e",
+    )
+    DATA_SOURCES["anymal_c"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-ANYmalC/archive/refs/tags/v0.1.1.zip",
+        target_path="robots/anymal_c",
+    )
+    DATA_SOURCES["unitree_h1"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-UnitreeH1/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/unitree_h1",
+    )
+    DATA_SOURCES["unitree_g1"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-UnitreeG1/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/unitree_g1",
+    )
+    DATA_SOURCES["unitree_go2"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-UnitreeGo2/archive/refs/tags/v0.1.1.zip",
+        target_path="robots/unitree_go2",
+    )
+    DATA_SOURCES["stompy"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-Stompy/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/stompy",
+    )
+    DATA_SOURCES["widowx250s"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-WidowX250S/archive/refs/tags/v0.2.0.zip",
+        target_path="robots/widowx",
+    )
+    DATA_SOURCES["googlerobot"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-GoogleRobot/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/googlerobot",
+    )
+    DATA_SOURCES["robotiq_2f"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-Robotiq_2F/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/robotiq_2f",
+    )
+    DATA_SOURCES["xarm6"] = DataSource(
+        source_type="robot",
+        url="https://github.com/haosulab/ManiSkill-XArm6/archive/refs/tags/v0.1.0.zip",
+        target_path="robots/xarm6",
+    )
+
+
+def expand_data_group_into_individual_data_source_ids(data_group_id: str):
+    """Expand a data group into a list of individual data source IDs"""
+    uids = []
+
+    def helper(uid):
+        nonlocal uids
+        if uid in DATA_SOURCES:
+            uids.append(uid)
+        elif uid in DATA_GROUPS:
+            [helper(x) for x in DATA_GROUPS[uid]]
+
+    for uid in DATA_GROUPS[data_group_id]:
+        helper(uid)
+    uids = list(set(uids))
+    return uids
+
+
+initialize_data_sources()

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/_mjcf_loader.py

@@ -0,0 +1,921 @@
+"""
+Loader code to import MJCF xml files into SAPIEN
+
+Code partially adapted from https://github.com/NVIDIA/warp/blob/3ed2ceab824b65486c5204d2a7381d37b79fc314/warp/sim/import_mjcf.py
+
+Articulations are known as kinematic trees (defined by <body> tags) in Mujoco. A single .xml file can have multiple articulations
+
+Any <geom> tag in <worldbody> but not a <body> tag will be built as separate static actors if possible. Actors that are not static seem to be defined
+with a free joint under a single body tag.
+
+Warnings of unloadable tags/data can be printed if verbosity is turned on (by default it is off)
+
+Notes:
+    Joint properties relating to the solver, stiffness, actuator, are all not directly imported here
+    and instead must be implemented via a controller like other robots in SAPIEN
+
+    Contact tags are not supported
+
+    Tendons/equality constraints are supported but may not work the same
+
+    The default group of geoms is 0 in mujoco. From docs it appears only group 0 and 2 are rendered by default.
+    This is also by default what the visualizer shows and presumably what image renders show.
+    Any other group is treated as being invisible (e.g. in SAPIEN we do not add visual bodies). SAPIEN does not currently support
+    toggling render groups like Mujoco. Sometimes a MJCF might not follow this and will try and render other groups. In that case the loader supports
+    indicating which other groups to add visual bodies for.
+
+    Ref: https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-geom-group,
+    https://mujoco.readthedocs.io/en/latest/modeling.html#composite-objects (says group 3 is turned off)
+
+    If contype is 0, it means that geom can't collide with anything. We do this by not adding a collision shape at all.
+
+    geoms under worldbody but not body tags are treated as static objects at the moment.
+
+    Useful references:
+    - Collision detection: https://mujoco.readthedocs.io/en/stable/computation/index.html#collision-detection
+
+
+"""
+import math
+import os
+import re
+import xml.etree.ElementTree as ET
+from collections import defaultdict
+from copy import deepcopy
+from dataclasses import dataclass
+from functools import reduce
+from typing import Any, Dict, List, Literal, Tuple, Union
+from xml.etree.ElementTree import Element
+
+import numpy as np
+import sapien
+from sapien import ActorBuilder, Pose
+from sapien.physx import PhysxArticulation, PhysxMaterial
+from sapien.render import RenderMaterial, RenderTexture2D
+from sapien.wrapper.articulation_builder import (
+    ArticulationBuilder,
+    LinkBuilder,
+    MimicJointRecord,
+)
+from transforms3d import euler, quaternions
+
+from mani_skill import logger
+
+
+@dataclass
+class MJCFTexture:
+    name: str
+    type: Literal["skybox", "cube", "2d"]
+    rgb1: list
+    rgb2: list
+    file: str
+
+
+DEFAULT_MJCF_OPTIONS = dict(contact=True)
+
+
+WARNED_ONCE = defaultdict(lambda: False)
+
+
+def _parse_int(attrib, key, default):
+    if key in attrib:
+        return int(attrib[key])
+    else:
+        return default
+
+
+def _parse_float(attrib, key, default):
+    if key in attrib:
+        return float(attrib[key])
+    else:
+        return default
+
+
+def _str_to_float(string: str, delimiter=" "):
+    res = [float(x) for x in string.split(delimiter)]
+    if len(res) == 1:
+        return res[0]
+    return res
+
+
+def _merge_attrib(default_attrib: dict, incoming_attribs: Union[List[dict], dict]):
+    def helper_merge(a: dict, b: dict, path=[]):
+        for key in b:
+            if key in a:
+                if isinstance(a[key], dict) and isinstance(b[key], dict):
+                    helper_merge(a[key], b[key], path + [str(key)])
+                else:
+                    a[key] = b[key]
+            else:
+                a[key] = b[key]
+        return a
+
+    attrib = deepcopy(default_attrib)
+    if isinstance(incoming_attribs, dict):
+        incoming_attribs = [incoming_attribs]
+    reduce(helper_merge, [attrib] + incoming_attribs)
+    return attrib
+
+
+def _parse_vec(attrib, key, default):
+    if key in attrib:
+        out = np.fromstring(attrib[key], sep=" ", dtype=np.float32)
+    else:
+        out = np.array(default, dtype=np.float32)
+    return out
+
+
+def _parse_orientation(attrib, use_degrees, euler_seq):
+    if "quat" in attrib:
+        wxyz = np.fromstring(attrib["quat"], sep=" ")
+        return wxyz
+    if "euler" in attrib:
+        euler_angles = np.fromstring(attrib["euler"], sep=" ")
+        if use_degrees:
+            euler_angles *= np.pi / 180
+        # TODO (stao): support other axes?
+        return np.array(
+            euler.euler2quat(euler_angles[0], -euler_angles[1], euler_angles[2])
+        )
+    if "axisangle" in attrib:
+        axisangle = np.fromstring(attrib["axisangle"], sep=" ")
+        angle = axisangle[3]
+        if use_degrees:
+            angle *= np.pi / 180
+        axis = axisangle[:3] / np.linalg.norm(axisangle[:3])
+        return quaternions.axangle2quat(axis, angle)
+    if "xyaxes" in attrib:
+        xyaxes = np.fromstring(attrib["xyaxes"], sep=" ")
+        xaxis = xyaxes[:3] / np.linalg.norm(xyaxes[:3])
+        zaxis = xyaxes[3:] / np.linalg.norm(xyaxes[:3])
+        yaxis = np.cross(zaxis, xaxis)
+        yaxis = yaxis / np.linalg.norm(yaxis)
+        rot_matrix = np.array([xaxis, yaxis, zaxis]).T
+        return quaternions.mat2quat(rot_matrix)
+    if "zaxis" in attrib:
+        zaxis = np.fromstring(attrib["zaxis"], sep=" ")
+        zaxis = zaxis / np.linalg.norm(zaxis)
+        xaxis = np.cross(np.array([0, 0, 1]), zaxis)
+        xaxis = xaxis / np.linalg.norm(xaxis)
+        yaxis = np.cross(zaxis, xaxis)
+        yaxis = yaxis / np.linalg.norm(yaxis)
+        rot_matrix = np.array([xaxis, yaxis, zaxis]).T
+        return quaternions.mat2quat(rot_matrix)
+    return np.array([1, 0, 0, 0])
+
+
+class MJCFLoader:
+    """
+    Class to load MJCF into SAPIEN.
+    """
+
+    def __init__(self, ignore_classes=["motor"], visual_groups=[0, 2]):
+        self.fix_root_link = True
+        """whether to fix the root link. Note regardless of given XML, the root link is a dummy link this loader
+        creates which makes a number of operations down the line easier. In general this should be False if there is a freejoint for the root body
+        of articulations in the XML and should be true if there are no free joints. At the moment when modelling a robot from Mujoco this
+        must be handled on a case by case basis"""
+
+        self.load_multiple_collisions_from_file = False
+        self.load_nonconvex_collisions = False
+        self.multiple_collisions_decomposition = "none"
+        self.multiple_collisions_decomposition_params = dict()
+
+        self.revolute_unwrapped = False
+        self.scale = 1.0
+
+        self.visual_groups = visual_groups
+
+        self.scene: sapien.Scene = None
+
+        self.ignore_classes = ignore_classes
+
+        # self._material = None
+        # self._patch_radius = 0
+        # self._min_patch_radius = 0
+        self.density = 1000
+        # self._link_material = dict()
+        # self._link_patch_radius = dict()
+        # self._link_min_patch_radius = dict()
+        # self._link_density = dict()
+
+        self._defaults: Dict[str, Element] = dict()
+        self._assets = dict()
+        self._materials = dict()
+        self._textures: Dict[str, MJCFTexture] = dict()
+        self._meshes: Dict[str, Element] = dict()
+
+        self._link2builder: Dict[str, LinkBuilder] = dict()
+        self._link2parent_joint: Dict[str, Any] = dict()
+        self._group_count = 0
+
+    def set_scene(self, scene):
+        self.scene = scene
+        return self
+
+    @staticmethod
+    def _pose_from_origin(origin, scale):
+        origin[:3, 3] = origin[:3, 3] * scale
+        return Pose(origin)
+
+    def _build_geom(
+        self, geom: Element, builder: Union[LinkBuilder, ActorBuilder], defaults
+    ):
+        geom_defaults = defaults
+        if "class" in geom.attrib:
+            geom_class = geom.attrib["class"]
+            ignore_geom = False
+            for pattern in self.ignore_classes:
+                if re.match(pattern, geom_class):
+                    ignore_geom = True
+                    break
+            if ignore_geom:
+                return
+            if geom_class in self._defaults:
+                geom_defaults = _merge_attrib(defaults, self._defaults[geom_class])
+        if "geom" in geom_defaults:
+            geom_attrib = _merge_attrib(geom_defaults["geom"], geom.attrib)
+        else:
+            geom_attrib = geom.attrib
+
+        geom_name = geom_attrib.get("name", "")
+        geom_type = geom_attrib.get("type", "sphere")
+        if "mesh" in geom_attrib:
+            geom_type = "mesh"
+        geom_size = (
+            _parse_vec(geom_attrib, "size", np.array([1.0, 1.0, 1.0])) * self.scale
+        )
+        geom_pos = (
+            _parse_vec(geom_attrib, "pos", np.array([0.0, 0.0, 0.0])) * self.scale
+        )
+        geom_rot = _parse_orientation(geom_attrib, self._use_degrees, self._euler_seq)
+        _parse_float(geom_attrib, "density", self.density)
+        if "material" in geom_attrib:
+            render_material = self._materials[geom_attrib["material"]]
+        else:
+            # use RGBA
+            render_material = RenderMaterial(
+                base_color=_parse_vec(geom_attrib, "rgba", [0.5, 0.5, 0.5, 1])
+            )
+
+        geom_density = _parse_float(geom_attrib, "density", 1000.0)
+
+        # if condim is 1, we can easily model the material's friction
+        condim = _parse_int(geom_attrib, "condim", 3)
+        if condim == 3:
+            friction = _parse_vec(
+                geom_attrib, "friction", np.array([0.3, 0.3, 0.3])
+            )  # maniskill default friction is 0.3
+            # NOTE (stao): we only support sliding friction at the moment. see
+            # https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-geom-friction
+            # we might be able to imitate their torsional frictions via patch radius attributes:
+            # https://nvidia-omniverse.github.io/PhysX/physx/5.4.0/_api_build/class_px_shape.html#_CPPv4N7PxShape23setTorsionalPatchRadiusE6PxReal
+            friction = friction[0]
+            physx_material = PhysxMaterial(
+                static_friction=friction, dynamic_friction=friction, restitution=0
+            )
+        elif condim == 1:
+            physx_material = PhysxMaterial(
+                static_friction=0, dynamic_friction=0, restitution=0
+            )
+        else:
+            physx_material = None
+
+        geom_group = _parse_int(geom_attrib, "group", 0)
+        # See note at top of file for how we handle geom groups
+        has_visual_body = False
+        if geom_group in self.visual_groups:
+            has_visual_body = True
+
+        geom_contype = _parse_int(geom_attrib, "contype", 1)
+        # See note at top of file for how we handle contype / objects without collisions
+        has_collisions = True
+        if geom_contype == 0:
+            has_collisions = False
+
+        t_visual2link = Pose(geom_pos, geom_rot)
+        if geom_type == "sphere":
+            if has_visual_body:
+                builder.add_sphere_visual(
+                    t_visual2link, radius=geom_size[0], material=render_material
+                )
+            if has_collisions:
+                builder.add_sphere_collision(
+                    t_visual2link,
+                    radius=geom_size[0],
+                    material=physx_material,
+                    density=geom_density,
+                )
+        elif geom_type in ["capsule", "cylinder", "box"]:
+            if "fromto" in geom_attrib:
+                geom_fromto = _parse_vec(
+                    geom_attrib, "fromto", (0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
+                )
+
+                start = np.array(geom_fromto[0:3]) * self.scale
+                end = np.array(geom_fromto[3:6]) * self.scale
+                # objects follow a line from start to end.
+
+                # objects are default along x-axis and we rotate accordingly via axis angle.
+                axis = (end - start) / np.linalg.norm(end - start)
+                # TODO this is bugged
+                angle = math.acos(np.dot(axis, np.array([1.0, 0.0, 0.0])))
+                axis = np.cross(axis, np.array([1.0, 0.0, 0.0]))
+                if np.linalg.norm(axis) < 1e-3:
+                    axis = np.array([1, 0, 0])
+                else:
+                    axis = axis / np.linalg.norm(axis)
+
+                geom_pos = (start + end) * 0.5
+                geom_rot = quaternions.axangle2quat(axis, -angle)
+                t_visual2link.set_p(geom_pos)
+                t_visual2link.set_q(geom_rot)
+                geom_radius = geom_size[0]
+                geom_half_length = np.linalg.norm(end - start) * 0.5
+            else:
+                geom_radius = geom_size[0]
+                geom_half_length = geom_size[1]
+                # TODO (stao): oriented along z-axis for capsules whereas boxes are not?
+                if geom_type in ["capsule", "cylinder"]:
+                    t_visual2link = t_visual2link * Pose(
+                        q=euler.euler2quat(0, np.pi / 2, 0)
+                    )
+            if geom_type == "capsule":
+                if has_visual_body:
+                    builder.add_capsule_visual(
+                        t_visual2link,
+                        radius=geom_radius,
+                        half_length=geom_half_length,
+                        material=render_material,
+                        name=geom_name,
+                    )
+                if has_collisions:
+                    builder.add_capsule_collision(
+                        t_visual2link,
+                        radius=geom_radius,
+                        half_length=geom_half_length,
+                        material=physx_material,
+                        density=geom_density,
+                        # name=geom_name,
+                    )
+            elif geom_type == "box":
+                if has_visual_body:
+                    builder.add_box_visual(
+                        t_visual2link,
+                        half_size=geom_size,
+                        material=render_material,
+                        name=geom_name,
+                    )
+                if has_collisions:
+                    builder.add_box_collision(
+                        t_visual2link,
+                        half_size=geom_size,
+                        material=physx_material,
+                        density=geom_density,
+                        # name=geom_name,
+                    )
+            elif geom_type == "cylinder":
+                if has_visual_body:
+                    builder.add_cylinder_visual(
+                        t_visual2link,
+                        radius=geom_radius,
+                        half_length=geom_half_length,
+                        material=render_material,
+                        name=geom_name,
+                    )
+                if has_collisions:
+                    builder.add_cylinder_collision(
+                        t_visual2link,
+                        radius=geom_radius,
+                        half_length=geom_half_length,
+                        material=physx_material,
+                        density=geom_density,
+                        # name=geom_name
+                    )
+
+        elif geom_type == "plane":
+            if not WARNED_ONCE["plane"]:
+                logger.warn(
+                    "Currently ManiSkill does not support loading plane geometries from MJCFs"
+                )
+                WARNED_ONCE["plane"] = True
+        elif geom_type == "ellipsoid":
+            if not WARNED_ONCE["ellipsoid"]:
+                logger.warn(
+                    "Currently ManiSkill does not support loading ellipsoid geometries from MJCFs"
+                )
+                WARNED_ONCE["ellipsoid"] = True
+        elif geom_type == "mesh":
+            mesh_name = geom_attrib.get("mesh")
+            mesh_attrib = self._meshes[mesh_name].attrib
+            mesh_scale = self.scale * np.array(
+                _parse_vec(mesh_attrib, "scale", np.array([1, 1, 1]))
+            )
+            # TODO refquat
+            mesh_file = os.path.join(self._mesh_dir, mesh_attrib["file"])
+            if has_visual_body:
+                builder.add_visual_from_file(
+                    mesh_file,
+                    pose=t_visual2link,
+                    scale=mesh_scale,
+                    material=render_material,
+                )
+            if has_collisions:
+                if self.load_multiple_collisions_from_file:
+                    builder.add_multiple_convex_collisions_from_file(
+                        mesh_file,
+                        pose=t_visual2link,
+                        scale=mesh_scale,
+                        material=physx_material,
+                        density=geom_density,
+                    )
+                else:
+                    builder.add_convex_collision_from_file(
+                        mesh_file,
+                        pose=t_visual2link,
+                        scale=mesh_scale,
+                        material=physx_material,
+                        density=geom_density,
+                    )
+        elif geom_type == "sdf":
+            raise NotImplementedError("SDF geom type not supported at the moment")
+        elif geom_type == "hfield":
+            raise NotImplementedError("Height fields are not supported at the moment")
+
+    def _build_link(
+        self, body: Element, body_attrib, link_builder: LinkBuilder, defaults
+    ):
+        """sets inertial, visual/collision shapes"""
+        # inertial
+        # TODO (stao)
+        # if (
+        #     link.inertial
+        #     and link.inertial.mass != 0
+        #     and not np.array_equal(link.inertial.inertia, np.zeros((3, 3)))
+        # ):
+        #     t_inertial2link = self._pose_from_origin(link.inertial.origin, self.scale)
+        #     mass = link.inertial.mass
+        #     inertia = link.inertial.inertia
+
+        #     if np.array_equal(np.diag(np.diag(inertia)), inertia):
+        #         eigs = np.diag(inertia)
+        #         vecs = np.eye(3)
+        #     else:
+        #         eigs, vecs = np.linalg.eigh(inertia)
+        #         if np.linalg.det(vecs) < 0:
+        #             vecs[:, 2] = -vecs[:, 2]
+
+        #     assert all([x > 0 for x in eigs]), "invalid moment of inertia"
+
+        #     t_inertia2inertial = np.eye(4)
+        #     t_inertia2inertial[:3, :3] = vecs
+        #     t_inertia2inertial = Pose(t_inertia2inertial)
+
+        #     t_inertial2link = t_inertial2link * t_inertia2inertial
+        #     scale3 = self.scale**3
+        #     scale5 = self.scale**5
+        #     link_builder.set_mass_and_inertia(
+        #         mass * scale3, t_inertial2link, scale5 * eigs
+        #     )
+
+        # go through each geometry of the body
+        for geo_count, geom in enumerate(body.findall("geom")):
+            self._build_geom(geom, link_builder, defaults)
+
+    def _parse_texture(self, texture: Element):
+        """Parse MJCF textures to then be referenced by materials: https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-texture
+
+        NOTE:
+        - Procedural texture generation is currently not supported.
+        - Different texture types are not really supported
+        """
+        name = texture.get("name")
+        file = texture.get("file")
+        self._textures[name] = MJCFTexture(
+            name=name,
+            type=texture.get("type"),
+            rgb1=texture.get("rgb1"),
+            rgb2=texture.get("rgb2"),
+            file=os.path.join(self._mesh_dir, file) if file else None,
+        )
+
+    def _parse_material(self, material: Element):
+        """Parse MJCF materials in asset to sapien render materials"""
+        name = material.get("name")
+        texture = None
+        if material.get("texture") in self._textures:
+            texture = self._textures[material.get("texture")]
+
+        # NOTE: Procedural texture generation is currently not supported.
+        # Defaults from https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-material
+        em_val = _parse_float(material.attrib, "emission", 0)
+        rgba = np.array(_parse_vec(material.attrib, "rgba", [1, 1, 1, 1]))
+        render_material = RenderMaterial(
+            emission=[rgba[0] * em_val, rgba[1] * em_val, rgba[2] * em_val, 1],
+            base_color=rgba,
+            specular=_parse_float(material.attrib, "specular", 0),
+            # TODO (stao): double check below 2 properties are right
+            roughness=1 - _parse_float(material.attrib, "reflectance", 0),
+            metallic=_parse_float(material.attrib, "shininess", 0.5),
+        )
+        if texture is not None and texture.file is not None:
+            render_material.base_color_texture = RenderTexture2D(filename=texture.file)
+        self._materials[name] = render_material
+
+    def _parse_mesh(self, mesh: Element):
+        """Parse MJCF mesh data in asset"""
+        # Vertex, normal, texcoord are not supported, file is required
+        file = mesh.get("file")
+        assert (
+            file is not None
+        ), "Mesh file not provided. While Mujoco allows file to be optional, for loading into SAPIEN this is not optional"
+        name = mesh.get("name", os.path.splitext(file)[0])
+        self._meshes[name] = mesh
+
+    @property
+    def _root_default(self):
+        if "__root__" not in self._defaults:
+            return {}
+        return self._defaults["__root__"]
+
+    def _parse_default(self, node: Element, parent: Element):
+        """Parse a MJCF default attribute. https://mujoco.readthedocs.io/en/stable/modeling.html#default-settings explains how it works"""
+        class_name = "__root__"
+        if node.tag == "default":
+            if "class" in node.attrib:
+                class_name = node.attrib["class"]
+            if parent is not None and "class" in parent.attrib:
+                self._defaults[class_name] = deepcopy(
+                    self._defaults[parent.attrib["class"]]
+                )
+            else:
+                self._defaults[class_name] = {}
+        for child in node:
+            if child.tag == "default":
+                self._parse_default(child, node)
+            else:
+                if child.tag in self._defaults[class_name]:
+                    self._defaults[class_name][child.tag] = _merge_attrib(
+                        self._defaults[class_name][child.tag], child.attrib
+                    )
+                else:
+                    self._defaults[class_name][child.tag] = child.attrib
+
+    def _parse_body(
+        self,
+        body: Element,
+        parent: LinkBuilder,
+        incoming_defaults: dict,
+        builder: ArticulationBuilder,
+    ):
+        body_class = body.get("childclass")
+        if body_class is None:
+            defaults = incoming_defaults
+        else:
+            for pattern in self.ignore_classes:
+                if re.match(pattern, body_class):
+                    return
+            defaults = _merge_attrib(incoming_defaults, self._defaults[body_class])
+
+        if "body" in defaults:
+            body_attrib = _merge_attrib(defaults["body"], body.attrib)
+        else:
+            body_attrib = body.attrib
+
+        body_name = body_attrib["name"]
+        body_pos = _parse_vec(body_attrib, "pos", (0.0, 0.0, 0.0))
+        body_ori = _parse_orientation(
+            body_attrib, use_degrees=self._use_degrees, euler_seq=self._euler_seq
+        )
+
+        body_pos *= self.scale
+        body_pose = Pose(body_pos, q=body_ori)
+
+        link_builder = parent
+
+        joints = body.findall("joint")
+        # if body has no joints, it is a fixed joint
+        if len(joints) == 0:
+            joints = [ET.Element("joint", attrib=dict(type="fixed"))]
+        for i, joint in enumerate(joints):
+            # note there can be multiple joints here. We create some dummy links to simulate that
+            incoming_attributes = []
+            if "joint" in defaults:
+                incoming_attributes.append(defaults["joint"])
+            if "class" in joint.attrib:
+                incoming_attributes.append(
+                    self._defaults[joint.attrib["class"]]["joint"]
+                )
+            incoming_attributes.append(joint.attrib)
+            joint_attrib = _merge_attrib(dict(), incoming_attributes)
+
+            # build the link
+            link_builder = builder.create_link_builder(parent=link_builder)
+            link_builder.set_joint_name(joint_attrib.get("name", ""))
+            if i == len(joints) - 1:
+                link_builder.set_name(f"{body_name}")
+                # the last link is the "real" one, the rest are dummy links to support multiple joints acting on a link
+                self._build_link(body, body_attrib, link_builder, defaults)
+            else:
+                link_builder.set_name(f"{body_name}_dummy_{i}")
+            self._link2builder[link_builder.name] = link_builder
+
+            joint_type = joint_attrib.get("type", "hinge")
+            joint_pos = np.array(_parse_vec(joint_attrib, "pos", [0, 0, 0]))
+            t_joint2parent = Pose()
+            if i == 0:
+                t_joint2parent = body_pose
+
+            friction = _parse_float(joint_attrib, "frictionloss", 0)
+            damping = _parse_float(joint_attrib, "damping", 0)
+
+            # compute joint axis and relative transformations
+            axis = _parse_vec(joint_attrib, "axis", [0.0, 0.0, 0.0])
+            axis_norm = np.linalg.norm(axis)
+            if axis_norm < 1e-3:
+                axis = np.array([1.0, 0.0, 0.0])
+            else:
+                axis /= axis_norm
+
+            if abs(axis @ [1.0, 0.0, 0.0]) > 0.9:
+                axis1 = np.cross(axis, [0.0, 0.0, 1.0])
+                axis1 /= np.linalg.norm(axis1)
+            else:
+                axis1 = np.cross(axis, [1.0, 0.0, 0.0])
+                axis1 /= np.linalg.norm(axis1)
+            axis2 = np.cross(axis, axis1)
+            t_axis2joint = np.eye(4)
+            t_axis2joint[:3, 3] = joint_pos
+            t_axis2joint[:3, 0] = axis
+            t_axis2joint[:3, 1] = axis1
+            t_axis2joint[:3, 2] = axis2
+            t_axis2joint = Pose(t_axis2joint)
+            t_axis2parent = t_joint2parent * t_axis2joint
+
+            limited = joint_attrib.get("limited", "auto")
+            if limited == "auto":
+                if "range" in joint_attrib:
+                    limited = True
+                else:
+                    limited = False
+            elif limited == "true":
+                limited = True
+            else:
+                limited = False
+
+            # set the joint properties to create it
+            if joint_type == "hinge":
+                if limited:
+                    joint_limits = _parse_vec(joint_attrib, "range", [0, 0])
+                    if self._use_degrees:
+                        joint_limits = np.deg2rad(joint_limits)
+                    link_builder.set_joint_properties(
+                        "revolute_unwrapped",
+                        [joint_limits],
+                        t_axis2parent,
+                        t_axis2joint,
+                        friction,
+                        damping,
+                    )
+                else:
+                    link_builder.set_joint_properties(
+                        "revolute",
+                        [[-np.inf, np.inf]],
+                        t_axis2parent,
+                        t_axis2joint,
+                        friction,
+                        damping,
+                    )
+            elif joint_type == "slide":
+                if limited:
+                    limits = [_parse_vec(joint_attrib, "range", [0, 0]) * self.scale]
+                else:
+                    limits = [[-np.inf, np.inf]]
+                link_builder.set_joint_properties(
+                    "prismatic",
+                    limits,
+                    t_axis2parent,
+                    t_axis2joint,
+                    friction,
+                    damping,
+                )
+            elif joint_type == "fixed":
+                link_builder.set_joint_properties(
+                    "fixed",
+                    [],
+                    t_axis2parent,
+                    t_axis2joint,
+                    friction,
+                    damping,
+                )
+
+        # ensure adjacent links do not collide. Normally SAPIEN does this
+        # but we often create dummy links to support multiple joints between two link functionality
+        # that mujoco has so it must be done here.
+        if parent is not None:
+            parent.collision_groups[2] |= 1 << (self._group_count)
+            link_builder.collision_groups[2] |= 1 << (self._group_count)
+            self._group_count += 1
+
+        for child in body.findall("body"):
+            self._parse_body(child, link_builder, defaults, builder)
+
+    def _parse_constraint(self, constraint: Element):
+        joint_elems = []
+        for joint in constraint.findall("joint"):
+            joint_elems.append(joint)
+        return MimicJointRecord(
+            joint_elems[0].attrib["joint"],
+            joint_elems[1].attrib["joint"],
+            1,
+            0
+            # joint.mimic.multiplier,
+            # joint.mimic.offset,
+        )
+
+    def _parse_mjcf(
+        self, mjcf_string: str
+    ) -> Tuple[List[ArticulationBuilder], List[ActorBuilder], None]:
+        """Helper function for self.parse"""
+        xml: Element = ET.fromstring(mjcf_string.encode("utf-8"))
+        self.xml = xml
+        # handle includes
+        for include in xml.findall("include"):
+            include_file = include.attrib["file"]
+            with open(os.path.join(self.mjcf_dir, include_file), "r") as f:
+                include_file_str = f.read()
+                include_xml = ET.fromstring(include_file_str.encode("utf-8"))
+            for child in include_xml:
+                xml.append(child)
+
+        self._use_degrees = True  # angles are in degrees by default
+        self._mjcf_options = DEFAULT_MJCF_OPTIONS
+        self._euler_seq = [1, 2, 3]  # XYZ by default
+
+        ### Parse compiler options ###
+        compiler = xml.find("compiler")
+        if compiler is not None:
+            self._use_degrees = (
+                compiler.attrib.get("angle", "degree").lower() == "degree"
+            )
+            self._euler_seq = [
+                "xyz".index(c) + 1
+                for c in compiler.attrib.get("eulerseq", "xyz").lower()
+            ]
+            self._mesh_dir = compiler.attrib.get("meshdir", ".")
+        else:
+            self._mesh_dir = "."
+        self._mesh_dir = os.path.join(self.mjcf_dir, self._mesh_dir)
+
+        ### Parse options/flags ###
+        option = xml.find("option")
+        if option is not None:
+            for flag in option.findall("flag"):
+                update_dict = dict()
+                for k, v in flag.attrib.items():
+                    update_dict[k] = True if v == "enable" else False
+                self._mjcf_options.update(update_dict)
+
+        ### Parse assets ###
+        for asset in xml.findall("asset"):
+            for texture in asset.findall("texture"):
+                self._parse_texture(texture)
+            for material in asset.findall("material"):
+                self._parse_material(material)
+            for mesh in asset.findall("mesh"):
+                self._parse_mesh(mesh)
+
+        ### Parse defaults ###
+        for default in xml.findall("default"):
+            self._parse_default(default, None)
+
+        ### Parse Kinematic Trees / Articulations in World Body ###
+
+        # NOTE (stao): For now we assume there is only one articulation. Some setups like Aloha 2 are technically 2 articulations
+        # but you can treat it as a single one anyway
+        articulation_builders: List[ArticulationBuilder] = []
+        actor_builders: List[ActorBuilder] = []
+        for i, body in enumerate(xml.find("worldbody").findall("body")):
+            # determine first if this body is really an articulation or a actor
+            has_freejoint = body.find("freejoint") is not None
+
+            def has_joint(body):
+                if body.find("joint") is not None:
+                    return True
+                for child in body.findall("body"):
+                    if has_joint(child):
+                        return True
+                return False
+
+            is_articulation = has_joint(body) or has_freejoint
+            # <body> tag refers to an artciulation in physx only if there is another body tag inside it
+            if is_articulation:
+                builder = self.scene.create_articulation_builder()
+                articulation_builders.append(builder)
+                dummy_root_link = builder.create_link_builder(None)
+                dummy_root_link.name = f"dummy_root_{i}"
+
+                # Check if the body tag only contains another body tag and nothing else
+                body_children = list(body)
+                tag_counts = defaultdict(int)
+                for child in body_children:
+                    tag_counts[child.tag] += 1
+                if (
+                    tag_counts["body"] == 1
+                    and "geom" not in tag_counts
+                    and "joint" not in tag_counts
+                ):
+                    # If so, skip the current body and continue with its child
+                    body = body.find("body")
+                self._parse_body(body, dummy_root_link, self._root_default, builder)
+
+                # handle free joints
+                fix_root_link = not has_freejoint
+                if fix_root_link:
+                    dummy_root_link.set_joint_properties(
+                        type="fixed",
+                        limits=None,
+                        pose_in_parent=Pose(),
+                        pose_in_child=Pose(),
+                    )
+            else:
+                builder = self.scene.create_actor_builder()
+                body_type = "dynamic" if has_freejoint else "static"
+                actor_builders.append(builder)
+                # NOTE that mujoco supports nested body tags to define groups of geoms
+                cur_body = body
+                while cur_body is not None:
+                    for i, geom in enumerate(cur_body.findall("geom")):
+                        self._build_geom(geom, builder, self._root_default)
+                        builder.set_name(geom.get("name", ""))
+                        builder.set_physx_body_type(body_type)
+                    cur_body = cur_body.find("body")
+
+        ### Parse geoms in World Body ###
+        # These can't have freejoints so they can't be dynamic
+        for i, geom in enumerate(xml.find("worldbody").findall("geom")):
+            builder = self.scene.create_actor_builder()
+            actor_builders.append(builder)
+            self._build_geom(geom, builder, self._root_default)
+            builder.set_name(geom.get("name", ""))
+            builder.set_physx_body_type("static")
+
+        ### Parse contact and exclusions ###
+        for contact in xml.findall("contact"):
+            # TODO
+            pass
+
+        ### Parse equality constraints ###
+        # tendon = xml.find("tendon")
+        # if tendon is not None:
+        #     # TODO (stao): unclear if this actually works
+        #     for constraint in tendon.findall("fixed"):
+        #         record = self._parse_constraint(constraint)
+        #         builder.mimic_joint_records.append(record)
+
+        if not self._mjcf_options["contact"]:
+            # means to disable all contacts
+            for actor in actor_builders:
+                actor.collision_groups[2] |= 1 << 1
+            for art in articulation_builders:
+                for link in art.link_builders:
+                    link.collision_groups[2] |= 1 << 1
+
+        return articulation_builders, actor_builders, []
+
+    def parse(self, mjcf_file: str, package_dir=None):
+        """Parses a given MJCF file into articulation builders and actor builders and sensor configs"""
+        self.package_dir = package_dir
+        self.mjcf_dir = os.path.dirname(mjcf_file)
+
+        with open(mjcf_file, "r") as f:
+            mjcf_string = f.read()
+
+        return self._parse_mjcf(mjcf_string)
+
+    def load(self, mjcf_file: str, package_dir=None):
+        """Parses a given mjcf .xml file and builds all articulations and actors"""
+        articulation_builders, actor_builders, cameras = self.parse(
+            mjcf_file, package_dir
+        )
+
+        articulations: List[PhysxArticulation] = []
+        for b in articulation_builders:
+            articulations.append(b.build())
+
+        actors = []
+        for b in actor_builders:
+            actors.append(b.build())
+
+        # TODO (stao): how does mjcf specify sensors?
+        # name2entity = dict()
+        # for a in articulations:
+        #     for l in a.links:
+        #         name2entity[l.name] = l.entity
+
+        # for a in actors:
+        #     name2entity[a.name] = a
+        return articulations[0]
+
+    # TODO (stao): function to also load the scene in?
+    # TODO (stao): function to load camera configs?

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/actor_builder.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+
+import numpy as np
+import sapien
+import sapien.physx as physx
+import torch
+from sapien import ActorBuilder as SAPIENActorBuilder
+from sapien.wrapper.coacd import do_coacd
+
+from mani_skill import logger
+from mani_skill.utils import common
+from mani_skill.utils.structs.actor import Actor
+from mani_skill.utils.structs.pose import Pose, to_sapien_pose
+
+if TYPE_CHECKING:
+    from mani_skill.envs.scene import ManiSkillScene
+
+
+class ActorBuilder(SAPIENActorBuilder):
+    """
+    ActorBuilder class to flexibly build actors in both CPU and GPU simulations.
+    This directly inherits the original flexible ActorBuilder from sapien and changes the build functions to support a batch of scenes and return a batch of Actors
+    """
+
+    scene: ManiSkillScene
+
+    def __init__(self):
+        super().__init__()
+        self.initial_pose = None
+        self.scene_idxs = None
+        self._allow_overlapping_plane_collisions = False
+        self._plane_collision_poses = set()
+        self._procedural_shapes = []
+        """procedurally generated shapes to attach"""
+
+    def set_scene_idxs(
+        self,
+        scene_idxs: Optional[
+            Union[List[int], Sequence[int], torch.Tensor, np.ndarray]
+        ] = None,
+    ):
+        """
+        Set a list of scene indices to build this object in. Cannot be used in conjunction with scene mask
+        """
+        self.scene_idxs = scene_idxs
+        return self
+
+    def set_allow_overlapping_plane_collisions(self, v: bool):
+        """Set whether or not to permit allowing overlapping plane collisions. In general if you are creating an Actor with a plane collision that is parallelized across multiple
+        sub-scenes, you only need one of those collision shapes. If you add multiple, it will cause the simulation to slow down significantly. By default this is set to False
+        """
+        self._allow_overlapping_plane_collisions = v
+        return self
+
+    def build_physx_component(self, link_parent=None):
+        for r in self.collision_records:
+            assert isinstance(r.material, physx.PhysxMaterial)
+
+        if self.physx_body_type == "dynamic":
+            component = physx.PhysxRigidDynamicComponent()
+        elif self.physx_body_type == "kinematic":
+            component = physx.PhysxRigidDynamicComponent()
+            component.kinematic = True
+        elif self.physx_body_type == "static":
+            component = physx.PhysxRigidStaticComponent()
+        elif self.physx_body_type == "link":
+            component = physx.PhysxArticulationLinkComponent(link_parent)
+        else:
+            raise Exception(f"invalid physx body type [{self.physx_body_type}]")
+
+        for r in self.collision_records:
+            try:
+                if r.type == "plane":
+                    # skip adding plane collisions if we already added one.
+                    pose_key = (tuple(r.pose.p), tuple(r.pose.q))
+                    if (
+                        self._allow_overlapping_plane_collisions
+                        or pose_key not in self._plane_collision_poses
+                    ):
+                        shape = physx.PhysxCollisionShapePlane(
+                            material=r.material,
+                        )
+                        shapes = [shape]
+                        self._plane_collision_poses.add(pose_key)
+                    else:
+                        continue
+                elif r.type == "box":
+                    shape = physx.PhysxCollisionShapeBox(
+                        half_size=r.scale, material=r.material
+                    )
+                    shapes = [shape]
+                elif r.type == "capsule":
+                    shape = physx.PhysxCollisionShapeCapsule(
+                        radius=r.radius,
+                        half_length=r.length,
+                        material=r.material,
+                    )
+                    shapes = [shape]
+                elif r.type == "cylinder":
+                    shape = physx.PhysxCollisionShapeCylinder(
+                        radius=r.radius,
+                        half_length=r.length,
+                        material=r.material,
+                    )
+                    shapes = [shape]
+                elif r.type == "sphere":
+                    shape = physx.PhysxCollisionShapeSphere(
+                        radius=r.radius,
+                        material=r.material,
+                    )
+                    shapes = [shape]
+                elif r.type == "convex_mesh":
+                    shape = physx.PhysxCollisionShapeConvexMesh(
+                        filename=r.filename,
+                        scale=r.scale,
+                        material=r.material,
+                    )
+                    shapes = [shape]
+                elif r.type == "nonconvex_mesh":
+                    shape = physx.PhysxCollisionShapeTriangleMesh(
+                        filename=r.filename,
+                        scale=r.scale,
+                        material=r.material,
+                    )
+                    shapes = [shape]
+                elif r.type == "multiple_convex_meshes":
+                    if r.decomposition == "coacd":
+                        params = r.decomposition_params
+                        if params is None:
+                            params = dict()
+
+                        filename = do_coacd(r.filename, **params)
+                    else:
+                        filename = r.filename
+
+                    shapes = physx.PhysxCollisionShapeConvexMesh.load_multiple(
+                        filename=filename,
+                        scale=r.scale,
+                        material=r.material,
+                    )
+                else:
+                    raise RuntimeError(f"invalid collision shape type [{r.type}]")
+            except RuntimeError:
+                # ignore runtime error (e.g., failed to cooke mesh)
+                continue
+
+            for shape in shapes:
+                shape.local_pose = r.pose
+                shape.set_collision_groups(self.collision_groups)
+                shape.set_density(r.density)
+                shape.set_patch_radius(r.patch_radius)
+                shape.set_min_patch_radius(r.min_patch_radius)
+                component.attach(shape)
+
+        if hasattr(self, "_auto_inertial"):
+            if not self._auto_inertial and self.physx_body_type != "kinematic":
+                component.mass = self._mass
+                component.cmass_local_pose = self._cmass_local_pose
+                component.inertia = self._inertia
+
+        return component
+
+    def build_dynamic(self, name):
+        self.set_physx_body_type("dynamic")
+        return self.build(name=name)
+
+    def build_kinematic(self, name):
+        self.set_physx_body_type("kinematic")
+        return self.build(name=name)
+
+    def build_static(self, name):
+        self.set_physx_body_type("static")
+        return self.build(name=name)
+
+    def build_entity(self):
+        """
+        build the raw sapien entity. Modifies original SAPIEN function to accept new procedurally generated render components
+        """
+        entity = sapien.Entity()
+        if self.visual_records or len(self._procedural_shapes) > 0:
+            render_component = self.build_render_component()
+            for shape in self._procedural_shapes:
+                render_component.attach(shape)
+            entity.add_component(render_component)
+        entity.add_component(self.build_physx_component())
+        entity.name = self.name
+        return entity
+
+    def build(self, name):
+        """
+        Build the actor with the given name.
+
+        Different to the original SAPIEN API, a unique name is required here.
+        """
+        self.set_name(name)
+
+        assert (
+            self.name is not None
+            and self.name != ""
+            and self.name not in self.scene.actors
+        ), "built actors in ManiSkill must have unique names and cannot be None or empty strings"
+
+        num_actors = self.scene.num_envs
+        if self.scene_idxs is not None:
+            self.scene_idxs = common.to_tensor(
+                self.scene_idxs, device=self.scene.device
+            ).to(torch.int)
+        else:
+            self.scene_idxs = torch.arange((self.scene.num_envs), dtype=int)
+        num_actors = len(self.scene_idxs)
+
+        if self.initial_pose is None:
+            logger.warn(
+                f"No initial pose set for actor builder of {self.name}, setting to default pose q=[1,0,0,0], p=[0,0,0]. Not setting reasonable initial poses may slow down simulation, see https://github.com/haosulab/ManiSkill/issues/421."
+            )
+            self.initial_pose = Pose.create(sapien.Pose())
+        else:
+            self.initial_pose = Pose.create(self.initial_pose, device=self.scene.device)
+
+        initial_pose_b = self.initial_pose.raw_pose.shape[0]
+        assert initial_pose_b == 1 or initial_pose_b == num_actors
+        initial_pose_np = common.to_numpy(self.initial_pose.raw_pose)
+        if initial_pose_b == 1:
+            initial_pose_np = initial_pose_np.repeat(num_actors, axis=0)
+        if self.scene.parallel_in_single_scene:
+            initial_pose_np[:, :3] += self.scene.scene_offsets_np[
+                common.to_numpy(self.scene_idxs)
+            ]
+        entities = []
+
+        for i, scene_idx in enumerate(self.scene_idxs):
+            if self.scene.parallel_in_single_scene:
+                sub_scene = self.scene.sub_scenes[0]
+            else:
+                sub_scene = self.scene.sub_scenes[scene_idx]
+            entity = self.build_entity()
+            # prepend scene idx to entity name to indicate which sub-scene it is in
+            entity.name = f"scene-{scene_idx}_{self.name}"
+            # set pose before adding to scene
+            entity.pose = to_sapien_pose(initial_pose_np[i])
+            sub_scene.add_entity(entity)
+            entities.append(entity)
+        actor = Actor.create_from_entities(entities, self.scene, self.scene_idxs)
+
+        # if it is a static body type and this is a GPU sim but we are given a single initial pose, we repeat it for the purposes of observations
+        if (
+            self.physx_body_type == "static"
+            and initial_pose_b == 1
+            and self.scene.gpu_sim_enabled
+        ):
+            actor.initial_pose = Pose.create(
+                self.initial_pose.raw_pose.repeat(num_actors, 1)
+            )
+        else:
+            actor.initial_pose = self.initial_pose
+        self.scene.actors[self.name] = actor
+        self.scene.add_to_state_dict_registry(actor)
+        return actor
+
+    """
+    additional procedurally generated visual meshes
+    """
+
+    def add_plane_repeated_visual(
+        self,
+        pose: sapien.Pose = sapien.Pose(),
+        half_size: List[float] = [5, 5],
+        mat: sapien.render.RenderMaterial = None,
+        texture_repeat: List[float] = [1, 1],
+    ):
+        """Procedurally generateds a repeated 2D texture. Works similarly to https://mujoco.readthedocs.io/en/stable/XMLreference.html#asset-material-texrepeat
+
+        currently this always adds a back face
+
+        Args:
+            texture_repeat: the number of times to repeat the texture in each direction.
+        """
+        floor_width = half_size[0] * 2
+        floor_length = half_size[1] * 2
+        floor_width = int(np.ceil(floor_width))
+        floor_length = int(np.ceil(floor_length))
+
+        # generate a grid of right triangles that form 1x1 meter squares centered at (0, 0, 0)
+        # for squares on the edge we cut them off
+
+        # floor_length = floor_width if floor_length is None else floor_length
+        num_verts = (floor_width + 1) * (floor_length + 1)
+        vertices = np.zeros((int(num_verts), 3))
+        floor_half_width = floor_width / 2
+        floor_half_length = floor_length / 2
+        xrange = np.arange(start=-floor_half_width, stop=floor_half_width + 1)
+        yrange = np.arange(start=-floor_half_length, stop=floor_half_length + 1)
+        xx, yy = np.meshgrid(xrange, yrange)
+        xys = np.stack((xx, yy), axis=2).reshape(-1, 2)
+        vertices[:, 0] = xys[:, 0]
+        vertices[:, 1] = xys[:, 1]
+        normals = np.zeros((len(vertices), 3))
+        normals[:, 2] = -1
+
+        # the number of times the texture repeats essentially.
+        uvs = np.zeros((len(vertices), 2))
+        # texture_repeat = [1,1]
+        uvs[:, 0] = xys[:, 0] * texture_repeat[0]
+        uvs[:, 1] = xys[:, 1] * texture_repeat[1]
+
+        # TODO: This is fast but still two for loops which is a little annoying
+        triangles = []
+        for i in range(floor_length):
+            triangles.append(
+                np.stack(
+                    [
+                        np.arange(floor_width) + i * (floor_width + 1),
+                        np.arange(floor_width)
+                        + 1
+                        + floor_width
+                        + i * (floor_width + 1),
+                        np.arange(floor_width) + 1 + i * (floor_width + 1),
+                    ],
+                    axis=1,
+                )
+            )
+        for i in range(floor_length):
+            triangles.append(
+                np.stack(
+                    [
+                        np.arange(floor_width)
+                        + 1
+                        + floor_width
+                        + i * (floor_width + 1),
+                        np.arange(floor_width)
+                        + floor_width
+                        + 2
+                        + i * (floor_width + 1),
+                        np.arange(floor_width) + 1 + i * (floor_width + 1),
+                    ],
+                    axis=1,
+                )
+            )
+        triangles = np.concatenate(triangles)
+
+        # vertices: (N, 3)
+        # triangles: (M, 3) of index triplets referencing vertices
+        # normals: (N, 3) normals of the vertices. These should all face the same direction
+        # uvs: (N, 2) uv coordinates for the vertices
+        if half_size[0] < floor_half_width:
+            diff = floor_half_width - half_size[0]
+            for sign in [-1, 1]:
+                mask = vertices[:, 0] == floor_half_width * sign
+                vertices[mask, 0] = half_size[0] * sign
+                uvs[mask, 0] -= 1 * diff * sign * texture_repeat[0]
+
+        if half_size[1] < floor_half_length:
+            diff = floor_half_length - half_size[1]
+            for sign in [-1, 1]:
+                mask = vertices[:, 1] == floor_half_length * sign
+                vertices[mask, 1] = half_size[1] * sign
+                uvs[mask, 1] -= diff * sign * texture_repeat[1]
+        shape = sapien.render.RenderShapeTriangleMesh(
+            vertices=vertices,
+            triangles=triangles,
+            normals=normals,
+            uvs=uvs,
+            material=mat,
+        )
+        shape.local_pose = pose
+        self._procedural_shapes.append(shape)

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/ground.py

@@ -0,0 +1,107 @@
+"""
+Useful utilities for creating the ground of a scene
+"""
+
+from __future__ import annotations
+
+import os.path as osp
+from typing import TYPE_CHECKING
+
+import numpy as np
+import sapien
+import sapien.render
+
+if TYPE_CHECKING:
+    from mani_skill.envs.scene import ManiSkillScene
+
+
+def build_ground(
+    scene: ManiSkillScene,
+    floor_width: int = 100,
+    floor_length: int = None,
+    xy_origin: tuple = (0, 0),
+    altitude=0,
+    name="ground",
+    texture_file=osp.join(osp.dirname(__file__), "assets/grid_texture.png"),
+    texture_square_len=4,
+    mipmap_levels=4,
+    add_collision=True,
+):
+    """Procedurally creates a checkered floor given a floor width in meters.
+
+    Note that this function runs slower as floor width becomes larger, but in general this function takes no more than 0.05s to run
+    and usually is never run more than once as it is for building a scene, not loading.
+    """
+    ground = scene.create_actor_builder()
+    if add_collision:
+        ground.add_plane_collision(
+            sapien.Pose(p=[0, 0, altitude], q=[0.7071068, 0, -0.7071068, 0]),
+        )
+    ground.initial_pose = sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0])
+    if scene.parallel_in_single_scene:
+        # when building a ground and using a parallel render in the GUI, we want to only build one ground visual+collision plane
+        ground.set_scene_idxs([0])
+    actor = ground.build_static(name=name)
+
+    # generate a grid of right triangles that form 1x1 meter squares centered at (0, 0, 0)
+    floor_length = floor_width if floor_length is None else floor_length
+    num_verts = (floor_width + 1) * (floor_length + 1)
+    vertices = np.zeros((num_verts, 3))
+    floor_half_width = floor_width / 2
+    floor_half_length = floor_length / 2
+    xrange = np.arange(start=-floor_half_width, stop=floor_half_width + 1)
+    yrange = np.arange(start=-floor_half_length, stop=floor_half_length + 1)
+    xx, yy = np.meshgrid(xrange, yrange)
+    xys = np.stack((yy, xx), axis=2).reshape(-1, 2)
+    vertices[:, 0] = xys[:, 0] + xy_origin[0]
+    vertices[:, 1] = xys[:, 1] + xy_origin[1]
+    vertices[:, 2] = altitude
+    normals = np.zeros((len(vertices), 3))
+    normals[:, 2] = 1
+
+    mat = sapien.render.RenderMaterial()
+    mat.base_color_texture = sapien.render.RenderTexture2D(
+        filename=texture_file,
+        mipmap_levels=mipmap_levels,
+    )
+    uv_scale = floor_width / texture_square_len
+    uvs = np.zeros((len(vertices), 2))
+    uvs[:, 0] = (xys[:, 0] * uv_scale + floor_half_width) / floor_width
+    uvs[:, 1] = (xys[:, 1] * uv_scale + floor_half_width) / floor_width
+
+    # TODO: This is fast but still two for loops which is a little annoying
+    triangles = []
+    for i in range(floor_length):
+        triangles.append(
+            np.stack(
+                [
+                    np.arange(floor_width) + i * (floor_width + 1),
+                    np.arange(floor_width) + 1 + floor_width + i * (floor_width + 1),
+                    np.arange(floor_width) + 1 + i * (floor_width + 1),
+                ],
+                axis=1,
+            )
+        )
+    for i in range(floor_length):
+        triangles.append(
+            np.stack(
+                [
+                    np.arange(floor_width) + 1 + floor_width + i * (floor_width + 1),
+                    np.arange(floor_width) + floor_width + 2 + i * (floor_width + 1),
+                    np.arange(floor_width) + 1 + i * (floor_width + 1),
+                ],
+                axis=1,
+            )
+        )
+    triangles = np.concatenate(triangles)
+
+    shape = sapien.render.RenderShapeTriangleMesh(
+        vertices=vertices, triangles=triangles, normals=normals, uvs=uvs, material=mat
+    )
+
+    for obj in actor._objs:
+        floor_comp = sapien.render.RenderBodyComponent()
+        floor_comp.attach(shape)
+        obj.add_component(floor_comp)
+
+    return actor

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/mjcf_loader.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, TypedDict
+
+from mani_skill.utils.building.actor_builder import ActorBuilder
+from mani_skill.utils.building.articulation_builder import ArticulationBuilder
+from mani_skill.utils.structs import Actor, Articulation
+
+if TYPE_CHECKING:
+    from mani_skill.envs.scene import ManiSkillScene
+
+from ._mjcf_loader import MJCFLoader as SAPIENMJCFLoader
+
+
+class ParsedMJCFData(TypedDict):
+    articulation_builders: List[ArticulationBuilder]
+    actor_builders: List[ActorBuilder]
+    cameras: List[Any]
+
+
+class MJCFLoader(SAPIENMJCFLoader):
+    """
+    Wrapper for the SAPIEN MJCF Loader to support easy parallelization
+    """
+
+    scene: ManiSkillScene
+    name: str = None
+    disable_self_collisions: bool = False
+
+    def parse(self, mjcf_file, package_dir=None) -> ParsedMJCFData:
+        articulation_builders, actor_builders, cameras = super().parse(
+            mjcf_file, package_dir
+        )
+        for i, a in enumerate(articulation_builders):
+            if len(articulation_builders) > 1:
+                a.set_name(f"{self.name}-articulation-{i}")
+            else:
+                a.set_name(f"{self.name}")
+            if self.disable_self_collisions:
+                for l in a.link_builders:
+                    # NOTE (stao): Currently this may not be working as intended
+                    l.collision_groups[2] |= 1 << 29
+        for i, b in enumerate(actor_builders):
+            b.set_name(f"{self.name}-actor-{i}")
+        return dict(
+            articulation_builders=articulation_builders,
+            actor_builders=actor_builders,
+            cameras=cameras,
+        )
+
+    def load(
+        self,
+        mjcf_file: str,
+        package_dir=None,
+        name=None,
+        scene_idxs=None,
+    ) -> Articulation:
+        """
+        Args:
+            urdf_file: filename for URDL file
+            srdf_file: SRDF for urdf_file. If srdf_file is None, it defaults to the ".srdf" file with the same as the urdf file
+            package_dir: base directory used to resolve asset files in the URDF file. If an asset path starts with "package://", "package://" is simply removed from the file name
+            name (str): name of the created articulation
+            scene_idxs (list[int]): the ids of the scenes to build the objects in
+        Returns:
+            returns a single Articulation loaded from the URDF file. It throws an error if multiple objects exists
+        """
+        if name is not None:
+            self.name = name
+        _parsed_mjcf_data = self.parse(mjcf_file, package_dir)
+        articulation_builders = _parsed_mjcf_data["articulation_builders"]
+        _parsed_mjcf_data["actor_builders"]
+        cameras = _parsed_mjcf_data["cameras"]
+
+        articulations: List[Articulation] = []
+        for b in articulation_builders[:1]:
+            b.set_scene_idxs(scene_idxs)
+            b.disable_self_collisions = self.disable_self_collisions
+            articulations.append(b.build())
+
+        actors: List[Actor] = []
+        # for b in actor_builders:
+        #     actors.append(b.build())
+
+        if len(cameras) > 0:
+            name2entity = dict()
+            for a in articulations:
+                for sapien_articulation in a._objs:
+                    for l in sapien_articulation.links:
+                        name2entity[l.name] = l.entity
+
+            for a in actors:
+                name2entity[a.name] = a
+
+            # TODO (stao): support extracting sensors
+            # for scene_idx, scene in enumerate(self.scene.sub_scenes):
+            #     for cam in cameras:
+            #         cam_component = RenderCameraComponent(cam["width"], cam["height"])
+            #         if cam["fovx"] is not None and cam["fovy"] is not None:
+            #             cam_component.set_fovx(cam["fovx"], False)
+            #             cam_component.set_fovy(cam["fovy"], False)
+            #         elif cam["fovy"] is None:
+            #             cam_component.set_fovx(cam["fovx"], True)
+            #         elif cam["fovx"] is None:
+            #             cam_component.set_fovy(cam["fovy"], True)
+
+            #         cam_component.near = cam["near"]
+            #         cam_component.far = cam["far"]
+            #         name2entity[f"scene-{scene_idx}_{cam['reference']}"].add_component(
+            #             cam_component
+            #         )
+
+        return articulations[0]

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/building/urdf_loader.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, TypedDict
+
+from sapien.render import RenderCameraComponent
+from sapien.wrapper.urdf_loader import URDFLoader as SapienURDFLoader
+
+from mani_skill.utils.building.actor_builder import ActorBuilder
+from mani_skill.utils.building.articulation_builder import ArticulationBuilder
+from mani_skill.utils.structs.actor import Actor
+from mani_skill.utils.structs.articulation import Articulation
+
+if TYPE_CHECKING:
+    from mani_skill.envs.scene import ManiSkillScene
+
+
+class ParsedURDFData(TypedDict):
+    articulation_builders: List[ArticulationBuilder]
+    actor_builders: List[ActorBuilder]
+    cameras: List[Any]
+
+
+class URDFLoader(SapienURDFLoader):
+    scene: ManiSkillScene
+    name: str = None
+    disable_self_collisions: bool = False
+
+    def parse(self, urdf_file, srdf_file=None, package_dir=None) -> ParsedURDFData:
+        articulation_builders, actor_builders, cameras = super().parse(
+            urdf_file, srdf_file, package_dir
+        )
+        for i, a in enumerate(articulation_builders):
+            if len(articulation_builders) > 1:
+                a.set_name(f"{self.name}-articulation-{i}")
+            else:
+                a.set_name(f"{self.name}")
+            if self.disable_self_collisions:
+                for l in a.link_builders:
+                    # NOTE (stao): Currently this may not be working as intended
+                    l.collision_groups[2] |= 1 << 29
+        for i, b in enumerate(actor_builders):
+            b.set_name(f"{self.name}-actor-{i}")
+        return dict(
+            articulation_builders=articulation_builders,
+            actor_builders=actor_builders,
+            cameras=cameras,
+        )
+
+    def load_file_as_articulation_builder(
+        self, urdf_file, srdf_file=None, package_dir=None
+    ) -> ArticulationBuilder:
+        return super().load_file_as_articulation_builder(
+            urdf_file, srdf_file, package_dir
+        )
+
+    def load(
+        self,
+        urdf_file: str,
+        srdf_file=None,
+        package_dir=None,
+        name=None,
+        scene_idxs=None,
+    ) -> Articulation:
+        """
+        Args:
+            urdf_file: filename for URDL file
+            srdf_file: SRDF for urdf_file. If srdf_file is None, it defaults to the ".srdf" file with the same as the urdf file
+            package_dir: base directory used to resolve asset files in the URDF file. If an asset path starts with "package://", "package://" is simply removed from the file name
+            name (str): name of the created articulation
+            scene_idxs (list[int]): the ids of the scenes to build the objects in
+        Returns:
+            returns a single Articulation loaded from the URDF file. It throws an error if multiple objects exists
+        """
+        if name is not None:
+            self.name = name
+        _parsed_urdf_data = self.parse(urdf_file, srdf_file, package_dir)
+        articulation_builders = _parsed_urdf_data["articulation_builders"]
+        actor_builders = _parsed_urdf_data["actor_builders"]
+        cameras = _parsed_urdf_data["cameras"]
+
+        if len(articulation_builders) > 1 or len(actor_builders) != 0:
+            raise Exception(
+                "URDF contains multiple objects, call load_multiple instead"
+            )
+
+        articulations: List[Articulation] = []
+        for b in articulation_builders:
+            b.set_scene_idxs(scene_idxs)
+            b.disable_self_collisions = self.disable_self_collisions
+            articulations.append(b.build())
+
+        actors: List[Actor] = []
+        for b in actor_builders:
+            actors.append(b.build())
+
+        if len(cameras) > 0:
+            name2entity = dict()
+            for a in articulations:
+                for sapien_articulation in a._objs:
+                    for l in sapien_articulation.links:
+                        name2entity[l.name] = l.entity
+
+            for a in actors:
+                name2entity[a.name] = a
+
+            for scene_idx, scene in enumerate(self.scene.sub_scenes):
+                for cam in cameras:
+                    cam_component = RenderCameraComponent(cam["width"], cam["height"])
+                    if cam["fovx"] is not None and cam["fovy"] is not None:
+                        cam_component.set_fovx(cam["fovx"], False)
+                        cam_component.set_fovy(cam["fovy"], False)
+                    elif cam["fovy"] is None:
+                        cam_component.set_fovx(cam["fovx"], True)
+                    elif cam["fovx"] is None:
+                        cam_component.set_fovy(cam["fovy"], True)
+
+                    cam_component.near = cam["near"]
+                    cam_component.far = cam["far"]
+                    name2entity[f"scene-{scene_idx}_{cam['reference']}"].add_component(
+                        cam_component
+                    )
+
+        return articulations[0]

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/__init__.py

@@ -0,0 +1 @@
+from .geometry import *

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/bounding_cylinder.py

@@ -0,0 +1,137 @@
+#
+# Smallest enclosing circle - Library (Python)
+#
+# Copyright (c) 2020 Project Nayuki
+# https://www.nayuki.io/page/smallest-enclosing-circle
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program (see COPYING.txt and COPYING.LESSER.txt).
+# If not, see <http://www.gnu.org/licenses/>.
+#
+
+# fmt: off
+# isort: skip_file
+import math, random
+import numpy as np
+
+
+# Data conventions: A point is a pair of floats (x, y). A circle is a triple of floats (center x, center y, radius).
+
+# Returns the smallest circle that encloses all the given points. Runs in expected O(n) time, randomized.
+# Input: A sequence of pairs of floats or ints, e.g. [(0,5), (3.1,-2.7)].
+# Output: A triple of floats representing a circle.
+# Note: If 0 points are given, None is returned. If 1 point is given, a circle of radius 0 is returned.
+#
+# Initially: No boundary points known
+def make_circle(points):
+    # Convert to float and randomize order
+    shuffled = [(float(x), float(y)) for (x, y) in points]
+    random.shuffle(shuffled)
+
+    # Progressively add points to circle or recompute circle
+    c = None
+    for (i, p) in enumerate(shuffled):
+        if c is None or not is_in_circle(c, p):
+            c = _make_circle_one_point(shuffled[ : i + 1], p)
+    return c
+
+
+# One boundary point known
+def _make_circle_one_point(points, p):
+    c = (p[0], p[1], 0.0)
+    for (i, q) in enumerate(points):
+        if not is_in_circle(c, q):
+            if c[2] == 0.0:
+                c = make_diameter(p, q)
+            else:
+                c = _make_circle_two_points(points[ : i + 1], p, q)
+    return c
+
+
+# Two boundary points known
+def _make_circle_two_points(points, p, q):
+    circ = make_diameter(p, q)
+    left  = None
+    right = None
+    px, py = p
+    qx, qy = q
+
+    # For each point not in the two-point circle
+    for r in points:
+        if is_in_circle(circ, r):
+            continue
+
+        # Form a circumcircle and classify it on left or right side
+        cross = _cross_product(px, py, qx, qy, r[0], r[1])
+        c = make_circumcircle(p, q, r)
+        if c is None:
+            continue
+        elif cross > 0.0 and (left is None or _cross_product(px, py, qx, qy, c[0], c[1]) > _cross_product(px, py, qx, qy, left[0], left[1])):
+            left = c
+        elif cross < 0.0 and (right is None or _cross_product(px, py, qx, qy, c[0], c[1]) < _cross_product(px, py, qx, qy, right[0], right[1])):
+            right = c
+
+    # Select which circle to return
+    if left is None and right is None:
+        return circ
+    elif left is None:
+        return right
+    elif right is None:
+        return left
+    else:
+        return left if (left[2] <= right[2]) else right
+
+
+def make_diameter(a, b):
+    cx = (a[0] + b[0]) / 2
+    cy = (a[1] + b[1]) / 2
+    r0 = math.hypot(cx - a[0], cy - a[1])
+    r1 = math.hypot(cx - b[0], cy - b[1])
+    return (cx, cy, max(r0, r1))
+
+
+def make_circumcircle(a, b, c):
+    # Mathematical algorithm from Wikipedia: Circumscribed circle
+    ox = (min(a[0], b[0], c[0]) + max(a[0], b[0], c[0])) / 2
+    oy = (min(a[1], b[1], c[1]) + max(a[1], b[1], c[1])) / 2
+    ax = a[0] - ox;  ay = a[1] - oy
+    bx = b[0] - ox;  by = b[1] - oy
+    cx = c[0] - ox;  cy = c[1] - oy
+    d = (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by)) * 2.0
+    if d == 0.0:
+        return None
+    x = ox + ((ax*ax + ay*ay) * (by - cy) + (bx*bx + by*by) * (cy - ay) + (cx*cx + cy*cy) * (ay - by)) / d
+    y = oy + ((ax*ax + ay*ay) * (cx - bx) + (bx*bx + by*by) * (ax - cx) + (cx*cx + cy*cy) * (bx - ax)) / d
+    ra = math.hypot(x - a[0], y - a[1])
+    rb = math.hypot(x - b[0], y - b[1])
+    rc = math.hypot(x - c[0], y - c[1])
+    return (x, y, max(ra, rb, rc))
+
+
+_MULTIPLICATIVE_EPSILON = 1 + 1e-14
+
+def is_in_circle(c, p):
+    return c is not None and math.hypot(p[0] - c[0], p[1] - c[1]) <= c[2] * _MULTIPLICATIVE_EPSILON
+
+
+# Returns twice the signed area of the triangle defined by (x0, y0), (x1, y1), (x2, y2).
+def _cross_product(x0, y0, x1, y1, x2, y2):
+    return (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0)
+
+
+def aabc(points):
+    points = np.asarray(points)
+    z_min = points[:, 2].min()
+    z_max = points[:, 2].max()
+    x, y, r = make_circle(points[:, :2])
+    return x, y, r, z_min, z_max

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/geometry.py

@@ -0,0 +1,201 @@
+from typing import Dict
+
+import numpy as np
+import sapien
+import sapien.physx as physx
+import torch
+from scipy.spatial.transform import Rotation
+
+from mani_skill.utils.geometry.bounding_cylinder import aabc
+
+
+def sample_on_unit_sphere(rng):
+    """
+    Algo from http://corysimon.github.io/articles/uniformdistn-on-sphere/
+    """
+    v = np.zeros(3)
+    while np.linalg.norm(v) < 1e-4:
+        v[0] = rng.normal()  # random standard normal
+        v[1] = rng.normal()
+        v[2] = rng.normal()
+
+    v = v / np.linalg.norm(v)
+    return v
+
+
+def sample_on_unit_circle(rng):
+    v = np.zeros(2)
+    while np.linalg.norm(v) < 1e-4:
+        v[0] = rng.normal()  # random standard normal
+        v[1] = rng.normal()
+
+    v = v / np.linalg.norm(v)
+    return v
+
+
+def rotation_between_vec(a, b):  # from a to b
+    a = a / np.linalg.norm(a)
+    b = b / np.linalg.norm(b)
+    axis = np.cross(a, b)
+    axis = axis / np.linalg.norm(axis)  # norm might be 0
+    angle = np.arccos(a @ b)
+    R = Rotation.from_rotvec(axis * angle)
+    return R
+
+
+def angle_between_vec(a, b):  # from a to b
+    a = a / np.linalg.norm(a)
+    b = b / np.linalg.norm(b)
+    angle = np.arccos(a @ b)
+    return angle
+
+
+def wxyz_to_xyzw(q):
+    return np.concatenate([q[1:4], q[0:1]])
+
+
+def xyzw_to_wxyz(q):
+    return np.concatenate([q[3:4], q[0:3]])
+
+
+def rotate_2d_vec_by_angle(vec, theta):
+    rot_mat = np.array(
+        [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]
+    )
+    return rot_mat @ vec
+
+
+def angle_distance(q0: sapien.Pose, q1: sapien.Pose):
+    qd = (q0.inv() * q1).q
+    return 2 * np.arctan2(np.linalg.norm(qd[1:]), qd[0]) / np.pi
+
+
+def get_axis_aligned_bbox_for_articulation(art: physx.PhysxArticulation):
+    mins = np.array([np.inf, np.inf, np.inf])
+    maxs = -mins
+    for link in art.get_links():
+        lp = link.pose
+        for s in link.get_collision_shapes():
+            p = lp * s.get_local_pose()
+            T = p.to_transformation_matrix()
+            assert isinstance(s, physx.PhysxCollisionShapeConvexMesh)
+            vertices = s.vertices * s.scale
+            vertices = vertices @ T[:3, :3].T + T[:3, 3]
+            mins = np.minimum(mins, vertices.min(0))
+            maxs = np.maximum(maxs, vertices.max(0))
+    return mins, maxs
+
+
+def get_axis_aligned_bbox_for_actor(actor: sapien.Entity):
+    mins = np.ones(3) * np.inf
+    maxs = -mins
+
+    for shape in actor.find_component_by_type(
+        physx.PhysxRigidDynamicComponent
+    ).get_collision_shapes():  # this is CollisionShape
+        assert isinstance(shape, physx.PhysxCollisionShapeConvexMesh)
+        scaled_vertices = shape.vertices * shape.scale
+        local_pose = shape.get_local_pose()
+        mat = (actor.get_pose() * local_pose).to_transformation_matrix()
+        world_vertices = scaled_vertices @ (mat[:3, :3].T) + mat[:3, 3]
+        mins = np.minimum(mins, world_vertices.min(0))
+        maxs = np.maximum(maxs, world_vertices.max(0))
+
+    return mins, maxs
+
+
+def get_local_axis_aligned_bbox_for_link(link: physx.PhysxArticulationLinkComponent):
+    mins = np.array([np.inf, np.inf, np.inf])
+    maxs = -mins
+    for s in link.get_collision_shapes():
+        assert isinstance(s, physx.PhysxCollisionShapeConvexMesh)
+        p = s.get_local_pose()
+        T = p.to_transformation_matrix()
+        vertices = s.vertices * s.scale
+        vertices = vertices @ T[:3, :3].T + T[:3, 3]
+        mins = np.minimum(mins, vertices.min(0))
+        maxs = np.maximum(maxs, vertices.max(0))
+    return mins, maxs
+
+
+def get_local_aabc_for_actor(actor: sapien.Entity):
+    all_vertices = []
+    for s in actor.find_component_by_type(
+        physx.PhysxRigidDynamicComponent
+    ).get_collision_shapes():
+        assert isinstance(s, physx.PhysxCollisionShapeConvexMesh)
+        p = s.get_local_pose()
+        T = p.to_transformation_matrix()
+        vertices = s.vertices * s.scale
+        vertices = vertices @ T[:3, :3].T + T[:3, 3]
+        all_vertices.append(vertices)
+    vertices = np.vstack(all_vertices)
+    return aabc(vertices)
+
+
+def transform_points(H: torch.Tensor, pts: torch.Tensor) -> torch.Tensor:
+    """transforms a batch of pts by a batch of transformation matrices H"""
+    assert H.shape[1:] == (4, 4), H.shape
+    assert pts.ndim == 2 and pts.shape[1] == 3, pts.shape
+    return (
+        torch.bmm(pts[:, None, :], H[:, :3, :3].transpose(2, 1))[:, 0, :] + H[:, :3, 3]
+    )
+
+
+def invert_transform(H: np.ndarray):
+    assert H.shape[-2:] == (4, 4), H.shape
+    H_inv = H.copy()
+    R_T = np.swapaxes(H[..., :3, :3], -1, -2)
+    H_inv[..., :3, :3] = R_T
+    H_inv[..., :3, 3:] = -R_T @ H[..., :3, 3:]
+    return H_inv
+
+
+def get_oriented_bounding_box_for_2d_points(
+    points_2d: np.ndarray, resolution=0.0
+) -> Dict:
+    assert len(points_2d.shape) == 2 and points_2d.shape[1] == 2
+    if resolution > 0.0:
+        points_2d = np.round(points_2d / resolution) * resolution
+        points_2d = np.unique(points_2d, axis=0)
+    ca = np.cov(points_2d, y=None, rowvar=0, bias=1)
+
+    v, vect = np.linalg.eig(ca)
+    tvect = np.transpose(vect)
+
+    # use the inverse of the eigenvectors as a rotation matrix and
+    # rotate the points so they align with the x and y axes
+    ar = np.dot(points_2d, np.linalg.inv(tvect))
+
+    # get the minimum and maximum x and y
+    mina = np.min(ar, axis=0)
+    maxa = np.max(ar, axis=0)
+    half_size = (maxa - mina) * 0.5
+
+    # the center is just half way between the min and max xy
+    center = mina + half_size
+    # get the 4 corners by subtracting and adding half the bounding boxes height and width to the center
+    corners = np.array(
+        [
+            center + [-half_size[0], -half_size[1]],
+            center + [half_size[0], -half_size[1]],
+            center + [half_size[0], half_size[1]],
+            center + [-half_size[0], half_size[1]],
+        ]
+    )
+
+    # use the the eigenvectors as a rotation matrix and
+    # rotate the corners and the centerback
+    corners = np.dot(corners, tvect)
+    center = np.dot(center, tvect)
+
+    return {"center": center, "half_size": half_size, "axes": vect, "corners": corners}
+
+
+# -------------------------------------------------------------------------- #
+# Functions pulled out from SAPIEN
+# -------------------------------------------------------------------------- #
+def rotate_vector(v, q):
+    w = q[0]
+    u = q[1:]
+    return 2.0 * u.dot(v) * u + (w * w - u.dot(u)) * v + 2.0 * w * np.cross(u, v)

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/rotation_conversions.py

@@ -0,0 +1,633 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from typing import Optional, Union
+
+import torch
+import torch.nn.functional as F
+
+Device = Union[str, torch.device]
+
+# -------------------------------------------------------------------------- #
+# Functions pulled out from pytorch3d to avoid having to install the whole package
+# -------------------------------------------------------------------------- #
+
+"""
+The transformation matrices returned from the functions in this file assume
+the points on which the transformation will be applied are column vectors.
+i.e. the R matrix is structured as
+
+    R = [
+            [Rxx, Rxy, Rxz],
+            [Ryx, Ryy, Ryz],
+            [Rzx, Rzy, Rzz],
+        ]  # (3, 3)
+
+This matrix can be applied to column vectors by post multiplication
+by the points e.g.
+
+    points = [[0], [1], [2]]  # (3 x 1) xyz coordinates of a point
+    transformed_points = R * points
+
+To apply the same matrix to points which are row vectors, the R matrix
+can be transposed and pre multiplied by the points:
+
+e.g.
+    points = [[0, 1, 2]]  # (1 x 3) xyz coordinates of a point
+    transformed_points = points * R.transpose(1, 0)
+"""
+
+
+def quaternion_to_matrix(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as quaternions to rotation matrices.
+
+    Args:
+        quaternions: quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Rotation matrices as tensor of shape (..., 3, 3).
+    """
+    r, i, j, k = torch.unbind(quaternions, -1)
+    # pyre-fixme[58]: `/` is not supported for operand types `float` and `Tensor`.
+    two_s = 2.0 / (quaternions * quaternions).sum(-1)
+
+    o = torch.stack(
+        (
+            1 - two_s * (j * j + k * k),
+            two_s * (i * j - k * r),
+            two_s * (i * k + j * r),
+            two_s * (i * j + k * r),
+            1 - two_s * (i * i + k * k),
+            two_s * (j * k - i * r),
+            two_s * (i * k - j * r),
+            two_s * (j * k + i * r),
+            1 - two_s * (i * i + j * j),
+        ),
+        -1,
+    )
+    return o.reshape(quaternions.shape[:-1] + (3, 3))
+
+
+def _copysign(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Return a tensor where each element has the absolute value taken from the,
+    corresponding element of a, with sign taken from the corresponding
+    element of b. This is like the standard copysign floating-point operation,
+    but is not careful about negative 0 and NaN.
+
+    Args:
+        a: source tensor.
+        b: tensor whose signs will be used, of the same shape as a.
+
+    Returns:
+        Tensor of the same shape as a with the signs of b.
+    """
+    signs_differ = (a < 0) != (b < 0)
+    return torch.where(signs_differ, -a, a)
+
+
+def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
+    """
+    Returns torch.sqrt(torch.max(0, x))
+    but with a zero subgradient where x is 0.
+    """
+    ret = torch.zeros_like(x)
+    positive_mask = x > 0
+    ret[positive_mask] = torch.sqrt(x[positive_mask])
+    return ret
+
+
+def matrix_to_quaternion(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to quaternions.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        quaternions with real part first, as tensor of shape (..., 4).
+    """
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
+        matrix.reshape(batch_dim + (9,)), dim=-1
+    )
+
+    q_abs = _sqrt_positive_part(
+        torch.stack(
+            [
+                1.0 + m00 + m11 + m22,
+                1.0 + m00 - m11 - m22,
+                1.0 - m00 + m11 - m22,
+                1.0 - m00 - m11 + m22,
+            ],
+            dim=-1,
+        )
+    )
+
+    # we produce the desired quaternion multiplied by each of r, i, j, k
+    quat_by_rijk = torch.stack(
+        [
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2], dim=-1),
+        ],
+        dim=-2,
+    )
+
+    # We floor here at 0.1 but the exact level is not important; if q_abs is small,
+    # the candidate won't be picked.
+    flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device)
+    quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr))
+
+    # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
+    # forall i; we pick the best-conditioned one (with the largest denominator)
+    out = quat_candidates[
+        F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, :
+    ].reshape(batch_dim + (4,))
+    return standardize_quaternion(out)
+
+
+def _axis_angle_rotation(axis: str, angle: torch.Tensor) -> torch.Tensor:
+    """
+    Return the rotation matrices for one of the rotations about an axis
+    of which Euler angles describe, for each value of the angle given.
+
+    Args:
+        axis: Axis label "X" or "Y or "Z".
+        angle: any shape tensor of Euler angles in radians
+
+    Returns:
+        Rotation matrices as tensor of shape (..., 3, 3).
+    """
+
+    cos = torch.cos(angle)
+    sin = torch.sin(angle)
+    one = torch.ones_like(angle)
+    zero = torch.zeros_like(angle)
+
+    if axis == "X":
+        R_flat = (one, zero, zero, zero, cos, -sin, zero, sin, cos)
+    elif axis == "Y":
+        R_flat = (cos, zero, sin, zero, one, zero, -sin, zero, cos)
+    elif axis == "Z":
+        R_flat = (cos, -sin, zero, sin, cos, zero, zero, zero, one)
+    else:
+        raise ValueError("letter must be either X, Y or Z.")
+
+    return torch.stack(R_flat, -1).reshape(angle.shape + (3, 3))
+
+
+def euler_angles_to_matrix(euler_angles: torch.Tensor, convention: str) -> torch.Tensor:
+    """
+    Convert rotations given as Euler angles in radians to rotation matrices.
+
+    Args:
+        euler_angles: Euler angles in radians as tensor of shape (..., 3).
+        convention: Convention string of three uppercase letters from
+            {"X", "Y", and "Z"}.
+
+    Returns:
+        Rotation matrices as tensor of shape (..., 3, 3).
+    """
+    if euler_angles.dim() == 0 or euler_angles.shape[-1] != 3:
+        raise ValueError("Invalid input euler angles.")
+    if len(convention) != 3:
+        raise ValueError("Convention must have 3 letters.")
+    if convention[1] in (convention[0], convention[2]):
+        raise ValueError(f"Invalid convention {convention}.")
+    for letter in convention:
+        if letter not in ("X", "Y", "Z"):
+            raise ValueError(f"Invalid letter {letter} in convention string.")
+    matrices = [
+        _axis_angle_rotation(c, e)
+        for c, e in zip(convention, torch.unbind(euler_angles, -1))
+    ]
+    # return functools.reduce(torch.matmul, matrices)
+    return torch.matmul(torch.matmul(matrices[0], matrices[1]), matrices[2])
+
+
+def _angle_from_tan(
+    axis: str, other_axis: str, data, horizontal: bool, tait_bryan: bool
+) -> torch.Tensor:
+    """
+    Extract the first or third Euler angle from the two members of
+    the matrix which are positive constant times its sine and cosine.
+
+    Args:
+        axis: Axis label "X" or "Y or "Z" for the angle we are finding.
+        other_axis: Axis label "X" or "Y or "Z" for the middle axis in the
+            convention.
+        data: Rotation matrices as tensor of shape (..., 3, 3).
+        horizontal: Whether we are looking for the angle for the third axis,
+            which means the relevant entries are in the same row of the
+            rotation matrix. If not, they are in the same column.
+        tait_bryan: Whether the first and third axes in the convention differ.
+
+    Returns:
+        Euler Angles in radians for each matrix in data as a tensor
+        of shape (...).
+    """
+
+    i1, i2 = {"X": (2, 1), "Y": (0, 2), "Z": (1, 0)}[axis]
+    if horizontal:
+        i2, i1 = i1, i2
+    even = (axis + other_axis) in ["XY", "YZ", "ZX"]
+    if horizontal == even:
+        return torch.atan2(data[..., i1], data[..., i2])
+    if tait_bryan:
+        return torch.atan2(-data[..., i2], data[..., i1])
+    return torch.atan2(data[..., i2], -data[..., i1])
+
+
+def _index_from_letter(letter: str) -> int:
+    if letter == "X":
+        return 0
+    if letter == "Y":
+        return 1
+    if letter == "Z":
+        return 2
+    raise ValueError("letter must be either X, Y or Z.")
+
+
+def matrix_to_euler_angles(matrix: torch.Tensor, convention: str) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to Euler angles in radians.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+        convention: Convention string of three uppercase letters.
+
+    Returns:
+        Euler angles in radians as tensor of shape (..., 3).
+    """
+    if len(convention) != 3:
+        raise ValueError("Convention must have 3 letters.")
+    if convention[1] in (convention[0], convention[2]):
+        raise ValueError(f"Invalid convention {convention}.")
+    for letter in convention:
+        if letter not in ("X", "Y", "Z"):
+            raise ValueError(f"Invalid letter {letter} in convention string.")
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+    i0 = _index_from_letter(convention[0])
+    i2 = _index_from_letter(convention[2])
+    tait_bryan = i0 != i2
+    if tait_bryan:
+        central_angle = torch.asin(
+            matrix[..., i0, i2] * (-1.0 if i0 - i2 in [-1, 2] else 1.0)
+        )
+    else:
+        central_angle = torch.acos(matrix[..., i0, i0])
+
+    o = (
+        _angle_from_tan(
+            convention[0], convention[1], matrix[..., i2], False, tait_bryan
+        ),
+        central_angle,
+        _angle_from_tan(
+            convention[2], convention[1], matrix[..., i0, :], True, tait_bryan
+        ),
+    )
+    return torch.stack(o, -1)
+
+
+def random_quaternions(
+    n: int, dtype: Optional[torch.dtype] = None, device: Optional[Device] = None
+) -> torch.Tensor:
+    """
+    Generate random quaternions representing rotations,
+    i.e. versors with nonnegative real part.
+
+    Args:
+        n: Number of quaternions in a batch to return.
+        dtype: Type to return.
+        device: Desired device of returned tensor. Default:
+            uses the current device for the default tensor type.
+
+    Returns:
+        Quaternions as tensor of shape (N, 4).
+    """
+    if isinstance(device, str):
+        device = torch.device(device)
+    o = torch.randn((n, 4), dtype=dtype, device=device)
+    s = (o * o).sum(1)
+    o = o / _copysign(torch.sqrt(s), o[:, 0])[:, None]
+    return o
+
+
+def random_rotations(
+    n: int, dtype: Optional[torch.dtype] = None, device: Optional[Device] = None
+) -> torch.Tensor:
+    """
+    Generate random rotations as 3x3 rotation matrices.
+
+    Args:
+        n: Number of rotation matrices in a batch to return.
+        dtype: Type to return.
+        device: Device of returned tensor. Default: if None,
+            uses the current device for the default tensor type.
+
+    Returns:
+        Rotation matrices as tensor of shape (n, 3, 3).
+    """
+    quaternions = random_quaternions(n, dtype=dtype, device=device)
+    return quaternion_to_matrix(quaternions)
+
+
+def random_rotation(
+    dtype: Optional[torch.dtype] = None, device: Optional[Device] = None
+) -> torch.Tensor:
+    """
+    Generate a single random 3x3 rotation matrix.
+
+    Args:
+        dtype: Type to return
+        device: Device of returned tensor. Default: if None,
+            uses the current device for the default tensor type
+
+    Returns:
+        Rotation matrix as tensor of shape (3, 3).
+    """
+    return random_rotations(1, dtype, device)[0]
+
+
+def standardize_quaternion(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert a unit quaternion to a standard form: one in which the real
+    part is non negative.
+
+    Args:
+        quaternions: Quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Standardized quaternions as tensor of shape (..., 4).
+    """
+    return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions)
+
+
+def quaternion_raw_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Multiply two quaternions.
+    Usual torch rules for broadcasting apply.
+
+    Args:
+        a: Quaternions as tensor of shape (..., 4), real part first.
+        b: Quaternions as tensor of shape (..., 4), real part first.
+
+    Returns:
+        The product of a and b, a tensor of quaternions shape (..., 4).
+    """
+    aw, ax, ay, az = torch.unbind(a, -1)
+    bw, bx, by, bz = torch.unbind(b, -1)
+    ow = aw * bw - ax * bx - ay * by - az * bz
+    ox = aw * bx + ax * bw + ay * bz - az * by
+    oy = aw * by - ax * bz + ay * bw + az * bx
+    oz = aw * bz + ax * by - ay * bx + az * bw
+    return torch.stack((ow, ox, oy, oz), -1)
+
+
+def quaternion_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Multiply two quaternions representing rotations, returning the quaternion
+    representing their composition, i.e. the versor with nonnegative real part.
+    Usual torch rules for broadcasting apply.
+
+    Args:
+        a: Quaternions as tensor of shape (..., 4), real part first.
+        b: Quaternions as tensor of shape (..., 4), real part first.
+
+    Returns:
+        The product of a and b, a tensor of quaternions of shape (..., 4).
+    """
+    ab = quaternion_raw_multiply(a, b)
+    return standardize_quaternion(ab)
+
+
+def quaternion_invert(quaternion: torch.Tensor) -> torch.Tensor:
+    """
+    Given a quaternion representing rotation, get the quaternion representing
+    its inverse.
+
+    Args:
+        quaternion: Quaternions as tensor of shape (..., 4), with real part
+            first, which must be versors (unit quaternions).
+
+    Returns:
+        The inverse, a tensor of quaternions of shape (..., 4).
+    """
+
+    scaling = torch.tensor([1, -1, -1, -1], device=quaternion.device)
+    return quaternion * scaling
+
+
+def quaternion_apply(quaternion: torch.Tensor, point: torch.Tensor) -> torch.Tensor:
+    """
+    Apply the rotation given by a quaternion to a 3D point.
+    Usual torch rules for broadcasting apply.
+
+    Args:
+        quaternion: Tensor of quaternions, real part first, of shape (..., 4).
+        point: Tensor of 3D points of shape (..., 3).
+
+    Returns:
+        Tensor of rotated points of shape (..., 3).
+    """
+    if point.size(-1) != 3:
+        raise ValueError(f"Points are not in 3D, {point.shape}.")
+    real_parts = point.new_zeros(point.shape[:-1] + (1,))
+    point_as_quaternion = torch.cat((real_parts, point), -1)
+    out = quaternion_raw_multiply(
+        quaternion_raw_multiply(quaternion, point_as_quaternion),
+        quaternion_invert(quaternion),
+    )
+    return out[..., 1:]
+
+
+def axis_angle_to_matrix(axis_angle: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as axis/angle to rotation matrices.
+
+    Args:
+        axis_angle: Rotations given as a vector in axis angle form,
+            as a tensor of shape (..., 3), where the magnitude is
+            the angle turned anticlockwise in radians around the
+            vector's direction.
+
+    Returns:
+        Rotation matrices as tensor of shape (..., 3, 3).
+    """
+    return quaternion_to_matrix(axis_angle_to_quaternion(axis_angle))
+
+
+def matrix_to_axis_angle(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as rotation matrices to axis/angle.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        Rotations given as a vector in axis angle form, as a tensor
+            of shape (..., 3), where the magnitude is the angle
+            turned anticlockwise in radians around the vector's
+            direction.
+    """
+    return quaternion_to_axis_angle(matrix_to_quaternion(matrix))
+
+
+def axis_angle_to_quaternion(axis_angle: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as axis/angle to quaternions.
+
+    Args:
+        axis_angle: Rotations given as a vector in axis angle form,
+            as a tensor of shape (..., 3), where the magnitude is
+            the angle turned anticlockwise in radians around the
+            vector's direction.
+
+    Returns:
+        quaternions with real part first, as tensor of shape (..., 4).
+    """
+    angles = torch.norm(axis_angle, p=2, dim=-1, keepdim=True)
+    half_angles = angles * 0.5
+    eps = 1e-6
+    small_angles = angles.abs() < eps
+    sin_half_angles_over_angles = torch.empty_like(angles)
+    sin_half_angles_over_angles[~small_angles] = (
+        torch.sin(half_angles[~small_angles]) / angles[~small_angles]
+    )
+    # for x small, sin(x/2) is about x/2 - (x/2)^3/6
+    # so sin(x/2)/x is about 1/2 - (x*x)/48
+    sin_half_angles_over_angles[small_angles] = (
+        0.5 - (angles[small_angles] * angles[small_angles]) / 48
+    )
+    quaternions = torch.cat(
+        [torch.cos(half_angles), axis_angle * sin_half_angles_over_angles], dim=-1
+    )
+    return quaternions
+
+
+def quaternion_to_axis_angle(quaternions: torch.Tensor) -> torch.Tensor:
+    """
+    Convert rotations given as quaternions to axis/angle.
+
+    Args:
+        quaternions: quaternions with real part first,
+            as tensor of shape (..., 4).
+
+    Returns:
+        Rotations given as a vector in axis angle form, as a tensor
+            of shape (..., 3), where the magnitude is the angle
+            turned anticlockwise in radians around the vector's
+            direction.
+    """
+    norms = torch.norm(quaternions[..., 1:], p=2, dim=-1, keepdim=True)
+    half_angles = torch.atan2(norms, quaternions[..., :1])
+    angles = 2 * half_angles
+    eps = 1e-6
+    small_angles = angles.abs() < eps
+    sin_half_angles_over_angles = torch.empty_like(angles)
+    sin_half_angles_over_angles[~small_angles] = (
+        torch.sin(half_angles[~small_angles]) / angles[~small_angles]
+    )
+    # for x small, sin(x/2) is about x/2 - (x/2)^3/6
+    # so sin(x/2)/x is about 1/2 - (x*x)/48
+    sin_half_angles_over_angles[small_angles] = (
+        0.5 - (angles[small_angles] * angles[small_angles]) / 48
+    )
+    return quaternions[..., 1:] / sin_half_angles_over_angles
+
+
+def rotation_6d_to_matrix(d6: torch.Tensor) -> torch.Tensor:
+    """
+    Converts 6D rotation representation by Zhou et al. [1] to rotation matrix
+    using Gram--Schmidt orthogonalization per Section B of [1].
+    Args:
+        d6: 6D rotation representation, of size (*, 6)
+
+    Returns:
+        batch of rotation matrices of size (*, 3, 3)
+
+    [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H.
+    On the Continuity of Rotation Representations in Neural Networks.
+    IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+    Retrieved from http://arxiv.org/abs/1812.07035
+    """
+
+    a1, a2 = d6[..., :3], d6[..., 3:]
+    b1 = F.normalize(a1, dim=-1)
+    b2 = a2 - (b1 * a2).sum(-1, keepdim=True) * b1
+    b2 = F.normalize(b2, dim=-1)
+    b3 = torch.cross(b1, b2, dim=-1)
+    return torch.stack((b1, b2, b3), dim=-2)
+
+
+def matrix_to_rotation_6d(matrix: torch.Tensor) -> torch.Tensor:
+    """
+    Converts rotation matrices to 6D rotation representation by Zhou et al. [1]
+    by dropping the last row. Note that 6D representation is not unique.
+    Args:
+        matrix: batch of rotation matrices of size (*, 3, 3)
+
+    Returns:
+        6D rotation representation, of size (*, 6)
+
+    [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H.
+    On the Continuity of Rotation Representations in Neural Networks.
+    IEEE Conference on Computer Vision and Pattern Recognition, 2019.
+    Retrieved from http://arxiv.org/abs/1812.07035
+    """
+    batch_dim = matrix.size()[:-2]
+    return matrix[..., :2, :].clone().reshape(batch_dim + (6,))
+
+def euler_to_quaternion(euler_angles: torch.Tensor, convention: str = "ZYX") -> torch.Tensor:
+    """
+    Convert rotations given as Euler angles in radians to quaternions.
+
+    Args:
+        euler_angles: Euler angles in radians as a tensor of shape (..., 3).
+        convention: Convention string of three uppercase letters from {"X", "Y", "Z"}.
+            Specifies the order of rotations (e.g., "ZYX" for yaw-pitch-roll).
+            Defaults to "ZYX".
+
+    Returns:
+        Quaternions with real part first, as a tensor of shape (..., 4).
+    """
+    rotation_matrix = euler_angles_to_matrix(euler_angles, convention)
+    return matrix_to_quaternion(rotation_matrix)
+
+def quaternion_to_euler(quaternions: torch.Tensor, convention: str = "ZYX") -> torch.Tensor:
+    """
+    Convert rotations given as quaternions to Euler angles in radians.
+
+    Args:
+        quaternions: Quaternions with real part first, as tensor of shape (..., 4).
+        convention: Convention string of three uppercase letters from {"X", "Y", "Z"}.
+            Specifies the order of rotations (e.g., "ZYX" for yaw-pitch-roll). 
+            Defaults to "ZYX".
+
+    Returns:
+        Euler angles in radians as tensor of shape (..., 3).
+    """
+    # First, convert the quaternion to a rotation matrix.
+    rotation_matrix = quaternion_to_matrix(quaternions)
+    # Next, convert the rotation matrix to Euler angles using the specified convention.
+    return matrix_to_euler_angles(rotation_matrix, convention)

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/geometry/trimesh_utils.py

@@ -0,0 +1,119 @@
+from typing import List
+
+## TODO clean up the code here, too many functions that are plurals of one or the other and confusing naming
+import numpy as np
+import sapien
+import sapien.physx as physx
+import sapien.render
+import trimesh
+import trimesh.creation
+
+
+def get_component_meshes(component: physx.PhysxRigidBaseComponent):
+    """Get component (collision) meshes in the component's frame."""
+    meshes = []
+    for geom in component.get_collision_shapes():
+        if isinstance(geom, physx.PhysxCollisionShapeBox):
+            mesh = trimesh.creation.box(extents=2 * geom.half_size)
+        elif isinstance(geom, physx.PhysxCollisionShapeCapsule):
+            mesh = trimesh.creation.capsule(
+                height=2 * geom.half_length, radius=geom.radius
+            )
+
+        elif isinstance(geom, physx.PhysxCollisionShapeCylinder):
+            mesh = trimesh.creation.cylinder(
+                radius=geom.radius, height=2 * geom.half_length
+            )
+        elif isinstance(geom, physx.PhysxCollisionShapeSphere):
+            mesh = trimesh.creation.icosphere(radius=geom.radius)
+        elif isinstance(geom, physx.PhysxCollisionShapePlane):
+            continue
+        elif isinstance(geom, (physx.PhysxCollisionShapeConvexMesh)):
+            vertices = geom.vertices  # [n, 3]
+            faces = geom.get_triangles()
+            vertices = vertices * geom.scale
+            mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+        elif isinstance(geom, physx.PhysxCollisionShapeTriangleMesh):
+            vertices = geom.vertices
+            faces = geom.get_triangles()
+            vertices = vertices * geom.scale
+            mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+        else:
+            raise TypeError(type(geom))
+        mesh.apply_transform(geom.get_local_pose().to_transformation_matrix())
+        meshes.append(mesh)
+    return meshes
+
+
+def get_render_body_meshes(visual_body: sapien.render.RenderBodyComponent):
+    meshes = []
+    for render_shape in visual_body.render_shapes:
+        meshes += get_render_shape_meshes(render_shape)
+    return meshes
+
+
+def get_render_shape_meshes(render_shape: sapien.render.RenderShape):
+    meshes = []
+    if type(render_shape) == sapien.render.RenderShapeTriangleMesh:
+        for part in render_shape.parts:
+            vertices = part.vertices * render_shape.scale  # [n, 3]
+            faces = part.triangles
+            # faces = render_shape.mesh.indices.reshape(-1, 3)  # [m * 3]
+            mesh = trimesh.Trimesh(vertices=vertices, faces=faces)
+            mesh.apply_transform(render_shape.local_pose.to_transformation_matrix())
+            meshes.append(mesh)
+    return meshes
+
+
+def get_actor_visual_meshes(actor: sapien.Entity):
+    """Get actor (visual) meshes in the actor frame."""
+    meshes = []
+    comp = actor.find_component_by_type(sapien.render.RenderBodyComponent)
+    if comp is not None:
+        meshes.extend(get_render_body_meshes(comp))
+    return meshes
+
+
+def merge_meshes(meshes: List[trimesh.Trimesh]):
+    n, vs, fs = 0, [], []
+    for mesh in meshes:
+        v, f = mesh.vertices, mesh.faces
+        vs.append(v)
+        fs.append(f + n)
+        n = n + v.shape[0]
+    if n:
+        return trimesh.Trimesh(np.vstack(vs), np.vstack(fs))
+    else:
+        return None
+
+
+def get_component_mesh(component: physx.PhysxRigidBaseComponent, to_world_frame=True):
+    mesh = merge_meshes(get_component_meshes(component))
+    if mesh is None:
+        return None
+    if to_world_frame:
+        T = component.pose.to_transformation_matrix()
+        mesh.apply_transform(T)
+    return mesh
+
+
+def get_actor_visual_mesh(actor: sapien.Entity):
+    mesh = merge_meshes(get_actor_visual_meshes(actor))
+    if mesh is None:
+        return None
+    return mesh
+
+
+def get_articulation_meshes(
+    articulation: physx.PhysxArticulation, exclude_link_names=()
+):
+    """Get link meshes in the world frame."""
+    meshes = []
+    for link in articulation.get_links():
+        if link.name in exclude_link_names:
+            continue
+        mesh = get_component_mesh(link, True)
+        if mesh is None:
+            continue
+        meshes.append(mesh)
+    return meshes

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/__init__.py

@@ -0,0 +1 @@
+from .scene_builder import SceneBuilder

project/ManiSkill3/src/maniskill3_environment/mani_skill/utils/scene_builder/ai2thor/__init__.py

@@ -0,0 +1,6 @@
+from .variants import (
+    ArchitecTHORSceneBuilder,
+    ProcTHORSceneBuilder,
+    RoboTHORSceneBuilder,
+    iTHORSceneBuilder,
+)