Use full size mesh terrain (#537)

use full size mesh terrain

metadrive/engine/core/terrain.py

@@ -36,7 +36,8 @@ def __init__(self, show_terrain, engine):
             CamMask.MiniMap | CamMask.Shadow | CamMask.DepthCam | CamMask.ScreenshotCam | CamMask.SemanticCam
         )
         # use plane terrain or mesh terrain， True by default.
-        self.plane_terrain = engine.global_config["plane_terrain"]
+        self.use_mesh_terrain = engine.global_config["use_mesh_terrain"]
+        self.full_size_mesh = engine.global_config["full_size_mesh"]
 
         # collision mesh
         self.plane_collision_terrain = None  # a flat collision shape
@@ -71,7 +72,7 @@ def __init__(self, show_terrain, engine):
             # self.probe.set_pos(0, 0, self.PROBE_HEIGHT)
             # self.probe.set_scale(self.PROBE_SIZE * 2, self.PROBE_SIZE * 2, 1000)
 
-        if not self.plane_terrain or self.render:
+        if self.use_mesh_terrain or self.render:
             self._load_height_field_image(engine)
 
     # @time_me
@@ -83,11 +84,11 @@ def reset(self, center_position):
         assert self.engine is not None, "Can not call this without initializing engine"
         self.detach_from_world(self.engine.physics_world)
 
-        if self.plane_terrain and self.plane_collision_terrain is None:
+        if not self.use_mesh_terrain and self.plane_collision_terrain is None:
             # only generate once if plane terrain
             self.generate_plane_collision_terrain()
 
-        if self.render or not self.plane_terrain:
+        if self.render or self.use_mesh_terrain:
             # modify default height image
             drivable_region = self.engine.current_map.get_height_map(
                 self._heightmap_size, 1, self._drivable_area_extension
@@ -109,8 +110,10 @@ def reset(self, center_position):
                              ...] = np.where(drivable_region, self._terrain_offset, heightfield_to_modify)
 
             # generate collision mesh
-            if not self.plane_terrain:
-                self._generate_collision_mesh(heightfield_to_modify, self._height_scale)
+            if self.use_mesh_terrain:
+                self._generate_collision_mesh(
+                    heightfield_base if self.full_size_mesh else heightfield_to_modify, self._height_scale
+                )
 
             if self.render:
                 # Make semantics for shader terrain
@@ -304,7 +307,7 @@ def set_position(self, position, height=None):
             self._mesh_terrain.set_pos(*pos, 0)
             if self.probe is not None:
                 self.probe.set_pos(*pos, self.PROBE_HEIGHT)
-        if not self.plane_terrain:
+        if self.use_mesh_terrain:
             self.mesh_collision_terrain.set_pos(*position[:2], self._height_scale)
 
     def _generate_card_terrain(self):

metadrive/envs/base_env.py

@@ -200,7 +200,9 @@
     # height scale for mountains, unit: [m]
     height_scale=50,
     # use plane collision or mesh collision
-    plane_terrain=True,
+    use_mesh_terrain=False,
+    # use full-size mesh terrain
+    full_size_mesh=True,
 
     # ===== Others =====
     # Force to generate objects in the left lane.

metadrive/tests/test_policy/test_expert_performance.py

@@ -63,7 +63,7 @@ def test_expert_with_traffic(plane, use_render=False):
         dict(
             num_scenarios=1,
             map="CCC",
-            plane_terrain=plane,
+            use_mesh_terrain=plane,
             start_seed=2,
             random_traffic=False,
             # debug_static_world=True,

metadrive/tests/test_policy/test_idm_policy.py

@@ -28,9 +28,9 @@ def _create_vehicle():
     return v
 
 
-@pytest.mark.parametrize("plane_terrain", [True, False], ids=["plane", "mesh"])
-def test_idm_policy_briefly(plane_terrain):
-    env = MetaDriveEnv({"plane_terrain": plane_terrain})
+@pytest.mark.parametrize("use_mesh_terrain", [True, False], ids=["plane", "mesh"])
+def test_idm_policy_briefly(use_mesh_terrain):
+    env = MetaDriveEnv({"use_mesh_terrain": use_mesh_terrain})
     env.reset()
     try:
         vehicles = env.engine.traffic_manager.traffic_vehicles
@@ -54,10 +54,10 @@ def test_idm_policy_briefly(plane_terrain):
         env.close()
 
 
-@pytest.mark.parametrize("plane_terrain", [True, False], ids=["plane", "mesh"])
-def test_idm_policy_is_moving(plane_terrain, render=False, in_test=True):
+@pytest.mark.parametrize("use_mesh_terrain", [True, False], ids=["plane", "mesh"])
+def test_idm_policy_is_moving(use_mesh_terrain, render=False, in_test=True):
     # config = {"traffic_mode": "hybrid", "map": "SS", "traffic_density": 1.0}
-    config = {"plane_terrain": plane_terrain, "traffic_mode": "respawn", "map": "SS", "traffic_density": 1.0}
+    config = {"use_mesh_terrain": use_mesh_terrain, "traffic_mode": "respawn", "map": "SS", "traffic_density": 1.0}
     if render:
         config.update({"use_render": True, "manual_control": True})
     env = MetaDriveEnv(config)

metadrive/tests/vis_env/vis_metadrive_env.py

@@ -26,7 +26,7 @@
             # "random_agent_model": False,
             "manual_control": True,
             "use_render": True,
-            "plane_terrain": False,
+            "use_mesh_terrain": False,
             "accident_prob": 1,
             "decision_repeat": 5,
             "daytime": "19:00",