miniworld-maze 1.0.0__py3-none-any.whl

miniworld_maze/core/miniworld_gymnasium/rendering_engine.py

@@ -0,0 +1,293 @@
+"""
+Centralized rendering system for MiniWorld environments.
+
+This module provides a comprehensive rendering architecture that separates
+OpenGL state management from high-level rendering logic, providing better
+maintainability and testability.
+"""
+
+from typing import Any, Optional
+
+import numpy as np
+from pyglet.gl import *
+from pyglet.gl.glu import *
+
+from ..observation_types import ObservationLevel
+from .rendering.framebuffer import FrameBuffer
+
+
+class OpenGLContextManager:
+    """Manage OpenGL state and context switching."""
+
+    def __init__(self):
+        """Initialize OpenGL context manager."""
+        self._saved_state = {}
+
+    def save_state(self):
+        """Save current OpenGL state."""
+        self._saved_state = {
+            "viewport": (GLint * 4)(),
+            "projection_matrix": (GLfloat * 16)(),
+            "modelview_matrix": (GLfloat * 16)(),
+        }
+        glGetIntegerv(GL_VIEWPORT, self._saved_state["viewport"])
+        glGetFloatv(GL_PROJECTION_MATRIX, self._saved_state["projection_matrix"])
+        glGetFloatv(GL_MODELVIEW_MATRIX, self._saved_state["modelview_matrix"])
+
+    def restore_state(self):
+        """Restore previously saved OpenGL state."""
+        if self._saved_state:
+            glViewport(*self._saved_state["viewport"])
+            glMatrixMode(GL_PROJECTION)
+            glLoadMatrixf(self._saved_state["projection_matrix"])
+            glMatrixMode(GL_MODELVIEW)
+            glLoadMatrixf(self._saved_state["modelview_matrix"])
+
+    def rendering_context(self):
+        """Context manager for safe rendering state management."""
+        return RenderingContext(self)
+
+
+class RenderingContext:
+    """Context manager for OpenGL rendering state."""
+
+    def __init__(self, context_manager: OpenGLContextManager):
+        """Initialize rendering context with OpenGL context manager."""
+        self.context_manager = context_manager
+
+    def __enter__(self):
+        """Enter rendering context and save OpenGL state."""
+        self.context_manager.save_state()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Exit rendering context and restore OpenGL state."""
+        self.context_manager.restore_state()
+
+
+class FrameBufferManager:
+    """Manage frame buffers and resolution handling."""
+
+    def __init__(self, obs_width: int, obs_height: int):
+        """Initialize framebuffer manager with default observation dimensions."""
+        self.obs_width = obs_width
+        self.obs_height = obs_height
+        self.frame_buffers = {}
+
+    def get_or_create_framebuffer(
+        self, name: str, width: Optional[int] = None, height: Optional[int] = None
+    ) -> FrameBuffer:
+        """Get existing framebuffer or create new one."""
+        width = width or self.obs_width
+        height = height or self.obs_height
+        key = (name, width, height)
+
+        if key not in self.frame_buffers:
+            self.frame_buffers[key] = FrameBuffer(width, height)
+
+        return self.frame_buffers[key]
+
+    def cleanup(self):
+        """Clean up all frame buffers."""
+        for fb in self.frame_buffers.values():
+            if hasattr(fb, "cleanup"):
+                fb.cleanup()
+        self.frame_buffers.clear()
+
+
+class CameraSystem:
+    """Handle camera positioning and projection matrices."""
+
+    def __init__(self):
+        """Initialize camera system with configuration cache."""
+        self.camera_configs = {}
+
+    def get_config(self, obs_level: ObservationLevel, agent: Any) -> dict:
+        """Get camera configuration for observation level."""
+        if obs_level == ObservationLevel.FIRST_PERSON:
+            return {
+                "type": "perspective",
+                "position": agent.pos + np.array([0, agent.cam_height, 0]),
+                "direction": agent.dir_vec,
+                "up": np.array([0, 1, 0]),
+                "fov": agent.cam_fov_y,
+            }
+        elif obs_level in [
+            ObservationLevel.TOP_DOWN_PARTIAL,
+            ObservationLevel.TOP_DOWN_FULL,
+        ]:
+            return {
+                "type": "orthographic",
+                "position": agent.pos + np.array([0, 10, 0]),  # High above
+                "direction": np.array([0, -1, 0]),  # Looking down
+                "up": np.array([0, 0, -1]),  # Z-axis points up in top view
+                "bounds": self._calculate_view_bounds(obs_level, agent),
+            }
+        else:
+            raise ValueError(f"Unsupported observation level: {obs_level}")
+
+    def _calculate_view_bounds(self, obs_level: ObservationLevel, agent: Any) -> dict:
+        """Calculate view bounds for top-down rendering."""
+        if obs_level == ObservationLevel.TOP_DOWN_PARTIAL:
+            # POMDP view - limited around agent
+            view_size = 8.0  # Configurable view size
+            return {
+                "left": agent.pos[0] - view_size,
+                "right": agent.pos[0] + view_size,
+                "bottom": agent.pos[2] - view_size,
+                "top": agent.pos[2] + view_size,
+            }
+        else:
+            # Full view - would need environment bounds
+            return {"left": -20, "right": 20, "bottom": -20, "top": 20}
+
+    def setup_camera(self, config: dict, frame_buffer: FrameBuffer):
+        """Setup camera projection and view matrices."""
+        glMatrixMode(GL_PROJECTION)
+        glLoadIdentity()
+
+        if config["type"] == "perspective":
+            aspect_ratio = frame_buffer.width / frame_buffer.height
+            # Setup perspective projection
+            gluPerspective(config["fov"], aspect_ratio, 0.04, 100.0)
+        elif config["type"] == "orthographic":
+            bounds = config["bounds"]
+            glOrtho(
+                bounds["left"],
+                bounds["right"],
+                bounds["bottom"],
+                bounds["top"],
+                0.01,
+                100.0,
+            )
+
+        glMatrixMode(GL_MODELVIEW)
+        glLoadIdentity()
+
+        # Setup view matrix
+        pos = config["position"]
+        direction = config["direction"]
+        up = config["up"]
+        target = pos + direction
+
+        gluLookAt(
+            pos[0], pos[1], pos[2], target[0], target[1], target[2], up[0], up[1], up[2]
+        )
+
+
+class RenderingEngine:
+    """Centralized rendering system for MiniWorld environments."""
+
+    def __init__(self, obs_width: int, obs_height: int):
+        """Initialize rendering engine with all subsystems."""
+        self.context_manager = OpenGLContextManager()
+        self.framebuffer_manager = FrameBufferManager(obs_width, obs_height)
+        self.camera_system = CameraSystem()
+
+        self.obs_width = obs_width
+        self.obs_height = obs_height
+
+    def render_observation(
+        self,
+        obs_level: ObservationLevel,
+        agent: Any,
+        entities: list,
+        rooms: list,
+        frame_buffer: Optional[FrameBuffer] = None,
+    ) -> np.ndarray:
+        """Unified observation rendering."""
+        if frame_buffer is None:
+            frame_buffer = self.framebuffer_manager.get_or_create_framebuffer("obs")
+
+        camera_config = self.camera_system.get_config(obs_level, agent)
+
+        with self.context_manager.rendering_context():
+            frame_buffer.bind()
+            self.camera_system.setup_camera(camera_config, frame_buffer)
+            self._setup_scene()
+            self._render_entities_and_rooms(
+                entities,
+                rooms,
+                agent,
+                render_agent=(obs_level != ObservationLevel.FIRST_PERSON),
+            )
+            img = frame_buffer.resolve()
+
+        return img
+
+    def render_top_view(
+        self,
+        agent: Any,
+        entities: list,
+        rooms: list,
+        POMDP: bool = False,
+        render_agent: bool = True,
+        frame_buffer: Optional[FrameBuffer] = None,
+    ) -> np.ndarray:
+        """Render top-down view of the environment."""
+        if frame_buffer is None:
+            frame_buffer = self.framebuffer_manager.get_or_create_framebuffer("topview")
+
+        obs_level = (
+            ObservationLevel.TOP_DOWN_PARTIAL
+            if POMDP
+            else ObservationLevel.TOP_DOWN_FULL
+        )
+        camera_config = self.camera_system.get_config(obs_level, agent)
+
+        with self.context_manager.rendering_context():
+            frame_buffer.bind()
+            self.camera_system.setup_camera(camera_config, frame_buffer)
+            self._setup_scene()
+            self._render_entities_and_rooms(entities, rooms, agent, render_agent)
+            img = frame_buffer.resolve()
+
+        return img
+
+    def _setup_scene(self):
+        """Setup basic OpenGL scene state."""
+        # Clear buffers
+        glClearColor(0.8, 0.9, 1.0, 1.0)  # Light blue background
+        glClearDepth(1.0)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        # Enable depth testing
+        glEnable(GL_DEPTH_TEST)
+        glDepthFunc(GL_LESS)
+
+        # Enable face culling
+        glEnable(GL_CULL_FACE)
+        glCullFace(GL_BACK)
+        glFrontFace(GL_CCW)
+
+        # Setup lighting (basic ambient light)
+        glEnable(GL_LIGHTING)
+        glEnable(GL_LIGHT0)
+
+        light_pos = (GLfloat * 4)(10.0, 10.0, 10.0, 1.0)
+        light_ambient = (GLfloat * 4)(0.2, 0.2, 0.2, 1.0)
+        light_diffuse = (GLfloat * 4)(0.8, 0.8, 0.8, 1.0)
+
+        glLightfv(GL_LIGHT0, GL_POSITION, light_pos)
+        glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient)
+        glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse)
+
+    def _render_entities_and_rooms(
+        self, entities: list, rooms: list, agent: Any, render_agent: bool = True
+    ):
+        """Render all entities and rooms in the scene."""
+        # Render rooms first (floors, walls, ceilings)
+        for room in rooms:
+            if hasattr(room, "_render"):
+                room._render()
+
+        # Render entities
+        for entity in entities:
+            if entity is agent and not render_agent:
+                continue
+            if hasattr(entity, "render"):
+                entity.render()
+
+    def cleanup(self):
+        """Clean up rendering resources."""
+        self.framebuffer_manager.cleanup()

miniworld_maze/core/miniworld_gymnasium/room.py

@@ -0,0 +1,330 @@
+"""Room class for MiniWorld environments."""
+
+import numpy as np
+from pyglet.gl import *
+
+from .math import Y_VEC
+from .opengl import Texture
+from .texture_utils import gen_texcs_floor, gen_texcs_wall
+
+# Default wall height for room
+DEFAULT_WALL_HEIGHT = 2.74
+
+
+class Room:
+    """Represent an individual room and its contents"""
+
+    def __init__(
+        self,
+        outline,
+        wall_height=DEFAULT_WALL_HEIGHT,
+        floor_tex="floor_tiles_bw",
+        wall_tex="concrete",
+        ceil_tex="concrete_tiles",
+        no_ceiling=False,
+    ):
+        # The outlien should have shape Nx2
+        assert len(outline.shape) == 2
+        assert outline.shape[1] == 2
+        assert outline.shape[0] >= 3
+
+        # Add a Y coordinate to the outline points
+        outline = np.insert(outline, 1, 0, axis=1)
+
+        # Number of outline vertices / walls
+        self.num_walls = outline.shape[0]
+
+        # List of 2D points forming the outline of the room
+        # Shape is Nx3
+        self.outline = outline
+
+        # Compute the min and max x, z extents
+        self.min_x = self.outline[:, 0].min()
+        self.max_x = self.outline[:, 0].max()
+        self.min_z = self.outline[:, 2].min()
+        self.max_z = self.outline[:, 2].max()
+
+        # Compute midpoint coordinates
+        self.mid_x = (self.max_x + self.min_x) / 2
+        self.mid_z = (self.max_z + self.min_z) / 2
+
+        # Compute approximate surface area
+        self.area = (self.max_x - self.min_x) * (self.max_z - self.min_z)
+
+        # Compute room edge directions and normals
+        # Compute edge vectors (p1 - p0)
+        # For the first point, p0 is the last
+        # For the last point, p0 is p_n-1
+        next_pts = np.concatenate(
+            [self.outline[1:], np.expand_dims(self.outline[0], axis=0)], axis=0
+        )
+        self.edge_dirs = next_pts - self.outline
+        self.edge_dirs = (self.edge_dirs.T / np.linalg.norm(self.edge_dirs, axis=1)).T
+        self.edge_norms = -np.cross(self.edge_dirs, Y_VEC)
+        self.edge_norms = (
+            self.edge_norms.T / np.linalg.norm(self.edge_norms, axis=1)
+        ).T
+
+        # Height of the room walls
+        self.wall_height = wall_height
+
+        # No ceiling flag
+        self.no_ceiling = no_ceiling
+
+        # Texture names
+        self.wall_tex_name = wall_tex
+        self.floor_tex_name = floor_tex
+        self.ceil_tex_name = ceil_tex
+
+        # Lists of portals, indexed by wall/edge index
+        self.portals = [[] for i in range(self.num_walls)]
+
+        # List of neighbor rooms
+        # Same length as list of portals
+        self.neighbors = []
+
+    def add_portal(
+        self,
+        edge,
+        start_pos=None,
+        end_pos=None,
+        min_x=None,
+        max_x=None,
+        min_z=None,
+        max_z=None,
+        min_y=0,
+        max_y=None,
+    ):
+        """Create a new portal/opening in a wall of this room"""
+
+        if max_y is None:
+            max_y = self.wall_height
+
+        assert edge <= self.num_walls
+        assert max_y > min_y
+
+        # Get the edge points, compute the direction vector
+        e_p0 = self.outline[edge]
+        e_p1 = self.outline[(edge + 1) % self.num_walls]
+        e_len = np.linalg.norm(e_p1 - e_p0)
+        e_dir = (e_p1 - e_p0) / e_len
+        x0, _, z0 = e_p0
+        x1, _, z1 = e_p1
+        dx, _, dz = e_dir
+
+        # If the portal extents are specified by x coordinates
+        if min_x is not None:
+            assert min_z is None and max_z is None
+            assert start_pos is None and end_pos is None
+            assert x0 != x1
+
+            m0 = (min_x - x0) / dx
+            m1 = (max_x - x0) / dx
+
+            if m1 < m0:
+                m0, m1 = m1, m0
+
+            start_pos, end_pos = m0, m1
+
+        # If the portal extents are specified by z coordinates
+        elif min_z is not None:
+            assert min_x is None and max_x is None
+            assert start_pos is None and end_pos is None
+            assert z0 != z1
+
+            m0 = (min_z - z0) / dz
+            m1 = (max_z - z0) / dz
+
+            if m1 < m0:
+                m0, m1 = m1, m0
+
+            start_pos, end_pos = m0, m1
+
+        else:
+            assert min_x is None and max_x is None
+            assert min_z is None and max_z is None
+
+        assert end_pos > start_pos
+        assert start_pos >= 0, "portal outside of wall extents"
+        assert end_pos <= e_len, "portal outside of wall extents"
+
+        self.portals[edge].append(
+            {"start_pos": start_pos, "end_pos": end_pos, "min_y": min_y, "max_y": max_y}
+        )
+
+        # Sort the portals by start position
+        self.portals[edge].sort(key=lambda e: e["start_pos"])
+
+        return start_pos, end_pos
+
+    def point_inside(self, p):
+        """Test if a point is inside the room"""
+
+        # Vector from edge start to test point
+        ap = p - self.outline
+
+        # Compute the dot products of normals to AP vectors
+        dotNAP = np.sum(self.edge_norms * ap, axis=1)
+
+        # The point is inside if all the dot products are greater than zero
+        return np.all(np.greater(dotNAP, 0))
+
+    def _gen_static_data(self, params, rng):
+        """Generate polygons and static data for this room
+
+        Needed for rendering and collision detection
+        Note: the wall polygons are quads, but the floor and
+              ceiling can be arbitrary n-gons
+        """
+        self._load_textures(rng)
+        self._generate_floor_geometry()
+        self._generate_ceiling_geometry()
+        self._generate_wall_geometry()
+        self._finalize_wall_geometry()
+
+    def _load_textures(self, rng):
+        """Load and randomize room textures."""
+        self.wall_tex = Texture.get(self.wall_tex_name, rng)
+        self.floor_tex = Texture.get(self.floor_tex_name, rng)
+        self.ceil_tex = Texture.get(self.ceil_tex_name, rng)
+
+    def _generate_floor_geometry(self):
+        """Generate floor vertices and texture coordinates."""
+        self.floor_verts = self.outline
+        self.floor_texcs = gen_texcs_floor(self.floor_tex, self.floor_verts)
+
+    def _generate_ceiling_geometry(self):
+        """Generate ceiling vertices and texture coordinates."""
+        # Flip the ceiling vertex order because of backface culling
+        self.ceil_verts = np.flip(self.outline, axis=0) + self.wall_height * Y_VEC
+        self.ceil_texcs = gen_texcs_floor(self.ceil_tex, self.ceil_verts)
+
+    def _generate_wall_geometry(self):
+        """Generate wall vertices, normals, texture coordinates, and collision segments."""
+        self.wall_verts = []
+        self.wall_norms = []
+        self.wall_texcs = []
+        self.wall_segs = []
+
+        def gen_seg_poly(edge_p0, side_vec, seg_start, seg_end, min_y, max_y):
+            if seg_end == seg_start:
+                return
+
+            if min_y == max_y:
+                return
+
+            s_p0 = edge_p0 + seg_start * side_vec
+            s_p1 = edge_p0 + seg_end * side_vec
+
+            # If this polygon starts at ground level, add a collidable segment
+            if min_y == 0:
+                self.wall_segs.append(np.array([s_p1, s_p0]))
+
+            # Generate the vertices
+            # Vertices are listed in counter-clockwise order
+            self.wall_verts.append(s_p0 + min_y * Y_VEC)
+            self.wall_verts.append(s_p0 + max_y * Y_VEC)
+            self.wall_verts.append(s_p1 + max_y * Y_VEC)
+            self.wall_verts.append(s_p1 + min_y * Y_VEC)
+
+            # Compute the normal for the polygon
+            normal = np.cross(s_p1 - s_p0, Y_VEC)
+            normal = -normal / np.linalg.norm(normal)
+            for i in range(4):
+                self.wall_norms.append(normal)
+
+            # Generate the texture coordinates
+            texcs = gen_texcs_wall(
+                self.wall_tex, seg_start, min_y, seg_end - seg_start, max_y - min_y
+            )
+            self.wall_texcs.append(texcs)
+
+        # For each wall
+        for wall_idx in range(self.num_walls):
+            edge_p0 = self.outline[wall_idx, :]
+            edge_p1 = self.outline[(wall_idx + 1) % self.num_walls, :]
+            wall_width = np.linalg.norm(edge_p1 - edge_p0)
+            side_vec = (edge_p1 - edge_p0) / wall_width
+
+            if len(self.portals[wall_idx]) > 0:
+                seg_end = self.portals[wall_idx][0]["start_pos"]
+            else:
+                seg_end = wall_width
+
+            # Generate the first polygon (going up to the first portal)
+            gen_seg_poly(edge_p0, side_vec, 0, seg_end, 0, self.wall_height)
+
+            # For each portal in this wall
+            for portal_idx, portal in enumerate(self.portals[wall_idx]):
+                portal = self.portals[wall_idx][portal_idx]
+                start_pos = portal["start_pos"]
+                end_pos = portal["end_pos"]
+                min_y = portal["min_y"]
+                max_y = portal["max_y"]
+
+                # Generate the bottom polygon
+                gen_seg_poly(edge_p0, side_vec, start_pos, end_pos, 0, min_y)
+
+                # Generate the top polygon
+                gen_seg_poly(
+                    edge_p0, side_vec, start_pos, end_pos, max_y, self.wall_height
+                )
+
+                if portal_idx < len(self.portals[wall_idx]) - 1:
+                    next_portal = self.portals[wall_idx][portal_idx + 1]
+                    next_portal_start = next_portal["start_pos"]
+                else:
+                    next_portal_start = wall_width
+
+                # Generate the polygon going up to the next portal
+                gen_seg_poly(
+                    edge_p0, side_vec, end_pos, next_portal_start, 0, self.wall_height
+                )
+
+    def _finalize_wall_geometry(self):
+        """Convert wall geometry lists to numpy arrays."""
+        self.wall_verts = np.array(self.wall_verts)
+        self.wall_norms = np.array(self.wall_norms)
+
+        if len(self.wall_segs) > 0:
+            self.wall_segs = np.array(self.wall_segs)
+        else:
+            self.wall_segs = np.array([]).reshape(0, 2, 3)
+
+        if len(self.wall_texcs) > 0:
+            self.wall_texcs = np.concatenate(self.wall_texcs)
+        else:
+            self.wall_texcs = np.array([]).reshape(0, 2)
+
+    def _render(self):
+        """Render the static elements of the room"""
+
+        glColor3f(1, 1, 1)
+
+        # Draw the floor
+        self.floor_tex.bind()
+        glBegin(GL_POLYGON)
+        glNormal3f(0, 1, 0)
+        for i in range(self.floor_verts.shape[0]):
+            glTexCoord2f(*self.floor_texcs[i, :])
+            glVertex3f(*self.floor_verts[i, :])
+        glEnd()
+
+        # Draw the ceiling
+        if not self.no_ceiling:
+            self.ceil_tex.bind()
+            glBegin(GL_POLYGON)
+            glNormal3f(0, -1, 0)
+            for i in range(self.ceil_verts.shape[0]):
+                glTexCoord2f(*self.ceil_texcs[i, :])
+                glVertex3f(*self.ceil_verts[i, :])
+            glEnd()
+
+        # Draw the walls
+        self.wall_tex.bind()
+        glBegin(GL_QUADS)
+        for i in range(self.wall_verts.shape[0]):
+            glNormal3f(*self.wall_norms[i, :])
+            glTexCoord2f(*self.wall_texcs[i, :])
+            glVertex3f(*self.wall_verts[i, :])
+        glEnd()

miniworld_maze/core/miniworld_gymnasium/texture_utils.py

@@ -0,0 +1,64 @@
+"""Texture utility functions for MiniWorld environments."""
+
+import numpy as np
+
+# Texture size/density in texels/meter
+TEX_DENSITY = 512
+
+
+def gen_texcs_wall(tex, min_x, min_y, width, height):
+    """
+    Generate texture coordinates for a wall quad.
+
+    Maps wall surface dimensions to texture coordinates based on texture density.
+
+    Args:
+        tex: Texture object with width/height properties
+        min_x (float): Minimum x coordinate of wall surface
+        min_y (float): Minimum y coordinate of wall surface
+        width (float): Width of wall surface
+        height (float): Height of wall surface
+
+    Returns:
+        np.ndarray: 4x2 array of texture coordinates for wall quad vertices
+    """
+    xc = TEX_DENSITY / tex.width
+    yc = TEX_DENSITY / tex.height
+
+    min_u = (min_x) * xc
+    max_u = (min_x + width) * xc
+    min_v = (min_y) * yc
+    max_v = (min_y + height) * yc
+
+    return np.array(
+        [
+            [min_u, min_v],
+            [min_u, max_v],
+            [max_u, max_v],
+            [max_u, min_v],
+        ],
+        dtype=np.float32,
+    )
+
+
+def gen_texcs_floor(tex, poss):
+    """
+    Generate texture coordinates for floor or ceiling surfaces.
+
+    Maps 3D world positions directly to 2D texture coordinates by projecting
+    x,z coordinates onto texture space using texture density scaling.
+
+    Args:
+        tex: Texture object with width/height properties
+        poss (np.ndarray): Nx3 array of 3D world positions
+
+    Returns:
+        np.ndarray: Nx2 array of texture coordinates
+    """
+    texc_mul = np.array(
+        [TEX_DENSITY / tex.width, TEX_DENSITY / tex.height], dtype=float
+    )
+
+    coords = np.stack([poss[:, 0], poss[:, 2]], axis=1) * texc_mul
+
+    return coords