maps4fs 2.8.2__py3-none-any.whl → 2.8.3__py3-none-any.whl

maps4fs/generator/component/background.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import os
 import shutil
 from copy import deepcopy
-from typing import Any
+from typing import Any, Literal
 
 import cv2
 import numpy as np
@@ -57,6 +57,14 @@ class Background(MeshComponent, ImageComponent):
         os.makedirs(self.background_directory, exist_ok=True)
         os.makedirs(self.water_directory, exist_ok=True)
 
+        self.textured_mesh_directory = os.path.join(self.background_directory, "textured_mesh")
+        os.makedirs(self.textured_mesh_directory, exist_ok=True)
+
+        self.assets_background_directory = os.path.join(self.map.assets_directory, "background")
+        self.assets_water_directory = os.path.join(self.map.assets_directory, "water")
+        os.makedirs(self.assets_background_directory, exist_ok=True)
+        os.makedirs(self.assets_water_directory, exist_ok=True)
+
         self.water_resources_path = os.path.join(self.water_directory, "water_resources.png")
 
         self.output_path = os.path.join(self.background_directory, f"{Parameters.FULL}.png")
@@ -110,8 +118,28 @@ class Background(MeshComponent, ImageComponent):
 
         if self.map.background_settings.generate_background:
             self.generate_obj_files()
+            if self.game.mesh_processing:
+                self.logger.debug("Mesh processing is enabled, will decimate, texture and convert.")
+                self.decimate_background_mesh()
+                self.texture_background_mesh()
+                background_conversion_result = self.convert_background_mesh_to_i3d()
+                if background_conversion_result:
+                    self.add_note_file(asset="background")
+            else:
+                self.logger.warning(
+                    "Mesh processing is disabled for the game, skipping background mesh processing."
+                )
         if self.map.background_settings.generate_water:
             self.generate_water_resources_obj()
