miniworld-maze 1.0.0__py3-none-any.whl

miniworld_maze/core/miniworld_gymnasium/objmesh.py

@@ -0,0 +1,294 @@
+"""OBJ mesh loading and rendering utilities for MiniWorld environments."""
+
+import os
+
+import numpy as np
+import pyglet
+
+from .opengl import *
+from .utils import *
+
+
+class ObjMesh:
+    """
+    Load and render OBJ model files for 3D entity meshes.
+
+    Provides functionality to load Wavefront OBJ files, parse vertices and faces,
+    and render them using OpenGL. Includes mesh caching for performance.
+    """
+
+    # Loaded mesh files, indexed by mesh file path
+    cache = {}
+
+    @classmethod
+    def get(self, mesh_name):
+        """
+        Load a mesh or used a cached version
+        """
+
+        # Assemble the absolute path to the mesh file
+        file_path = get_file_path("meshes", mesh_name, "obj")
+
+        if file_path in self.cache:
+            return self.cache[file_path]
+
+        mesh = ObjMesh(file_path)
+        self.cache[file_path] = mesh
+
+        return mesh
+
+    def __init__(self, file_path):
+        """
+        Load an OBJ model file
+
+        Limitations:
+        - only one object/group
+        - only triangle faces
+        """
+
+        # OBJ file format:
+        # #Comments
+        # mtllib file_name
+        # o object_name
+        # v x y z
+        # vt u v
+        # vn x y z
+        # usemtl mtl_name
+        # f v0/t0/n0 v1/t1/n1 v2/t2/n2
+
+        # print('Loading mesh "%s"' % file_path)
+
+        # Attempt to load the materials library
+        materials = self._load_mtl(file_path)
+        mesh_file = open(file_path, "r")
+
+        verts = []
+        texs = []
+        normals = []
+        faces = []
+
+        cur_mtl = ""
+
+        # For each line of the input file
+        for line in mesh_file:
+            line = line.rstrip(" \r\n")
+
+            # Skip comments
+            if line.startswith("#") or line == "":
+                continue
+
+            tokens = line.split(" ")
+            tokens = map(lambda t: t.strip(" "), tokens)
+            tokens = list(filter(lambda t: t != "", tokens))
+
+            prefix = tokens[0]
+            tokens = tokens[1:]
+
+            if prefix == "v":
+                vert = list(map(lambda v: float(v), tokens))
+                verts.append(vert)
+
+            if prefix == "vt":
+                tc = list(map(lambda v: float(v), tokens))
+                texs.append(tc)
+
+            if prefix == "vn":
+                normal = list(map(lambda v: float(v), tokens))
+                normals.append(normal)
+
+            if prefix == "usemtl":
+                mtl_name = tokens[0]
+                if mtl_name in materials:
+                    cur_mtl = mtl_name
+                else:
+                    cur_mtl = ""
+
+            if prefix == "f":
+                assert len(tokens) == 3, "only triangle faces are supported"
+
+                face = []
+                for token in tokens:
+                    indices = filter(lambda t: t != "", token.split("/"))
+                    indices = list(map(lambda idx: int(idx), indices))
+                    assert len(indices) == 2 or len(indices) == 3
+                    face.append(indices)
+
+                faces.append([face, cur_mtl])
+
+        # Sort the faces by material name
+        faces.sort(key=lambda f: f[1])
+
+        # Compute the start and end faces for each chunk in the model
+        cur_mtl = None
+        chunks = []
+        for idx, face in enumerate(faces):
+            face, mtl_name = face
+            if mtl_name != cur_mtl:
+                if len(chunks) > 0:
+                    chunks[-1]["end_idx"] = idx
+                chunks.append(
+                    {"mtl": materials[mtl_name], "start_idx": idx, "end_idx": None}
+                )
+                cur_mtl = mtl_name
+        chunks[-1]["end_idx"] = len(faces)
+
+        num_faces = len(faces)
+        # print('num verts=%d' % len(verts))
+        # print('num faces=%d' % num_faces)
+        # print('num chunks=%d' % len(chunks))
+
+        # Create numpy arrays to store the vertex data
+        list_verts = np.zeros(shape=(num_faces, 3, 3), dtype=np.float32)
+        list_norms = np.zeros(shape=(num_faces, 3, 3), dtype=np.float32)
+        list_texcs = np.zeros(shape=(num_faces, 3, 2), dtype=np.float32)
+        list_color = np.zeros(shape=(num_faces, 3, 3), dtype=np.float32)
+
+        # For each triangle
+        for f_idx, face in enumerate(faces):
+            face, mtl_name = face
+
+            # Get the color for this face
+            f_mtl = materials[mtl_name]
+            f_color = f_mtl["Kd"] if f_mtl else np.array((1, 1, 1))
+
+            # For each tuple of indices
+            for l_idx, indices in enumerate(face):
+                # Note: OBJ uses 1-based indexing
+                # and texture coordinates are optional
+                if len(indices) == 3:
+                    v_idx, t_idx, n_idx = indices
+                    vert = verts[v_idx - 1]
+                    texc = texs[t_idx - 1]
+                    normal = normals[n_idx - 1]
+                else:
+                    v_idx, n_idx = indices
+                    vert = verts[v_idx - 1]
+                    normal = normals[n_idx - 1]
+                    texc = [0, 0]
+
+                list_verts[f_idx, l_idx, :] = vert
+                list_texcs[f_idx, l_idx, :] = texc
+                list_norms[f_idx, l_idx, :] = normal
+                list_color[f_idx, l_idx, :] = f_color
+
+        # Re-center the object so that the base is at y=0
+        # and the object is centered in x and z
+        min_coords = list_verts.min(axis=0).min(axis=0)
+        max_coords = list_verts.max(axis=0).min(axis=0)
+        mean_coords = (min_coords + max_coords) / 2
+        min_y = min_coords[1]
+        mean_x = mean_coords[0]
+        mean_z = mean_coords[2]
+        list_verts[:, :, 1] -= min_y
+        list_verts[:, :, 0] -= mean_x
+        list_verts[:, :, 2] -= mean_z
+
+        # Recompute the object extents after centering
+        self.min_coords = list_verts.min(axis=0).min(axis=0)
+        self.max_coords = list_verts.max(axis=0).max(axis=0)
+
+        # Vertex lists, one per chunk
+        self.vlists = []
+
+        # Textures, one per chunk
+        self.textures = []
+
+        # For each chunk
+        for chunk in chunks:
+            start_idx = chunk["start_idx"]
+            end_idx = chunk["end_idx"]
+            num_faces_chunk = end_idx - start_idx
+
+            # Create a vertex list to be used for rendering
+            vlist = pyglet.graphics.vertex_list(
+                3 * num_faces_chunk,
+                ("v3f", list_verts[start_idx:end_idx, :, :].reshape(-1)),
+                ("t2f", list_texcs[start_idx:end_idx, :, :].reshape(-1)),
+                ("n3f", list_norms[start_idx:end_idx, :, :].reshape(-1)),
+                ("c3f", list_color[start_idx:end_idx, :, :].reshape(-1)),
+            )
+
+            mtl = chunk["mtl"]
+            if "map_Kd" in mtl:
+                texture = Texture.load(mtl["map_Kd"])
+            else:
+                texture = None
+
+            self.vlists.append(vlist)
+            self.textures.append(texture)
+
+    def _load_mtl(self, model_file):
+        model_dir, file_name = os.path.split(model_file)
+
+        # Create a default material for the model
+        default_mtl = {
+            "Kd": np.array([1, 1, 1]),
+        }
+
+        # Determine the default texture path for the default material
+        tex_name = file_name.split(".")[0]
+        tex_path = get_file_path("meshes", tex_name, "png")
+        if os.path.exists(tex_path):
+            default_mtl["map_Kd"] = tex_path
+
+        materials = {"": default_mtl}
+
+        mtl_path = model_file.split(".")[0] + ".mtl"
+
+        if not os.path.exists(mtl_path):
+            return materials
+
+        # print('Loading materials from "%s"' % mtl_path)
+
+        mtl_file = open(mtl_path, "r")
+
+        cur_mtl = None
+
+        # For each line of the input file
+        for line in mtl_file:
+            line = line.rstrip(" \r\n")
+
+            # Skip comments
+            if line.startswith("#") or line == "":
+                continue
+
+            tokens = line.split(" ")
+            tokens = map(lambda t: t.strip(" "), tokens)
+            tokens = list(filter(lambda t: t != "", tokens))
+
+            prefix = tokens[0]
+            tokens = tokens[1:]
+
+            if prefix == "newmtl":
+                cur_mtl = {}
+                materials[tokens[0]] = cur_mtl
+
+            # Diffuse color
+            if prefix == "Kd":
+                vals = list(map(lambda v: float(v), tokens))
+                vals = np.array(vals)
+                cur_mtl["Kd"] = vals
+
+            # Texture file name
+            if prefix == "map_Kd":
+                tex_file = tokens[-1]
+                tex_file = os.path.join(model_dir, tex_file)
+                cur_mtl["map_Kd"] = tex_file
+
+        mtl_file.close()
+
+        return materials
+
+    def render(self):
+        for idx, vlist in enumerate(self.vlists):
+            texture = self.textures[idx]
+
+            if texture:
+                glEnable(GL_TEXTURE_2D)
+                glBindTexture(texture.target, texture.id)
+            else:
+                glDisable(GL_TEXTURE_2D)
+
+            vlist.draw(GL_TRIANGLES)
+
+        glDisable(GL_TEXTURE_2D)

