Render API

gym/core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Generic, Optional, SupportsFloat, Tuple, TypeVar, Union
+from typing import Generic, List, Optional, SupportsFloat, Tuple, TypeVar, Union
 
 import gym
 from gym import spaces
@@ -122,41 +122,30 @@ def reset(
 
     @abstractmethod
     def render(self, mode="human"):
-        """Renders the environment.
+        """Compute the render(s) as specified by render_mode attribute during initialization of the environment.
 
         The set of supported modes varies per environment. (And some
         third-party environments may not support rendering at all.)
-        By convention, if mode is:
+        By convention, if render_mode is:
 
-        - human: render to the current display or terminal and
-          return nothing. Usually for human consumption.
-        - rgb_array: Return an numpy.ndarray with shape (x, y, 3),
-          representing RGB values for an x-by-y pixel image, suitable
-          for turning into a video.
-        - ansi: Return a string (str) or StringIO.StringIO containing a
-          terminal-style text representation. The text can include newlines
-          and ANSI escape sequences (e.g. for colors).
+        - None (default): no render is computed.
+        - human: render return None.
+          The environment is continuously rendered in the current display or terminal. Usually for human consumption.
+        - rgb_array: Return a list of frames. Each frame is a numpy.ndarray with shape (x, y, 3),
+          representing RGB values for an x-by-y pixel image.
+        - ansi: Return a list of strings (str) or StringIO.StringIO containing a
+          terminal-style text representation for each time step.
+          The text can include newlines and ANSI escape sequences (e.g. for colors).
 
         Note:
-            Make sure that your class's metadata 'render_modes' key includes
-              the list of supported modes. It's recommended to call super()
-              in implementations to use the functionality of this method.
-
-        Args:
-            mode (str): the mode to render with
-
-        Example::
+            Rendering computations is performed internally even if you don't call render().
+            To avoid this, you can set render_mode = None and, if the environment supports it,
+            call render() specifying the argument 'mode'.
 
-            class MyEnv(Env):
-                metadata = {'render_modes': ['human', 'rgb_array']}
-
-                def render(self, mode='human'):
-                    if mode == 'rgb_array':
-                        return np.array(...) # return RGB frame suitable for video
-                    elif mode == 'human':
-                        ... # pop up a window and render
-                    else:
-                        super(MyEnv, self).render(mode=mode) # just raise an exception
+        Note:
+            Make sure that your class's metadata 'render_modes' key includes
+            the list of supported modes. It's recommended to call super()
+            in implementations to use the functionality of this method.
         """
         raise NotImplementedError
 

gym/envs/box2d/bipedal_walker.py

@@ -18,6 +18,7 @@
 import gym
 from gym import error, spaces
 from gym.utils import EzPickle, colorize, seeding
+from gym.utils.renderer import Renderer
 
 FPS = 50
 SCALE = 30.0  # affects how fast-paced the game is, forces should be adjusted as well
@@ -154,12 +155,10 @@ class BipedalWalker(gym.Env, EzPickle):
 
     """
 
-    metadata = {"render_modes": ["human", "rgb_array"], "render_fps": FPS}
+    metadata = {"render_modes": [None, "human", "rgb_array"], "render_fps": FPS}
 
-    def __init__(self, hardcore: bool = False):
+    def __init__(self, render_mode: Optional[str] = None, hardcore: bool = False):
         EzPickle.__init__(self)
-        self.screen = None
-        self.clock = None
         self.isopen = True
 
         self.world = Box2D.b2World()
@@ -247,6 +246,11 @@ def __init__(self, hardcore: bool = False):
         # ]
         # state += [l.fraction for l in self.lidar]
 
+        assert render_mode in self.metadata["render_modes"]
+        self.renderer = Renderer(render_mode, self._render)
+        self.screen = None
+        self.clock = None
+
     def _destroy(self):
         if not self.terrain:
             return
@@ -498,6 +502,7 @@ def ReportFixture(self, fixture, point, normal, fraction):
                 return fraction
 
         self.lidar = [LidarCallback() for _ in range(10)]
+        self.renderer.reset()
         if not return_info:
             return self.step(np.array([0, 0, 0, 0]))[0]
         else:
@@ -587,141 +592,155 @@ def step(self, action: np.ndarray):
             done = True
         if pos[0] > (TERRAIN_LENGTH - TERRAIN_GRASS) * TERRAIN_STEP:
             done = True
+
+        self.renderer.render_step()
         return np.array(state, dtype=np.float32), reward, done, {}
 
     def render(self, mode: str = "human"):
-        import pygame
-        from pygame import gfxdraw
-
-        if self.screen is None:
-            pygame.init()
-            pygame.display.init()
-            self.screen = pygame.display.set_mode((VIEWPORT_W, VIEWPORT_H))
-        if self.clock is None:
-            self.clock = pygame.time.Clock()
-
-        self.surf = pygame.Surface((VIEWPORT_W + self.scroll * SCALE, VIEWPORT_H))
-
-        pygame.transform.scale(self.surf, (SCALE, SCALE))
-
-        pygame.draw.polygon(
-            self.surf,
-            color=(215, 215, 255),
-            points=[
-                (self.scroll * SCALE, 0),
-                (self.scroll * SCALE + VIEWPORT_W, 0),
-                (self.scroll * SCALE + VIEWPORT_W, VIEWPORT_H),
-                (self.scroll * SCALE, VIEWPORT_H),
-            ],
-        )
+        if self.renderer.mode is not None:
+            return self.renderer.get_renders()
+        else:
+            return self._render(mode)
+
+    def _render(self, mode: str = "human"):
+        if mode is not None:
+            import pygame
+            from pygame import gfxdraw
+
+            if self.screen is None and mode == "human":
+                pygame.init()
+                pygame.display.init()
+                self.screen = pygame.display.set_mode((VIEWPORT_W, VIEWPORT_H))
+            if self.clock is None:
+                self.clock = pygame.time.Clock()
+
+            self.surf = pygame.Surface((VIEWPORT_W + self.scroll * SCALE, VIEWPORT_H))
+
+            pygame.transform.scale(self.surf, (SCALE, SCALE))
 
-        for poly, x1, x2 in self.cloud_poly:
-            if x2 < self.scroll / 2:
-                continue
-            if x1 > self.scroll / 2 + VIEWPORT_W / SCALE:
-                continue
             pygame.draw.polygon(
                 self.surf,
-                color=(255, 255, 255),
+                color=(215, 215, 255),
                 points=[
-                    (p[0] * SCALE + self.scroll * SCALE / 2, p[1] * SCALE) for p in poly
+                    (self.scroll * SCALE, 0),
+                    (self.scroll * SCALE + VIEWPORT_W, 0),
+                    (self.scroll * SCALE + VIEWPORT_W, VIEWPORT_H),
+                    (self.scroll * SCALE, VIEWPORT_H),
                 ],
             )
-            gfxdraw.aapolygon(
-                self.surf,
-                [(p[0] * SCALE + self.scroll * SCALE / 2, p[1] * SCALE) for p in poly],
-                (255, 255, 255),
-            )
-        for poly, color in self.terrain_poly:
-            if poly[1][0] < self.scroll:
-                continue
-            if poly[0][0] > self.scroll + VIEWPORT_W / SCALE:
-                continue
-            scaled_poly = []
-            for coord in poly:
-                scaled_poly.append([coord[0] * SCALE, coord[1] * SCALE])
-            pygame.draw.polygon(self.surf, color=color, points=scaled_poly)
-            gfxdraw.aapolygon(self.surf, scaled_poly, color)
-
-        self.lidar_render = (self.lidar_render + 1) % 100
-        i = self.lidar_render
-        if i < 2 * len(self.lidar):
-            l = (
-                self.lidar[i]
-                if i < len(self.lidar)
-                else self.lidar[len(self.lidar) - i - 1]
-            )
-            pygame.draw.line(
-                self.surf,
-                color=(255, 0, 0),
-                start_pos=(l.p1[0] * SCALE, l.p1[1] * SCALE),
-                end_pos=(l.p2[0] * SCALE, l.p2[1] * SCALE),
-                width=1,
-            )
 
-        for obj in self.drawlist:
-            for f in obj.fixtures:
-                trans = f.body.transform
-                if type(f.shape) is circleShape:
-                    pygame.draw.circle(
-                        self.surf,
-                        color=obj.color1,
-                        center=trans * f.shape.pos * SCALE,
-                        radius=f.shape.radius * SCALE,
-                    )
-                    pygame.draw.circle(
+            for poly, x1, x2 in self.cloud_poly:
+                if x2 < self.scroll / 2:
+                    continue
+                if x1 > self.scroll / 2 + VIEWPORT_W / SCALE:
+                    continue
+                pygame.draw.polygon(
+                    self.surf,
+                    color=(255, 255, 255),
+                    points=[
+                        (p[0] * SCALE + self.scroll * SCALE / 2, p[1] * SCALE)
+                        for p in poly
+                    ],
+                )
+                gfxdraw.aapolygon(
+                    self.surf,
+                    [
+                        (p[0] * SCALE + self.scroll * SCALE / 2, p[1] * SCALE)
+                        for p in poly
+                    ],
+                    (255, 255, 255),
+                )
+            for poly, color in self.terrain_poly:
+                if poly[1][0] < self.scroll:
+                    continue
+                if poly[0][0] > self.scroll + VIEWPORT_W / SCALE:
+                    continue
+                scaled_poly = []
+                for coord in poly:
+                    scaled_poly.append([coord[0] * SCALE, coord[1] * SCALE])
+                pygame.draw.polygon(self.surf, color=color, points=scaled_poly)
+                gfxdraw.aapolygon(self.surf, scaled_poly, color)
+
+            self.lidar_render = (self.lidar_render + 1) % 100
+            i = self.lidar_render
+            if i < 2 * len(self.lidar):
+                l = (
+                    self.lidar[i]
+                    if i < len(self.lidar)
+                    else self.lidar[len(self.lidar) - i - 1]
+                )
+                if hasattr(l, "p1") and hasattr(l, "p2"):
+                    pygame.draw.line(
                         self.surf,
-                        color=obj.color2,
-                        center=trans * f.shape.pos * SCALE,
-                        radius=f.shape.radius * SCALE,
+                        color=(255, 0, 0),
+                        start_pos=(l.p1[0] * SCALE, l.p1[1] * SCALE),
+                        end_pos=(l.p2[0] * SCALE, l.p2[1] * SCALE),
+                        width=1,
                     )
-                else:
-                    path = [trans * v * SCALE for v in f.shape.vertices]
-                    if len(path) > 2:
-                        pygame.draw.polygon(self.surf, color=obj.color1, points=path)
-                        gfxdraw.aapolygon(self.surf, path, obj.color1)
-                        path.append(path[0])
-                        pygame.draw.polygon(
-                            self.surf, color=obj.color2, points=path, width=1
-                        )
-                        gfxdraw.aapolygon(self.surf, path, obj.color2)
-                    else:
-                        pygame.draw.aaline(
+
+            for obj in self.drawlist:
+                for f in obj.fixtures:
+                    trans = f.body.transform
+                    if type(f.shape) is circleShape:
+                        pygame.draw.circle(
                             self.surf,
-                            start_pos=path[0],
-                            end_pos=path[1],
                             color=obj.color1,
+                            center=trans * f.shape.pos * SCALE,
+                            radius=f.shape.radius * SCALE,
                         )
+                        pygame.draw.circle(
+                            self.surf,
+                            color=obj.color2,
+                            center=trans * f.shape.pos * SCALE,
+                            radius=f.shape.radius * SCALE,
+                        )
+                    else:
+                        path = [trans * v * SCALE for v in f.shape.vertices]
+                        if len(path) > 2:
+                            pygame.draw.polygon(
+                                self.surf, color=obj.color1, points=path
+                            )
+                            gfxdraw.aapolygon(self.surf, path, obj.color1)
+                            path.append(path[0])
+                            pygame.draw.polygon(
+                                self.surf, color=obj.color2, points=path, width=1
+                            )
+                            gfxdraw.aapolygon(self.surf, path, obj.color2)
+                        else:
+                            pygame.draw.aaline(
+                                self.surf,
+                                start_pos=path[0],
+                                end_pos=path[1],
+                                color=obj.color1,
+                            )
+
+            flagy1 = TERRAIN_HEIGHT * SCALE
+            flagy2 = flagy1 + 50
+            x = TERRAIN_STEP * 3 * SCALE
+            pygame.draw.aaline(
+                self.surf, color=(0, 0, 0), start_pos=(x, flagy1), end_pos=(x, flagy2)
+            )
+            f = [
+                (x, flagy2),
+                (x, flagy2 - 10),
+                (x + 25, flagy2 - 5),
+            ]
+            pygame.draw.polygon(self.surf, color=(230, 51, 0), points=f)
+            pygame.draw.lines(
+                self.surf, color=(0, 0, 0), points=f + [f[0]], width=1, closed=False
+            )
 
-        flagy1 = TERRAIN_HEIGHT * SCALE
-        flagy2 = flagy1 + 50
-        x = TERRAIN_STEP * 3 * SCALE
-        pygame.draw.aaline(
-            self.surf, color=(0, 0, 0), start_pos=(x, flagy1), end_pos=(x, flagy2)
-        )
-        f = [
-            (x, flagy2),
-            (x, flagy2 - 10),
-            (x + 25, flagy2 - 5),
-        ]
-        pygame.draw.polygon(self.surf, color=(230, 51, 0), points=f)
-        pygame.draw.lines(
-            self.surf, color=(0, 0, 0), points=f + [f[0]], width=1, closed=False
-        )
-
-        self.surf = pygame.transform.flip(self.surf, False, True)
-        self.screen.blit(self.surf, (-self.scroll * SCALE, 0))
-        if mode == "human":
-            pygame.event.pump()
-            self.clock.tick(self.metadata["render_fps"])
-            pygame.display.flip()
+            self.surf = pygame.transform.flip(self.surf, False, True)
 
-        if mode == "rgb_array":
-            return np.transpose(
-                np.array(pygame.surfarray.pixels3d(self.screen)), axes=(1, 0, 2)
-            )
-        else:
-            return self.isopen
+            if mode == "human":
+                self.screen.blit(self.surf, (-self.scroll * SCALE, 0))
+                pygame.event.pump()
+                self.clock.tick(self.metadata["render_fps"])
+                pygame.display.flip()
+            else:  # mode == "rgb_array":
+                return np.transpose(
+                    np.array(pygame.surfarray.pixels3d(self.surf)), axes=(1, 0, 2)
+                )
 
     def close(self):
         if self.screen is not None:
@@ -822,6 +841,5 @@ def __init__(self):
         a[3] = knee_todo[1]
         a = np.clip(0.5 * a, -1.0, 1.0)
 
-        env.render()
         if done:
             break