+            if self.game.mesh_processing:
+                self.logger.debug("Mesh processing is enabled, will convert water mesh to i3d.")
+                water_conversion_result = self.convert_water_mesh_to_i3d()
+                if water_conversion_result:
+                    self.add_note_file(asset="water")
+            else:
+                self.logger.warning(
+                    "Mesh processing is disabled for the game, skipping water mesh processing."
+                )
 
     def create_foundations(self, dem_image: np.ndarray) -> np.ndarray:
         """Creates foundations for buildings based on the DEM data.
@@ -253,6 +281,257 @@ class Background(MeshComponent, ImageComponent):
             remove_center=self.map.background_settings.remove_center,
         )
 
+    @staticmethod
+    def get_decimate_factor(map_size: int) -> float:
+        """Returns the decimation factor based on the map size.
+
+        Arguments:
+            map_size (int): The size of the map in pixels.
+
+        Raises:
+            ValueError: If the map size is too large for decimation.
+
+        Returns:
+            float -- The decimation factor.
+        """
+        thresholds = {
+            2048: 0.1,
+            4096: 0.05,
+            8192: 0.025,
+            16384: 0.0125,
+        }
+        for threshold, factor in thresholds.items():
+            if map_size <= threshold:
+                return factor
+        raise ValueError(
+            "Map size is too large for decimation, perform manual decimation in Blender."
+        )
+
+    @staticmethod
+    def get_background_texture_resolution(map_size: int) -> int:
+        """Returns the background texture resolution based on the map size.
+
+        Arguments:
+            map_size (int): The size of the map in pixels.
+
+        Returns:
+            int -- The background texture resolution.
+        """
+        resolutions = {
+            2048: 2048,
+            4096: Parameters.MAXIMUM_BACKGROUND_TEXTURE_SIZE,
+            8192: Parameters.MAXIMUM_BACKGROUND_TEXTURE_SIZE,
+            16384: Parameters.MAXIMUM_BACKGROUND_TEXTURE_SIZE,
+        }
+        for threshold, resolution in resolutions.items():
+            if map_size <= threshold:
+                return resolution
+        return Parameters.MAXIMUM_BACKGROUND_TEXTURE_SIZE
+
+    def decimate_background_mesh(self) -> None:
+        """ ""Decimates the background mesh based on the map size."""
+        if not self.assets.background_mesh or not os.path.isfile(self.assets.background_mesh):
+            self.logger.warning("Background mesh not found, cannot generate i3d background.")
+            return
+
+        try:
+            mesh = trimesh.load_mesh(self.assets.background_mesh, force="mesh")
+        except Exception as e:
+            self.logger.error("Could not load background mesh: %s", e)
+            return
+
+        try:
+            decimate_factor = self.get_decimate_factor(self.map_size)
+        except ValueError as e:
+            self.logger.error("Could not determine decimation factor: %s", e)
+            return
+
+        decimated_save_path = os.path.join(
+            self.background_directory, f"{Parameters.DECIMATED_BACKGROUND}.obj"
+        )
+        try:
+            self.logger.debug("Decimating background mesh with factor %s.", decimate_factor)
+            decimated_mesh = self.decimate_mesh(mesh, decimate_factor)
+            self.logger.debug("Decimation completed.")
+        except Exception as e:
+            self.logger.error("Could not decimate background mesh: %s", e)
+            return
+
+        decimated_mesh.export(decimated_save_path)
+        self.logger.debug("Decimated background mesh saved: %s", decimated_save_path)
+
+        self.assets.decimated_background_mesh = decimated_save_path
+
+    def texture_background_mesh(self) -> None:
+        """Textures the background mesh using satellite imagery."""
+        satellite_component = self.map.get_satellite_component()
+        if not satellite_component:
+            self.logger.warning("Satellite component not found, cannot texture background mesh.")
+            return
+
+        background_texture_path = satellite_component.assets.background
+
+        if not background_texture_path or not os.path.isfile(background_texture_path):
+            self.logger.warning("Background texture not found, cannot texture background mesh.")
+            return
+
+        decimated_background_mesh_path = self.assets.decimated_background_mesh
+        if not decimated_background_mesh_path or not os.path.isfile(decimated_background_mesh_path):
+            self.logger.warning(
+                "Decimated background mesh not found, cannot texture background mesh."
+            )
+            return
+
+        background_texture_resolution = self.get_background_texture_resolution(self.map_size)
+        non_resized_texture_image = cv2.imread(background_texture_path, cv2.IMREAD_UNCHANGED)
+
+        if non_resized_texture_image is None:
+            self.logger.error(
+                "Failed to read background texture image: %s", background_texture_path
+            )
+            return
+
+        resized_texture_image = cv2.resize(
+            non_resized_texture_image,  # type: ignore
+            (background_texture_resolution, background_texture_resolution),
+            interpolation=cv2.INTER_AREA,
+        )
+
+        resized_texture_save_path = os.path.join(
+            self.textured_mesh_directory,
+            "background_texture.jpg",
+        )
+
+        cv2.imwrite(resized_texture_save_path, resized_texture_image)
+        self.logger.debug("Resized background texture saved: %s", resized_texture_save_path)
+
+        decimated_mesh = trimesh.load_mesh(decimated_background_mesh_path, force="mesh")
+
+        if decimated_mesh is None:
+            self.logger.error("Failed to load decimated mesh after all retry attempts")
+            return
+
+        try:
+            obj_save_path, mtl_save_path = self.texture_mesh(
+                decimated_mesh,
+                resized_texture_save_path,
+                output_directory=self.textured_mesh_directory,
+                output_name="background_textured_mesh",
+            )
+
+            self.assets.textured_background_mesh = obj_save_path
+            self.assets.textured_background_mtl = mtl_save_path
+            self.assets.resized_background_texture = resized_texture_save_path
+            self.logger.debug("Textured background mesh saved: %s", obj_save_path)
+        except Exception as e:
+            self.logger.error("Could not texture background mesh: %s", e)
+            return
+
+    def convert_background_mesh_to_i3d(self) -> bool:
+        """Converts the textured background mesh to i3d format.
+
+        Returns:
+            bool -- True if the conversion was successful, False otherwise.
+        """
+        if not self.assets.textured_background_mesh or not os.path.isfile(
+            self.assets.textured_background_mesh
+        ):
+            self.logger.warning("Textured background mesh not found, cannot convert to i3d.")
+            return False
+
+        if not self.assets.resized_background_texture or not os.path.isfile(
+            self.assets.resized_background_texture
+        ):
+            self.logger.warning("Resized background texture not found, cannot convert to i3d.")
+            return False
+
+        try:
+            mesh = trimesh.load_mesh(self.assets.textured_background_mesh, force="mesh")
+        except Exception as e:
+            self.logger.error("Could not load textured background mesh: %s", e)
+            return False
+
+        try:
+            i3d_background_terrain = self.mesh_to_i3d(
+                mesh,
+                output_dir=self.assets_background_directory,
+                name=Parameters.BACKGROUND_TERRAIN,
+                texture_path=self.assets.resized_background_texture,
+                water_mesh=False,
+            )
+            self.logger.debug(
+                "Background mesh converted to i3d successfully: %s", i3d_background_terrain
+            )
+            self.assets.background_terrain_i3d = i3d_background_terrain
+            return True
+        except Exception as e:
+            self.logger.error("Could not convert background mesh to i3d: %s", e)
+            return False
+
+    def add_note_file(self, asset: Literal["background", "water"]) -> None:
+        """Adds a note file to the background or water directory.
+
+        Arguments:
+            asset (Literal["background", "water"]): The asset type to add the note file to.
+        """
+        filename = "DO_NOT_USE_THESE_FILES.txt"
+        note_template = (
+            "Please find the ready-to-use {asset} i3d files in the {asset_directory} directory."
+        )
+        directory = {
+            "background": self.background_directory,
+            "water": self.water_directory,
+        }
+
+        content = (
+            "The files in this directory can be used to create the mesh files manually in Blender. "
+            "However, it's recommended to use the ready-to-use i3d files located in the assets "
+            "directory. There you'll find the i3d files, that can be imported directly into the "
+            "Giants Editor without any additional processing."
+        )
+        note = note_template.format(
+            asset=asset,
+            asset_directory=f"assets/{asset}",
+        )
+
+        file_path = os.path.join(directory[asset], filename)
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(content + "\n\n" + note)
+
+    def convert_water_mesh_to_i3d(self) -> bool:
+        """Converts the line-based water mesh to i3d format.
+
+        Returns:
+            bool -- True if the conversion was successful, False otherwise.
+        """
+        if not self.assets.line_based_water_mesh or not os.path.isfile(
+            self.assets.line_based_water_mesh
+        ):
+            self.logger.warning("Line-based water mesh not found, cannot convert to i3d.")
+            return False
+
+        try:
+            mesh = trimesh.load_mesh(self.assets.line_based_water_mesh, force="mesh")
+        except Exception as e:
+            self.logger.error("Could not load line-based water mesh: %s", e)
+            return False
+
+        try:
+            i3d_water_resources = self.mesh_to_i3d(
+                mesh,
+                output_dir=self.assets_water_directory,
+                name=Parameters.WATER_RESOURCES,
+                water_mesh=True,
+            )
+            self.logger.debug(
+                "Water resources mesh converted to i3d successfully: %s", i3d_water_resources
+            )
+            self.assets.water_resources_i3d = i3d_water_resources
+            return True
+        except Exception as e:
+            self.logger.error("Could not convert water mesh to i3d: %s", e)
+            return False
+
     def save_map_dem(self, dem_path: str, save_path: str | None = None) -> str:
         """Cuts out the center of the DEM (the actual map) and saves it as a separate file.
 