miniworld_maze/core/miniworld_gymnasium/occlusion_queries.py

@@ -0,0 +1,97 @@
+"""OpenGL occlusion query utilities for MiniWorld environments."""
+
+from typing import List, Set
+
+from pyglet.gl import *
+
+from .entities import Entity
+
+
+class OcclusionQueryManager:
+    """
+    Manages OpenGL occlusion queries for entity visibility detection.
+
+    This class handles the lifecycle of OpenGL occlusion queries, providing
+    a clean interface for determining which entities are visible to the agent.
+    """
+
+    def __init__(self, entities: List[Entity]):
+        """
+        Initialize occlusion query manager.
+
+        Args:
+            entities: List of entities to test for visibility
+        """
+        self.entities = entities
+        self.num_entities = len(entities)
+
+        # Allocate OpenGL query IDs
+        self.query_ids = (GLuint * self.num_entities)()
+        glGenQueries(self.num_entities, self.query_ids)
+
+    def begin_query(self, entity_index: int) -> None:
+        """
+        Begin occlusion query for specific entity.
+
+        Args:
+            entity_index: Index of entity in the entities list
+        """
+        if entity_index >= self.num_entities:
+            raise IndexError(f"Entity index {entity_index} out of range")
+
+        glBeginQuery(GL_ANY_SAMPLES_PASSED, self.query_ids[entity_index])
+
+    def end_query(self) -> None:
+        """End the current occlusion query."""
+        glEndQuery(GL_ANY_SAMPLES_PASSED)
+
+    def get_query_result(self, entity_index: int) -> bool:
+        """
+        Get the result of an occlusion query.
+
+        Args:
+            entity_index: Index of entity in the entities list
+
+        Returns:
+            True if entity is visible (any samples passed), False otherwise
+        """
+        if entity_index >= self.num_entities:
+            raise IndexError(f"Entity index {entity_index} out of range")
+
+        visible = (GLuint * 1)(1)
+        glGetQueryObjectuiv(self.query_ids[entity_index], GL_QUERY_RESULT, visible)
+        return visible[0] != 0
+
+    def get_visible_entities(self, agent: Entity) -> Set[Entity]:
+        """
+        Get all entities that are visible (excluding the agent).
+
+        Args:
+            agent: The agent entity to exclude from results
+
+        Returns:
+            Set of visible entities
+        """
+        visible_entities = set()
+
+        for entity_index, entity in enumerate(self.entities):
+            if entity is agent:
+                continue
+
+            if self.get_query_result(entity_index):
+                visible_entities.add(entity)
+
+        return visible_entities
+
+    def cleanup(self) -> None:
+        """Clean up OpenGL resources."""
+        if hasattr(self, "query_ids"):
+            glDeleteQueries(self.num_entities, self.query_ids)
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit with automatic cleanup."""
+        self.cleanup()

miniworld_maze/core/miniworld_gymnasium/opengl.py

@@ -0,0 +1,21 @@
+"""OpenGL utilities for MiniWorld environments.
+
+This module now imports from the refactored rendering modules for better organization.
+"""
+
+import os
+
+import pyglet
+
+# Solution to https://github.com/maximecb/gym-miniworld/issues/24
+# until pyglet support egl officially
+if os.environ.get("PYOPENGL_PLATFORM", None) == "egl":
+    pyglet.options["headless"] = True
+
+from pyglet.gl import *
+
+# Import all classes and functions from the refactored modules
+from .rendering import FrameBuffer, Texture, drawAxes, drawBox
+
+# Export everything for backward compatibility
+__all__ = ["Texture", "FrameBuffer", "drawAxes", "drawBox"]

miniworld_maze/core/miniworld_gymnasium/params.py

@@ -0,0 +1,128 @@
+from collections import namedtuple
+from copy import deepcopy
+
+import numpy as np
+
+# Simulation parameter, with domain randomization range
+# The default value is used when domain randomization is disabled
+DomainParam = namedtuple("Domainparam", ["default", "min", "max", "type"])
+
+
+class DomainParams:
+    """
+    Set of simulation parameters
+    """
+
+    def __init__(self):
+        # Dictionary of parameters, indexed by name
+        self.params = {}
+
+    def copy(self):
+        return deepcopy(self)
+
+    def no_random(self):
+        """
+        Make a copy in which randomization is disabled for all parameters
+        This is useful to then selectively enable randomization on a
+        limited subset of the parameters.
+        """
+
+        copy = self.copy()
+
+        for name, p in copy.params.items():
+            copy.params[name] = DomainParam(p.default, p.default, p.default, p.type)
+
+        return copy
+
+    def set(self, name, default, min=None, max=None, type="float"):
+        """
+        Register/modify a named parameter
+        """
+
+        if isinstance(default, list):
+            default = np.array(default)
+        if isinstance(min, list):
+            min = np.array(min)
+        if isinstance(max, list):
+            max = np.array(max)
+
+        if min is None:
+            min = default
+        if max is None:
+            max = default
+
+        if isinstance(default, np.ndarray):
+            assert max.shape == default.shape
+            assert min.shape == max.shape
+            assert np.all(np.greater_equal(max, default))
+            assert np.all(np.greater_equal(default, min))
+
+            if type == "float":
+                default = default.astype("float")
+                min = min.astype("float")
+                max = max.astype("float")
+        else:
+            assert max >= default
+            assert default >= min
+
+        # Validation when modifying existing parameters
+        if name in self.params:
+            p = self.params[name]
+            assert type == p.type
+            if isinstance(p.default, np.ndarray):
+                assert default.shape == p.default.shape
+
+        self.params[name] = DomainParam(default, min, max, type)
+
+    def get_max(self, name):
+        assert name in self.params, name
+        p = self.params[name]
+        return p.max
+
+    def sample(self, rng, name):
+        """
+        Sample a single parameter
+        Note: when rng is None, the default value is returned, which
+        has the effect of turning off domain randomization
+        """
+
+        assert name in self.params, name
+        p = self.params[name]
+
+        if rng is None:
+            return p.default
+
+        if p.type == "float":
+            return rng.float(p.min, p.max)
+        elif p.type == "int":
+            return rng.int(p.min, p.max + 1)
+
+        assert False
+
+    def sample_many(self, rng, target_obj, param_names):
+        """
+        Sample a list of parameters
+        """
+
+        for name in param_names:
+            setattr(target_obj, name, self.sample(rng, name))
+
+
+# Default simulation parameters
+DEFAULT_PARAMS = DomainParams()
+DEFAULT_PARAMS.set("black", [0.00, 0.00, 0.00], [0.00, 0.00, 0.00], [0.00, 0.00, 0.00])
+DEFAULT_PARAMS.set("sky_color", [0.25, 0.82, 1], [0.1, 0.1, 0.1], [1.0, 1.0, 1.0])
+DEFAULT_PARAMS.set("light_pos", [0, 2.5, 0], [-40, 2.5, -40], [40, 5, 40])
+DEFAULT_PARAMS.set("light_color", [0.7, 0.7, 0.7], [0.45, 0.45, 0.45], [0.8, 0.8, 0.8])
+DEFAULT_PARAMS.set(
+    "light_ambient", [0.45, 0.45, 0.45], [0.35, 0.35, 0.35], [0.55, 0.55, 0.55]
+)
+DEFAULT_PARAMS.set("obj_color_bias", [0, 0, 0], [-0.2, -0.2, -0.2], [0.2, 0.2, 0.2])
+DEFAULT_PARAMS.set("forward_step", 0.15, 0.12, 0.17)
+DEFAULT_PARAMS.set("forward_drift", 0, -0.05, 0.05)
+DEFAULT_PARAMS.set("turn_step", 15, 10, 20)
+DEFAULT_PARAMS.set("bot_radius", 0.4, 0.38, 0.42)
+DEFAULT_PARAMS.set("cam_pitch", 0, -5, 5)
+DEFAULT_PARAMS.set("cam_fov_y", 60, 55, 65)
+DEFAULT_PARAMS.set("cam_height", 1.5, 1.45, 1.55)
+DEFAULT_PARAMS.set("cam_fwd_disp", 0, -0.05, 0.10)

miniworld_maze/core/miniworld_gymnasium/random.py

@@ -0,0 +1,105 @@
+"""Random number generation utilities for MiniWorld environments."""
+
+from gymnasium.utils import seeding
+
+
+class RandGen:
+    """
+    Thread-safe random value generator for environment simulation.
+
+    Provides consistent random number generation across different runs
+    when seeded properly, which is essential for reproducible experiments.
+    """
+
+    def __init__(self, seed=None):
+        """Initialize random generator with optional seed."""
+        self.np_random, _ = seeding.np_random(seed)
+
+    def random_int(self, low, high):
+        """
+        Generate random integer in the range [low, high).
+
+        Args:
+            low: Lower bound (inclusive)
+            high: Upper bound (exclusive)
+
+        Returns:
+            Random integer in specified range
+        """
+        return self.np_random.integers(low, high)
+
+    def random_float(self, low, high, shape=None):
+        """
+        Generate random float(s) in the range [low, high).
+
+        Args:
+            low: Lower bound (inclusive)
+            high: Upper bound (exclusive)
+            shape: Optional shape for array output
+
+        Returns:
+            Random float or array of floats in specified range
+        """
+        return self.np_random.uniform(low, high, size=shape)
+
+    def random_bool(self):
+        """
+        Generate random boolean value with 50/50 probability.
+
+        Returns:
+            Random boolean (True or False)
+        """
+
+        return self.np_random.integers(0, 2) == 0
+
+    def choice(self, iterable, probs=None):
+        """
+        Pick a random element in a list
+        """
+
+        lst = list(iterable)
+        idx = self.np_random.choice(len(lst), p=probs)
+        return lst[idx]
+
+    def random_color(self):
+        """
+        Pick a random color name
+        """
+
+        from .entities.base_entity import COLOR_NAMES
+
+        return self.choice(COLOR_NAMES)
+
+    def subset(self, iterable, num_elems):
+        """
+        Sample a random subset of distinct elements of a list
+        """
+
+        lst = list(iterable)
+        assert num_elems <= len(lst)
+
+        out = []
+
+        while len(out) < num_elems:
+            elem = self.choice(lst)
+            lst.remove(elem)
+            out.append(elem)
+
+        return out
+
+    # Backward compatibility aliases
+    def int(self, low, high):
+        """Legacy alias for random_int (deprecated: shadows built-in)"""
+        return self.random_int(low, high)
+
+    def float(self, low, high, shape=None):
+        """Legacy alias for random_float (deprecated: shadows built-in)"""
+        return self.random_float(low, high, shape)
+
+    def bool(self):
+        """Legacy alias for random_bool (deprecated: shadows built-in)"""
+        return self.random_bool()
+
+    def color(self):
+        """Legacy alias for random_color (deprecated: not descriptive)"""
+        return self.random_color()

miniworld_maze/core/miniworld_gymnasium/rendering/__init__.py

@@ -0,0 +1,7 @@
+"""Rendering modules for MiniWorld environments."""
+
+from .drawing import drawAxes, drawBox
+from .framebuffer import FrameBuffer
+from .texture import Texture
+
+__all__ = ["Texture", "FrameBuffer", "drawAxes", "drawBox"]