[Question] how can i set different usd in different env

[437142188]

Question

when i use below code to set my env for parellel training, i cannot get different usd model correctly.

def _setup_scene(self):
        self.robot = Articulation(self.cfg.robot_cfg)
        # add ground plane
        spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())

        map_paths = [
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_02_collider.usd",
            f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_29_collider_1.usd",
        ]
        
        num_envs = self.scene.cfg.num_envs
        
        for env_idx in range(num_envs):
            map_path = map_paths[env_idx % len(map_paths)]
            
            prim_path = f"/World/envs/env_{env_idx}/narrow_gap_localmap"
            
            cfg = sim_utils.UsdFileCfg(
                usd_path=map_path,
                rigid_props=sim_utils.RigidBodyPropertiesCfg(
                    rigid_body_enabled=True,
                    kinematic_enabled=True,
                    disable_gravity=True,
                ),
                collision_props=sim_utils.CollisionPropertiesCfg(
                    collision_enabled=True,
                ),
                activate_contact_sensors=False,
            )
            
            cfg.func(
                prim_path, cfg,
                translation=(-1.0, -1.0, -0.1),
                orientation=(1, 0.0, 0.0, 0)
            )

        # clone and replicate
        self.scene.clone_environments(
            copy_from_source=False,
        )

        # add lights
        light_cfg = sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75))
        light_cfg.func("/World/Light", light_cfg)
        # add raycaster
        self.lidar_2d = MultiMeshRayCaster(self.cfg.lidar_2d)
        self.scene.sensors["lidar_2d"] = self.lidar_2d
        # add contact
        self.contact_sensor = ContactSensor(self.cfg.contact_sensor)
        self.scene.sensors["contact_sensor"] = self.contact_sensor

        # add articulation to scene
        self.scene.articulations["robot"] = self.robot

        self.scene.filter_collisions(
            global_prim_paths=["/World/ground"],
        )

        self.visualization_markers = define_markers()

        self.up_dir = torch.tensor([0.0, 0.0, 1.0]).cuda()  
        self.yaws = torch.zeros((self.cfg.scene.num_envs, 1)).cuda()
        self.commands = torch.randn((self.cfg.scene.num_envs, 3)).cuda()
        self.commands[:,-1] = 0.0
        self.commands = self.commands/torch.linalg.norm(self.commands, dim=1, keepdim=True)
        
        # offsets to account for atan range and keep things on [-pi, pi]
        ratio = self.commands[:,1]/(self.commands[:,0]+1E-8)
        gzero = torch.where(self.commands > 0, True, False)
        lzero = torch.where(self.commands < 0, True, False)
        plus = lzero[:,0]*gzero[:,1]
        minus = lzero[:,0]*lzero[:,1]
        offsets = torch.pi*plus - torch.pi*minus
        self.yaws = torch.atan(ratio).reshape(-1,1) + offsets.reshape(-1,1)

        self.marker_locations = torch.zeros((self.cfg.scene.num_envs, 3)).cuda()
        self.marker_offset = torch.zeros((self.cfg.scene.num_envs, 3)).cuda()
        self.marker_offset[:,-1] = 0.5
        self.forward_marker_orientations = torch.zeros((self.cfg.scene.num_envs, 4)).cuda()
        self.command_marker_orientations = torch.zeros((self.cfg.scene.num_envs, 4)).cuda()

as the picture shows, all the lidar in different env percept same mesh, although they visual not same type. Beside, all the envs have same collider feature that shows in env0 usd file, maybe i am not use correct usd import function, Thanks for help me!

Build Info

Describe the versions that you are currently using:

• Isaac Lab Version: 2.2.0
• Isaac Sim Version: 5.0.0

[RandomOakForest]

Thank you for posting this. Each environment is still “seeing” the same USD because all your gap meshes are being spawned in the source env before calling clone_environments, and the clone step is then replicating only that source layout and physics, not the per-env variation you expect. In other words, all lidar sensors end up ray-casting against the same collider set even if the visuals differ.¹²

In Isaac Lab, clone_environments(copy_from_source=False) only controls whether the original USD prims are shared or separately instantiated, but it still uses the source environment’s prims and physics setup as a template for all envs. To get different USD maps per environment, you must:²¹

1. Create an explicit per-environment root prim and spawn the USD into that prim, not directly into /World/envs/env_0/... before cloning.
2. Disable replication of that prim in the scene config so the cloning logic does not override your custom per-env USD placement.
3. Spawn the different USDs after clone_environments, using env_indices or per-env prim paths that already exist for each cloned env.

A robust approach is:

• In your InteractiveSceneCfg, set up the maps as generic USD prims that are not part of the replicated categories (articulations/sensors). Then, in _setup_scene:

def _setup_scene(self):
    self.robot = Articulation(self.cfg.robot_cfg)

    # ground first
    spawn_ground_plane(prim_path="/World/ground", cfg=GroundPlaneCfg())

    # clone and replicate only robots, sensors, etc.
    self.scene.clone_environments(copy_from_source=False)

    # now spawn per-env USDs under each env root
    map_paths = [
        f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_02_collider.usd",
        f"{ISAAC_NUCLEUS_DIR}/Environments/Narrow_gap/localmap_29_collider_1.usd",
    ]
    num_envs = self.scene.cfg.num_envs

    for env_idx in range(num_envs):
        map_path = map_paths[env_idx % len(map_paths)]
        # use the already-created env root
        prim_path = f"/World/envs/env_{env_idx}/narrow_gap_localmap"

        cfg = sim_utils.UsdFileCfg(
            usd_path=map_path,
            rigid_props=sim_utils.RigidBodyPropertiesCfg(
                rigid_body_enabled=True,
                kinematic_enabled=True,
                disable_gravity=True,
            ),
            collision_props=sim_utils.CollisionPropertiesCfg(
                collision_enabled=True,
            ),
            activate_contact_sensors=False,
        )
        cfg.func(
            prim_path=prim_path,
            cfg=cfg,
            translation=(-1.0, -1.0, -0.1),
            orientation=(1.0, 0.0, 0.0, 0.0),
        )

    # register robot & sensors AFTER cloning
    self.scene.articulations["robot"] = self.robot
    self.lidar_2d = MultiMeshRayCaster(self.cfg.lidar_2d)
    self.scene.sensors["lidar_2d"] = self.lidar_2d
    self.contact_sensor = ContactSensor(self.cfg.contact_sensor)
    self.scene.sensors["contact_sensor"] = self.contact_sensor

This sequence makes sure:

• clone_environments only builds env_0, env_1, ... roots and clones the robot/sensors layout.¹
• The narrow gap USD is spawned separately in each env with a different file path, so physics and ray-casting see different meshes per env.

Why lidar still saw same mesh

Ray casting uses the shared PhysX scene; if multiple USDs share the same prim name and are cloned from the same source env, they all reference the same underlying collider setup. By spawning after cloning into env-specific prim paths, each gap map has its own collider prims, and MultiMeshRayCaster can correctly intersect only what belongs to that env.³⁴

Footnotes

1. https://isaac-sim.github.io/IsaacLab/main/source/setup/walkthrough/technical_env_design.html ↩ ↩² ↩³

2. https://isaac-sim.github.io/IsaacLab/main/source/api/lab/isaaclab.scene.html ↩ ↩²

3. https://isaac-sim.github.io/IsaacLab/main/source/how-to/multi_asset_spawning.html ↩

4. https://forums.developer.nvidia.com/t/collision-rigid-body-sim-not-working-with-different-assets/245386 ↩