@@ -623,6 +902,8 @@ class Background(MeshComponent, ImageComponent):
         mesh.export(line_based_save_path)
         self.logger.debug("Line-based water mesh saved to %s", line_based_save_path)
 
+        self.assets.line_based_water_mesh = line_based_save_path
+
     def mesh_from_3d_polygons(
         self, polygons: list[shapely.Polygon], single_z_value: int | None = None
     ) -> Trimesh | None:

maps4fs/generator/component/base/component.py

@@ -22,12 +22,31 @@ if TYPE_CHECKING:
 
 
 class AttrDict(dict):
-    """A dictionary that allows attribute-style access to its keys."""
+    """A dictionary that allows attribute-style access to its keys.
+    Allows safe access to non-existing keys, returning None instead of raising KeyError.
+    """
+
+    def __getattr__(self, name: str) -> Any | None:
+        """Returns the value of the given key or None if the key does not exist.
 
-    def __getattr__(self, name):
-        return self[name]
+        Arguments:
+            name (str): The key to retrieve.
 
-    def __setattr__(self, name, value):
+        Returns:
+            Any | None: The value of the key or None if the key does not exist.
+        """
+        try:
+            return self[name]
+        except KeyError:
+            return None
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Sets the value of the given key.
+
+        Arguments:
+            name (str): The key to set.
+            value (Any): The value to set.
+        """
         self[name] = value
 
 

maps4fs/generator/component/base/component_image.py

@@ -4,6 +4,7 @@ import os
 
 import cv2
 import numpy as np
+from PIL import Image, ImageFile
 
 from maps4fs.generator.component.base.component import Component
 from maps4fs.generator.settings import Parameters
@@ -237,3 +238,35 @@ class ImageComponent(Component):
         edge_mask = cv2.subtract(bigger_mask, smaller_mask)
 
         return self.blur_by_mask(data, edge_mask)
+
+    @staticmethod
+    def convert_png_to_dds(input_png_path: str, output_dds_path: str):
+        """Convert a PNG file to DDS format using PIL
+
+        Arguments:
+            input_png_path (str): Path to input PNG file
+            output_dds_path (str): Path for output DDS file
+
+        Raises:
+            FileNotFoundError: If the input PNG file does not exist.
+            RuntimeError: If the DDS conversion fails.
+        """
+        if not os.path.exists(input_png_path):
+            raise FileNotFoundError(f"Input PNG file not found: {input_png_path}")
+
+        try:
+            ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+            with Image.open(input_png_path) as img:
+                # Convert to RGB if needed (DDS works better with RGB)
+                if img.mode == "RGBA":
+                    # Create RGB version on white background
+                    rgb_img = Image.new("RGB", img.size, (255, 255, 255))
+                    rgb_img.paste(img, mask=img.split()[-1])  # Use alpha as mask
+                    img = rgb_img
+                elif img.mode != "RGB":
+                    img = img.convert("RGB")
+
+                img.save(output_dds_path, format="DDS")
+        except Exception as e:
+            raise RuntimeError(f"DDS conversion failed: {e}")

maps4fs/generator/component/base/component_mesh.py

@@ -1,10 +1,15 @@
 """Base class for all components that primarily used to work with meshes."""
 
 import os
+import shutil
+import xml.etree.ElementTree as ET
+from datetime import datetime
 
 import cv2
 import numpy as np
+import open3d as o3d
 import trimesh
+from PIL import Image
 from tqdm import tqdm
 
 from maps4fs.generator.component.base.component import Component
@@ -269,3 +274,405 @@ class MeshComponent(Component):
         mesh_copy = mesh.copy()
         mesh_copy.faces = mesh_copy.faces[:, ::-1]  # type: ignore
         return mesh_copy
+
+    @staticmethod
+    def decimate_mesh(mesh: trimesh.Trimesh, reduction_factor: float) -> trimesh.Trimesh:
+        """Decimate mesh using Open3D's quadric decimation (similar to Blender's approach)
+
+        Arguments:
+            mesh (trimesh.Trimesh): Input trimesh mesh
+            reduction_factor (float): Reduce to this fraction of original triangles (0.5 = 50%)
+
+        Returns:
+            trimesh.Trimesh: Decimated trimesh mesh
+        """
+        # 1. Convert trimesh to Open3D format.
+        vertices = mesh.vertices
+        faces = mesh.faces
+
+        o3d_mesh = o3d.geometry.TriangleMesh()
+        o3d_mesh.vertices = o3d.utility.Vector3dVector(vertices)
+        o3d_mesh.triangles = o3d.utility.Vector3iVector(faces)
+
+        # 2. Calculate target number of triangles.
+        target_triangles = int(len(faces) * reduction_factor)
+
+        # 3. Apply quadric decimation.
+        decimated_o3d = o3d_mesh.simplify_quadric_decimation(target_triangles)
+
+        # 4. Convert back to trimesh.
+        decimated_vertices = np.asarray(decimated_o3d.vertices)
+        decimated_faces = np.asarray(decimated_o3d.triangles)
+        decimated_mesh = trimesh.Trimesh(vertices=decimated_vertices, faces=decimated_faces)
+
+        return decimated_mesh
+
+    @staticmethod
+    def texture_mesh(
+        mesh: trimesh.Trimesh,
+        resized_texture_path: str,
+        output_directory: str,
+        output_name: str,
+    ) -> tuple[str, str]:
+        """Apply texture to mesh with UV mapping based on X and Z coordinates (ground plane).
+
+        Arguments:
+            mesh (trimesh.Trimesh): The mesh to texture
+            resized_texture_path (str): Path to resized texture image
+            output_directory (str): Directory to save textured OBJ and MTL files and texture.
+            output_name (str): Base name for output files (without extension)
+
+        Returns:
+            tuple[str, str]: Paths to the saved OBJ and MTL files
+        """
+        # 1. Copy texture to output directory (only if not already there).
+        texture_filename = os.path.basename(resized_texture_path)
+        texture_output_path = os.path.join(output_directory, texture_filename)
+
+        # Check if source and destination are the same file to avoid copy conflicts
+        if os.path.abspath(resized_texture_path) != os.path.abspath(texture_output_path):
+            shutil.copy2(resized_texture_path, texture_output_path)
+
+        # 2. Apply rotation to fix 90-degree X-axis rotation.
+        rotation_matrix = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
+        mesh.apply_transform(rotation_matrix)
+
+        # 3. Get mesh bounds: using X and Z for ground plane.
+        vertices = mesh.vertices
+
+        # 4. Ground plane coordinates (X, Z)
+        min_x = np.min(vertices[:, 0])  # X coordinate
+        max_x = np.max(vertices[:, 0])
+        min_z = np.min(vertices[:, 2])  # Z coordinate
+        max_z = np.max(vertices[:, 2])
+
+        width = max_x - min_x  # X dimension
+        depth = max_z - min_z  # Z dimension
+
+        # 5. Load texture.
+        texture_image = Image.open(texture_output_path)
+
+        # 6. Calculate UV coordinates based on X and Z positions.
+        uv_coords = np.zeros((len(vertices), 2), dtype=np.float32)
+        for i in tqdm(range(len(vertices)), desc="Calculating UVs", unit="vertex"):
+            vertex = vertices[i]
+
+            # Map X coordinate to U
+            u = (vertex[0] - min_x) / width if width > 0 else 0.5
+
+            # Map Z coordinate to V (NOT Y!)
+            v = (vertex[2] - min_z) / depth if depth > 0 else 0.5
+
+            # Flip V coordinate for correct orientation
+            v = 1.0 - v
+
+            # Clamp to valid range
+            u = np.clip(u, 0.0, 1.0)
+            v = np.clip(v, 0.0, 1.0)
+
+            uv_coords[i] = [u, v]
+
+        # 7. Create material.
+        material = trimesh.visual.material.PBRMaterial(
+            baseColorTexture=texture_image,
+            metallicFactor=0.0,
+            roughnessFactor=1.0,
+            emissiveFactor=[0.0, 0.0, 0.0],
+        )
+
+        # 8. Apply UV and material to mesh.
+        visual = trimesh.visual.TextureVisuals(uv=uv_coords, material=material)
+        mesh.visual = visual
+
+        mtl_filename = f"{output_name}.mtl"
+        obj_filename = f"{output_name}.obj"
+        mtl_filepath = os.path.join(output_directory, mtl_filename)
+        obj_filepath = os.path.join(output_directory, obj_filename)
+
+        faces = mesh.faces
+
+        # 9. Write OBJ file with correct UV mapping.
+        with open(obj_filepath, "w") as f:  # pylint: disable=unspecified-encoding
+            f.write("# Corrected UV mapping using X,Z coordinates (ground plane)\n")
+            f.write("# Y coordinate represents elevation\n")
+            f.write(f"mtllib {os.path.basename(mtl_filename)}\n")
+
+            # Write vertices
+            for vertex in vertices:
+                f.write(f"v {vertex[0]:.6f} {vertex[1]:.6f} {vertex[2]:.6f}\n")
+
+            # Write UV coordinates
+            for uv in uv_coords:
+                f.write(f"vt {uv[0]:.6f} {uv[1]:.6f}\n")
+
+            # Write faces
+            f.write("usemtl TerrainMaterial_XZ\n")
+            for face in faces:
+                v1, v2, v3 = face[0] + 1, face[1] + 1, face[2] + 1
+                f.write(f"f {v1}/{v1} {v2}/{v2} {v3}/{v3}\n")
+
+        # 10. Write MTL file.
+        with open(mtl_filepath, "w") as f:  # pylint: disable=unspecified-encoding
+            f.write("# Material with X,Z UV mapping\n")
+            f.write("newmtl TerrainMaterial_XZ\n")
+            f.write("Ka 1.0 1.0 1.0\n")
+            f.write("Kd 1.0 1.0 1.0\n")
+            f.write("Ks 0.0 0.0 0.0\n")
+            f.write("illum 1\n")
+            f.write(f"map_Kd {texture_filename}\n")
+
+        return obj_filepath, mtl_filepath
+
+    @staticmethod
+    def mesh_to_i3d(
+        mesh: trimesh.Trimesh,
+        output_dir: str,
+        name: str,
+        texture_path: str | None = None,
+        water_mesh: bool = False,
+    ) -> str:
+        """Convert a trimesh to i3d format with optional water shader support.
+
+        Arguments:
+            mesh (trimesh.Trimesh): trimesh.Trimesh object to convert
+            output_dir (str): Directory to save i3d and copy textures to
+            name (str): Base name for output files (e.g., "terrain_mesh")
+            texture_path (str | None): Optional path to texture file (will be copied to output_dir)
+            water_mesh (bool): If True, adds ocean shader material for water rendering
+
+        Returns:
+            str: Full path to the generated i3d file
+        """
+
+        # Ensure output directory exists
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        # Apply transformations (only for water meshes)
+        if water_mesh:
+            # 1. Apply rotation fix (90-degree X-axis correction) - water only
+            rotation_matrix = trimesh.transformations.rotation_matrix(-np.pi / 2, [1, 0, 0])
+            mesh.apply_transform(rotation_matrix)
+
+            # 2. Center mesh at origin - water only
+            vertices = mesh.vertices
+            center = vertices.mean(axis=0)
+            mesh.vertices = vertices - center
+
+        # 3. Handle texture copying if provided
+        texture_file = None
+        if texture_path and os.path.exists(texture_path):
+            texture_filename = os.path.basename(texture_path)
+            texture_dest = os.path.join(output_dir, texture_filename)
+
+            # Copy texture if it's not already in output_dir
+            if os.path.abspath(texture_path) != os.path.abspath(texture_dest):
+                shutil.copy2(texture_path, texture_dest)
+
+            texture_file = texture_filename
+
+        # 4. Generate i3d file
+        output_path = os.path.join(output_dir, f"{name}.i3d")
+        MeshComponent._write_i3d_file(mesh, output_path, name, texture_file, water_mesh)
+
+        return output_path
+
+    @staticmethod
+    def _write_i3d_file(
+        mesh: trimesh.Trimesh,
+        output_path: str,
+        name: str,
+        texture_file: str | None,
+        is_water: bool,
+    ) -> None:
+        """Write the actual i3d XML file.
+
+        Arguments:
+            mesh  (trimesh.Trimesh): object containing the geometry
+            output_path (str): Full path where to save the i3d file
+            name (str): Name for the mesh in i3d file
+            texture_file (str | None): Optional texture filename (if copied to output dir)
+            is_water (bool): If True, generates water mesh with ocean shader
+        """
+
+        # Root element
+        i3d = ET.Element(
+            "i3D",
+            attrib={
+                "name": name,
+                "version": "1.6",
+                "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+                "xsi:noNamespaceSchemaLocation": "http://i3d.giants.ch/schema/i3d-1.6.xsd",
+            },
+        )
+
+        # Asset section
+        asset = ET.SubElement(i3d, "Asset")
+        exp = ET.SubElement(asset, "Export")
+        exp.set("program", "maps4fs")
+        exp.set("version", "1.0")
+        exp.set("date", datetime.now().strftime("%Y-%m-%d"))
+
+        vertices = mesh.vertices
+        faces = mesh.faces
+
+        has_normals = mesh.vertex_normals is not None and len(mesh.vertex_normals) == len(vertices)
+        has_uv = (
+            hasattr(mesh.visual, "uv")
+            and mesh.visual.uv is not None
+            and len(mesh.visual.uv) == len(vertices)
+        )
+
+        # Files section
+        files_section = None
+        if is_water:
+            # Water mesh: add ocean shader
+            files_section = ET.SubElement(i3d, "Files")
+            shader_file = ET.SubElement(files_section, "File")
+            shader_file.set("fileId", "4")
+            shader_file.set("filename", "$data/shaders/oceanShader.xml")
+        elif texture_file:
+            # Terrain mesh: add texture file
+            files_section = ET.SubElement(i3d, "Files")
+            file_entry = ET.SubElement(files_section, "File")
+            file_entry.set("fileId", "1")
+            file_entry.set("filename", texture_file)
+            file_entry.set("relativePath", "true")
+
+        # Materials section
+        materials_section = ET.SubElement(i3d, "Materials")
+        material = ET.SubElement(materials_section, "Material")
+
+        if is_water:
+            # Water material with ocean shader
+            material.set("name", "OceanShader")
+            material.set("materialId", "1")
+            material.set("diffuseColor", "0.8 0.8 0.8 1")
+            material.set("specularColor", "0.501961 1 0")
+            material.set("customShaderId", "4")
+            material.set("customShaderVariation", "simple")
+
+            # Required for ocean shader
+            normalmap = ET.SubElement(material, "Normalmap")
+            normalmap.set("fileId", "2")
+
+            refractionmap = ET.SubElement(material, "Refractionmap")
+            refractionmap.set("coeff", "1")
+            refractionmap.set("bumpScale", "0.01")
+            refractionmap.set("withSSRData", "true")
+        else:
+            # Standard terrain material
+            material.set("name", f"{name}_material")
+            material.set("materialId", "1")
+            material.set("diffuseColor", "1 1 1 1")
+            material.set("specularColor", "0.5 0.5 0.5")
+
+            if texture_file:
+                texture = ET.SubElement(material, "Texture")
+                texture.set("fileId", "1")
+
+        # Shapes section
+        shapes = ET.SubElement(i3d, "Shapes")
+        shape = ET.SubElement(shapes, "IndexedTriangleSet")
+        shape.set("name", name)
+        shape.set("shapeId", "1")
+
+        # Calculate bounding sphere
+        if len(vertices) > 0:
+            center = vertices.mean(axis=0)
+            max_dist = ((vertices - center) ** 2).sum(axis=1).max() ** 0.5
+            shape.set("bvCenter", f"{center[0]:.6f} {center[1]:.6f} {center[2]:.6f}")
+            shape.set("bvRadius", f"{max_dist:.6f}")
+
+        # Vertices block
+        xml_vertices = ET.SubElement(shape, "Vertices")
+        xml_vertices.set("count", str(len(vertices)))
+
+        if has_normals:
+            xml_vertices.set("normal", "true")
+        if has_uv:
+            xml_vertices.set("uv0", "true")
+
+        # Write vertex data
+        for idx in tqdm(range(len(vertices)), desc="Writing vertices", unit="vertex"):
+            v = vertices[idx]
+            v_el = ET.SubElement(xml_vertices, "v")
+            v_el.set("p", f"{v[0]:.6f} {v[1]:.6f} {v[2]:.6f}")
+
+            if has_normals:
+                n = mesh.vertex_normals[idx]
+                v_el.set("n", f"{n[0]:.6f} {n[1]:.6f} {n[2]:.6f}")
+
+            if has_uv:
+                uv = mesh.visual.uv[idx]
+                v_el.set("t0", f"{uv[0]:.6f} {uv[1]:.6f}")
+
+        # Triangles block
+        xml_tris = ET.SubElement(shape, "Triangles")
+        xml_tris.set("count", str(len(faces)))
+        for f in tqdm(faces, desc="Writing triangles", unit="triangle"):
+            t = ET.SubElement(xml_tris, "t")
+            t.set("vi", f"{f[0]} {f[1]} {f[2]}")
+
+        # Subsets block
+        xml_subs = ET.SubElement(shape, "Subsets")
+        xml_subs.set("count", "1")
+        subset = ET.SubElement(xml_subs, "Subset")
+        subset.set("firstVertex", "0")
+        subset.set("numVertices", str(len(vertices)))
+        subset.set("firstIndex", "0")
+        subset.set("numIndices", str(len(faces) * 3))
+
+        # Scene section
+        scene = ET.SubElement(i3d, "Scene")
+
+        if is_water:
+            # Water: direct shape node
+            shape_node = ET.SubElement(scene, "Shape")
+            shape_node.set("name", name)
+            shape_node.set("shapeId", "1")
+            shape_node.set("nodeId", "4")
+            shape_node.set("castsShadows", "true")
+            shape_node.set("receiveShadows", "true")
+            shape_node.set("materialIds", "1")
+        else:
+            # Terrain: transform group with shape
+            transform_group = ET.SubElement(scene, "TransformGroup")
+            transform_group.set("name", name)
+            transform_group.set("nodeId", "1")
+
+            shape_node = ET.SubElement(transform_group, "Shape")
+            shape_node.set("name", f"{name}_shape")
+            shape_node.set("nodeId", "2")
+            shape_node.set("shapeId", "1")
+            shape_node.set("static", "true")
+            shape_node.set("compound", "false")
+            shape_node.set("collision", "true")
+            shape_node.set("materialIds", "1")
+
+        # Pretty print and write
+        MeshComponent._indent(i3d)
+        tree = ET.ElementTree(i3d)
+        tree.write(output_path, encoding="iso-8859-1", xml_declaration=True)
+
+    @staticmethod
+    def _indent(elem: ET.Element, level: int = 0) -> None:
+        """Pretty print XML formatting. Modifies the element in place.
+
+        Arguments:
+            elem (ET.Element): The XML element to indent
+            level (int): Current indentation level
+        """
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for e in elem:
+                MeshComponent._indent(e, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i

maps4fs/generator/game.py

@@ -42,9 +42,10 @@ class Game:
     _environment_processing: bool = True
     _fog_processing: bool = True
     _dissolve: bool = True
+    _mesh_processing: bool = True
 
     # Order matters! Some components depend on others.
-    components = [Texture, Background, GRLE, I3d, Config, Satellite]
+    components = [Satellite, Texture, Background, GRLE, I3d, Config]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -312,6 +313,14 @@ class Game:
             bool: True if the dissolve should be applied, False otherwise."""
         return self._dissolve
 
+    @property
+    def mesh_processing(self) -> bool:
+        """Returns whether the mesh should be processed.
+
+        Returns:
+            bool: True if the mesh should be processed, False otherwise."""
+        return self._mesh_processing
+
 
 class FS22(Game):
     """Class used to define the game version FS22."""
@@ -324,6 +333,7 @@ class FS22(Game):
     _fog_processing = False
     _plants_processing = False
     _dissolve = False
+    _mesh_processing = False
 
     def dem_file_path(self, map_directory: str) -> str:
         """Returns the path to the DEM file.

maps4fs/generator/map.py

@@ -12,7 +12,7 @@ from pydtmdl.base.dtm import DTMProviderSettings
 
 import maps4fs.generator.config as mfscfg
 import maps4fs.generator.utils as mfsutils
-from maps4fs.generator.component import Background, Component, Layer, Texture
+from maps4fs.generator.component import Background, Component, Layer, Satellite, Texture
 from maps4fs.generator.game import Game
 from maps4fs.generator.settings import GenerationSettings, MainSettings, SharedSettings
 from maps4fs.generator.statistics import send_advanced_settings, send_main_settings
@@ -150,6 +150,9 @@ class Map:
             raise RuntimeError(f"Can not unpack map template due to error: {e}") from e
         # endregion
 
+        self.assets_directory = os.path.join(self.map_directory, "assets")
+        os.makedirs(self.assets_directory, exist_ok=True)
+
         self.shared_settings = SharedSettings()
         self.components: list[Component] = []
 
@@ -301,6 +304,17 @@ class Map:
             return None
         return component
 
+    def get_satellite_component(self) -> Satellite | None:
+        """Get satellite component.
+
+        Returns:
+            Satellite | None: Satellite instance or None if not found.
+        """
+        component = self.get_component("Satellite")
+        if not isinstance(component, Satellite):
+            return None
+        return component
+
     def get_texture_layer(self, by_usage: str | None = None) -> Layer | None:
         """Get texture layer by usage.
 

maps4fs/generator/settings.py

@@ -28,12 +28,19 @@ class Parameters:
     WATER = "water"
     FARMYARDS = "farmyards"
 
+    MAXIMUM_BACKGROUND_TEXTURE_SIZE = 4096
+
     PREVIEW_MAXIMUM_SIZE = 2048
 
     BACKGROUND_DISTANCE = 2048
     FULL = "FULL"
     PREVIEW = "PREVIEW"
 
+    DECIMATED_BACKGROUND = "decimated_background"
+    BACKGROUND_TERRAIN = "background_terrain"
+
+    WATER_RESOURCES = "water_resources"
+
     RESIZE_FACTOR = 8
 
     FARMLAND_ID_LIMIT = 254

{maps4fs-2.8.2.dist-info → maps4fs-2.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.8.2
+Version: 2.8.3
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: GNU Affero General Public License v3.0
@@ -26,18 +26,22 @@ Requires-Dist: scipy
 Requires-Dist: pydtmdl
 Requires-Dist: manifold3d
 Requires-Dist: fast-simplification
+Requires-Dist: open3d
 Dynamic: license-file
 
-<p align="center">
-<a href="https://github.com/iwatkot/maps4fs">maps4fs</a> •
-<a href="https://github.com/iwatkot/maps4fsui">maps4fs UI</a> •
-<a href="https://github.com/iwatkot/maps4fsdata">maps4fs Data</a> •
-<a href="https://github.com/iwatkot/maps4fsapi">maps4fs API</a> •
-<a href="https://github.com/iwatkot/maps4fsstats">maps4fs Stats</a> •
-<a href="https://github.com/iwatkot/maps4fsbot">maps4fs Bot</a><br>
-<a href="https://github.com/iwatkot/pygmdl">pygmdl</a> •
-<a href="https://github.com/iwatkot/pydtmdl">pydtmdl</a>
-</p>
+<div align="center" markdown>
+
+[![Maps4FS](https://img.shields.io/badge/maps4fs-gray?style=for-the-badge)](https://github.com/iwatkot/maps4fs)
+[![PYDTMDL](https://img.shields.io/badge/pydtmdl-blue?style=for-the-badge)](https://github.com/iwatkot/pydtmdl)
+[![PYGDMDL](https://img.shields.io/badge/pygmdl-teal?style=for-the-badge)](https://github.com/iwatkot/pygmdl)  
+[![Maps4FS API](https://img.shields.io/badge/maps4fs-api-green?style=for-the-badge)](https://github.com/iwatkot/maps4fsapi)
+[![Maps4FS UI](https://img.shields.io/badge/maps4fs-ui-blue?style=for-the-badge)](https://github.com/iwatkot/maps4fsui)
+[![Maps4FS Data](https://img.shields.io/badge/maps4fs-data-orange?style=for-the-badge)](https://github.com/iwatkot/maps4fsdata)  
+[![Maps4FS Upgrader](https://img.shields.io/badge/maps4fs-upgrader-yellow?style=for-the-badge)](https://github.com/iwatkot/maps4fsupgrader)
+[![Maps4FS Stats](https://img.shields.io/badge/maps4fs-stats-red?style=for-the-badge)](https://github.com/iwatkot/maps4fsstats)
+[![Maps4FS Bot](https://img.shields.io/badge/maps4fs-bot-teal?style=for-the-badge)](https://github.com/iwatkot/maps4fsbot)
+
+</div>
 
 <div align="center" markdown>
 <a href="https://discord.gg/Sj5QKKyE42">

{maps4fs-2.8.2.dist-info → maps4fs-2.8.3.dist-info}/RECORD

@@ -2,14 +2,14 @@ maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
 maps4fs/logger.py,sha256=6sem0aFKQqtVjQ_yNu9iGcc-hqzLQUhfxco05K6nqow,763
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/config.py,sha256=KwYYWM5wrMB_tKn3Fls6WpEurZJxmrBH5AgAXPGHTJE,7122
-maps4fs/generator/game.py,sha256=nf6iuYNA5NJc-ir_WOgkw-MdJVgetVHeEtxbWJYt3Vo,14462
-maps4fs/generator/map.py,sha256=IC72Mr_04wm5kby4J0m-Bw32UrcE6qn2KwaX9vLEzn4,14036
+maps4fs/generator/game.py,sha256=sNyPNHGd5bEi7-00l5_MVp62KnBmH-OIIabeDwFEepc,14767
+maps4fs/generator/map.py,sha256=ZZRU8x0feGbgeJgxc0D3N-mfiasyFXxj6gbGyl-WRzE,14528
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=oDs_bgvqHMJfKGK7uVVkm6MykAL3dVkvm5L3-hvZx2c,13044
+maps4fs/generator/settings.py,sha256=4CDyJdKthVAT5I78_1gcruZVK4TYD1ctklAZBwvFwCM,13226
 maps4fs/generator/statistics.py,sha256=Dp1-NS-DWv0l0UdmhOoXeQs_N-Hs7svYUnmziSW5Z9I,2098
 maps4fs/generator/utils.py,sha256=ugdQ8C22NeiZLIlldLoEKCc7ioOefz4W-8qF2eOy9qU,4834
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
-maps4fs/generator/component/background.py,sha256=rUDTPduNCD7KKt_eoVWN4XVSVgjwGSoLNPbZOzpGx7E,34532
+maps4fs/generator/component/background.py,sha256=tFWdYASUUZsJ8QiQrxxba-6aMECD3hvpd0pMm_UdrH8,46151
 maps4fs/generator/component/config.py,sha256=uL76h9UwyhZKZmbxz0mBmWtEPN6qYay4epTEqqtej60,8601
 maps4fs/generator/component/dem.py,sha256=FPqcXmFQg5MPaGuy4g5kxzvY1wbhozeCf-aNMCj5eaU,11687
 maps4fs/generator/component/grle.py,sha256=0PC1K829wjD4y4d9qfIbnU29ebjflIPBbwIZx8FXwc8,27242
@@ -18,12 +18,12 @@ maps4fs/generator/component/layer.py,sha256=bdy1XGOODyPqYUM3b_wEY2H9Piz-AaHsCDec
 maps4fs/generator/component/satellite.py,sha256=9nKwL8zQ-BB6WFMx2m8zduFn6RaxSNv6Vtpge1-QMYE,5052
 maps4fs/generator/component/texture.py,sha256=gXZgr73ehT3_qjuIku0j7N7exloywtmmEQKBJ-MDcco,36988
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
-maps4fs/generator/component/base/component.py,sha256=lf0V9CLUXMg88Nm2yI3rP5taVYYlNivud0x6kbhBYqA,23312
-maps4fs/generator/component/base/component_image.py,sha256=WTGC6v1KuS5sLNCC95Z48nCspvATKKNOuhTNYzTWXr4,8315
-maps4fs/generator/component/base/component_mesh.py,sha256=3hC-qDT8Vde6SmRMqs9USAkrF-gL2dDTYW71ATpxUS4,9130
+maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
+maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
+maps4fs/generator/component/base/component_mesh.py,sha256=plCLS4O8XsVzAtaRi9lm7a8LnS1dcJ7-mqUpVMvCPAg,24704
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.8.2.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
-maps4fs-2.8.2.dist-info/METADATA,sha256=MeLuVswRau8eG5hivACyRZqqN71C8nbxREvmuoAOYKQ,9425
-maps4fs-2.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.8.2.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.8.2.dist-info/RECORD,,
+maps4fs-2.8.3.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
+maps4fs-2.8.3.dist-info/METADATA,sha256=R4Nh5jeZ3nPZUSZ2KQEG73Sh6mC-MI_jv2_GN7FJw0A,10042
+maps4fs-2.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.8.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.8.3.dist-info/RECORD,,