amulet-core 2.0a8__cp312-cp312-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a1__cp312-cp312-win_amd64.whl

amulet/level/java/long_array.pyi

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import numpy
-import numpy.typing
-import typing_extensions
-
-__all__ = ["decode_long_array", "encode_long_array"]
-
-def decode_long_array(
-    long_array: typing_extensions.Buffer,
-    size: int,
-    bits_per_entry: int,
-    dense: bool = True,
-) -> numpy.ndarray:
-    """
-    Decode a long array (from BlockStates or Heightmaps)
-
-    :param long_array: Encoded long array
-    :param size: The expected size of the returned array
-    :param bits_per_entry: The number of bits per entry in the encoded array.
-    :param dense: If true the long arrays will be treated as a bit stream. If false they are distinct values with padding
-    :return: Decoded array as numpy array
-    """
-
-def encode_long_array(
-    array: typing_extensions.Buffer,
-    bits_per_entry: None | int = None,
-    dense: bool = True,
-    min_bits_per_entry: int = 1,
-) -> numpy.typing.NDArray[numpy.uint64]:
-    """
-    Encode a long array (from BlockStates or Heightmaps)
-
-    :param array: A numpy array of the data to be encoded.
-    :param bits_per_entry: The number of bits to use to store each value. If left as None will use the smallest bits per entry.
-    :param dense: If true the long arrays will be treated as a bit stream. If false they are distinct values with padding
-    :param min_bits_per_entry: The mimimum value that bits_per_entry can be. If it is less than this it will be capped at this value.
-    :return: Encoded array as numpy array
-    """

amulet/level/temporary_level/__init__.py

@@ -1 +0,0 @@
-from ._level import TemporaryLevel

amulet/level/temporary_level/_level.py

@@ -1,16 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-from amulet.level.abc import Level, CreatableLevel
-from amulet.utils.call_spec import method_spec
-
-
-class TemporaryLevel(Level, CreatableLevel):
-    """A temporary level that exists only in memory."""
-
-    __slots__ = ()
-
-    @classmethod
-    @method_spec()
-    def create(cls, *args: Any, **kwargs: Any) -> TemporaryLevel:
-        raise NotImplementedError

amulet/mesh/block/__init__.pyi

@@ -1,301 +0,0 @@
-from __future__ import annotations
-
-import collections.abc
-import typing
-
-import numpy
-import pybind11_stubgen.typing_ext
-from amulet.mesh.block._cube import get_cube, get_unit_cube
-from amulet.mesh.block._missing_block import get_missing_block
-
-from . import _cube, _missing_block
-
-__all__ = [
-    "BlockMesh",
-    "BlockMeshCullDirection",
-    "BlockMeshPart",
-    "BlockMeshTransparency",
-    "CUBE_FACE_LUT",
-    "FACE_KEYS",
-    "FloatVec2",
-    "FloatVec3",
-    "TRI_FACE",
-    "Triangle",
-    "UV_ROTATION_LUT",
-    "Vertex",
-    "get_cube",
-    "get_missing_block",
-    "get_unit_cube",
-    "merge_block_meshes",
-]
-
-class BlockMesh:
-    """
-    All the data that makes up a block mesh.
-    """
-
-    def __init__(
-        self,
-        transparency: BlockMeshTransparency,
-        textures: list[str],
-        parts: tuple[
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-            BlockMeshPart | None,
-        ],
-    ) -> None: ...
-    def rotate(self, rotx: int, roty: int) -> BlockMesh:
-        """
-        Rotate the mesh in the x and y axis. Accepted values are -3 to 3 which corrospond to 90 degree rotations.
-        """
-
-    @property
-    def parts(
-        self,
-    ) -> typing.Annotated[
-        list[BlockMeshPart | None], pybind11_stubgen.typing_ext.FixedSize(7)
-    ]:
-        """
-        The mesh parts that make up this mesh. The index corrosponds to the value of BlockMeshCullDirection.
-        """
-
-    @parts.setter
-    def parts(
-        self,
-        arg0: typing.Annotated[
-            list[BlockMeshPart | None], pybind11_stubgen.typing_ext.FixedSize(7)
-        ],
-    ) -> None: ...
-    @property
-    def textures(self) -> list[str]:
-        """
-        The texture paths used in this block mesh. The Triangle's texture_index attribute is an index into this list.
-        """
-
-    @textures.setter
-    def textures(self, arg0: list[str]) -> None: ...
-    @property
-    def transparency(self) -> BlockMeshTransparency:
-        """
-        The transparency state of this block mesh.
-        """
-
-    @transparency.setter
-    def transparency(self, arg0: BlockMeshTransparency) -> None: ...
-
-class BlockMeshCullDirection:
-    """
-    The direction a mesh part is culled by. The value corrosponds to the index in the mesh parts array.
-
-    Members:
-
-      CullNone : Is not culled by any neighbouring blocks.
-
-      CullUp : Is culled by an opaque block above.
-
-      CullDown : Is culled by an opaque block below.
-
-      CullNorth : Is culled by an opaque block to the north.
-
-      CullEast : Is culled by an opaque block to the east.
-
-      CullSouth : Is culled by an opaque block to the south.
-
-      CullWest : Is culled by an opaque block to the west.
-    """
-
-    CullDown: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullDown: 2>
-    CullEast: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullEast: 4>
-    CullNone: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullNone: 0>
-    CullNorth: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullNorth: 3>
-    CullSouth: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullSouth: 5>
-    CullUp: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullUp: 1>
-    CullWest: typing.ClassVar[
-        BlockMeshCullDirection
-    ]  # value = <BlockMeshCullDirection.CullWest: 6>
-    __members__: typing.ClassVar[
-        dict[str, BlockMeshCullDirection]
-    ]  # value = {'CullNone': <BlockMeshCullDirection.CullNone: 0>, 'CullUp': <BlockMeshCullDirection.CullUp: 1>, 'CullDown': <BlockMeshCullDirection.CullDown: 2>, 'CullNorth': <BlockMeshCullDirection.CullNorth: 3>, 'CullEast': <BlockMeshCullDirection.CullEast: 4>, 'CullSouth': <BlockMeshCullDirection.CullSouth: 5>, 'CullWest': <BlockMeshCullDirection.CullWest: 6>}
-    def __and__(self, other: typing.Any) -> typing.Any: ...
-    def __eq__(self, other: typing.Any) -> bool: ...
-    def __ge__(self, other: typing.Any) -> bool: ...
-    def __gt__(self, other: typing.Any) -> bool: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __init__(self, value: int) -> None: ...
-    def __int__(self) -> int: ...
-    def __invert__(self) -> typing.Any: ...
-    def __le__(self, other: typing.Any) -> bool: ...
-    def __lt__(self, other: typing.Any) -> bool: ...
-    def __ne__(self, other: typing.Any) -> bool: ...
-    def __or__(self, other: typing.Any) -> typing.Any: ...
-    def __rand__(self, other: typing.Any) -> typing.Any: ...
-    def __repr__(self) -> str: ...
-    def __ror__(self, other: typing.Any) -> typing.Any: ...
-    def __rxor__(self, other: typing.Any) -> typing.Any: ...
-    def __str__(self) -> str: ...
-    def __xor__(self, other: typing.Any) -> typing.Any: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def value(self) -> int: ...
-
-class BlockMeshPart:
-    """
-    A part of a block mesh for one of the culling directions.
-    """
-
-    def __init__(self, verts: list[Vertex], triangles: list[Triangle]) -> None: ...
-    @property
-    def triangles(self) -> list[Triangle]:
-        """
-        The triangles in this block mesh part.
-        """
-
-    @triangles.setter
-    def triangles(self, arg0: list[Triangle]) -> None: ...
-    @property
-    def verts(self) -> list[Vertex]:
-        """
-        The vertices in this block mesh part.
-        """
-
-    @verts.setter
-    def verts(self, arg0: list[Vertex]) -> None: ...
-
-class BlockMeshTransparency:
-    """
-    The transparency of a block mesh.
-
-    Members:
-
-      FullOpaque : A block that occupies the whole block and is opaque.
-
-      FullTranslucent : A block that occupies the whole block and has at least one translucent face.
-
-      Partial : A block that does not occupy the whole block.
-    """
-
-    FullOpaque: typing.ClassVar[
-        BlockMeshTransparency
-    ]  # value = <BlockMeshTransparency.FullOpaque: 0>
-    FullTranslucent: typing.ClassVar[
-        BlockMeshTransparency
-    ]  # value = <BlockMeshTransparency.FullTranslucent: 1>
-    Partial: typing.ClassVar[
-        BlockMeshTransparency
-    ]  # value = <BlockMeshTransparency.Partial: 2>
-    __members__: typing.ClassVar[
-        dict[str, BlockMeshTransparency]
-    ]  # value = {'FullOpaque': <BlockMeshTransparency.FullOpaque: 0>, 'FullTranslucent': <BlockMeshTransparency.FullTranslucent: 1>, 'Partial': <BlockMeshTransparency.Partial: 2>}
-    def __eq__(self, other: typing.Any) -> bool: ...
-    def __ge__(self, other: typing.Any) -> bool: ...
-    def __gt__(self, other: typing.Any) -> bool: ...
-    def __hash__(self) -> int: ...
-    def __index__(self) -> int: ...
-    def __init__(self, value: int) -> None: ...
-    def __int__(self) -> int: ...
-    def __le__(self, other: typing.Any) -> bool: ...
-    def __lt__(self, other: typing.Any) -> bool: ...
-    def __ne__(self, other: typing.Any) -> bool: ...
-    def __repr__(self) -> str: ...
-    def __str__(self) -> str: ...
-    @property
-    def name(self) -> str: ...
-    @property
-    def value(self) -> int: ...
-
-class FloatVec2:
-    """
-    A 2D floating point vector
-    """
-
-    x: float
-    y: float
-    def __init__(self, x: float, y: float) -> None: ...
-
-class FloatVec3:
-    """
-    A 3D floating point vector
-    """
-
-    x: float
-    y: float
-    z: float
-    def __init__(self, x: float, y: float, z: float) -> None: ...
-
-class Triangle:
-    """
-    The vertex and texture indexes that make up a triangle.
-    """
-
-    texture_index: int
-    vert_index_a: int
-    vert_index_b: int
-    vert_index_c: int
-    def __init__(
-        self,
-        vert_index_a: int,
-        vert_index_b: int,
-        vert_index_c: int,
-        texture_index: int,
-    ) -> None: ...
-
-class Vertex:
-    """
-    Attributes for a single vertex.
-    """
-
-    def __init__(
-        self, coord: FloatVec3, texture_coord: FloatVec2, tint: FloatVec3
-    ) -> None: ...
-    @property
-    def coord(self) -> FloatVec3:
-        """
-        The spatial coordinate of the vertex.
-        """
-
-    @coord.setter
-    def coord(self, arg0: FloatVec3) -> None: ...
-    @property
-    def texture_coord(self) -> FloatVec2:
-        """
-        The texture coordinate of the vertex.
-        """
-
-    @texture_coord.setter
-    def texture_coord(self, arg0: FloatVec2) -> None: ...
-    @property
-    def tint(self) -> FloatVec3:
-        """
-        The tint colour for the vertex.
-        """
-
-    @tint.setter
-    def tint(self, arg0: FloatVec3) -> None: ...
-
-def merge_block_meshes(meshes: collections.abc.Sequence[BlockMesh]) -> BlockMesh:
-    """
-    Merge multiple block mesh objects into one block mesh.
-    """
-
-CUBE_FACE_LUT: dict  # value = {'down': array([0, 4, 5, 1]), 'up': array([3, 7, 6, 2]), 'north': array([4, 0, 2, 6]), 'east': array([5, 4, 6, 7]), 'south': array([1, 5, 7, 3]), 'west': array([0, 1, 3, 2])}
-FACE_KEYS: dict  # value = {None: <BlockMeshCullDirection.CullNone: 0>, 'up': <BlockMeshCullDirection.CullUp: 1>, 'down': <BlockMeshCullDirection.CullDown: 2>, 'north': <BlockMeshCullDirection.CullNorth: 3>, 'east': <BlockMeshCullDirection.CullEast: 4>, 'south': <BlockMeshCullDirection.CullSouth: 5>, 'west': <BlockMeshCullDirection.CullWest: 6>}
-TRI_FACE: numpy.ndarray  # value = array([0, 1, 2, 0, 2, 3], dtype=uint32)
-UV_ROTATION_LUT: list = [0, 3, 2, 3, 2, 1, 0, 1]

amulet/mesh/block/_cube.py

@@ -1,198 +0,0 @@
-from typing import TypeAlias
-import numpy
-import itertools
-
-from amulet.mesh.block import (
-    BlockMesh,
-    BlockMeshPart,
-    Triangle,
-    Vertex,
-    FloatVec3,
-    FloatVec2,
-    BlockMeshTransparency,
-    BlockMeshCullDirection,
-)
-
-BoundsType: TypeAlias = tuple[
-    tuple[float, float], tuple[float, float], tuple[float, float]
-]
-TextureUVType: TypeAlias = tuple[
-    tuple[float, float, float, float],
-    tuple[float, float, float, float],
-    tuple[float, float, float, float],
-    tuple[float, float, float, float],
-    tuple[float, float, float, float],
-    tuple[float, float, float, float],
-]
-
-UNIT_BOX_COORDINATES = numpy.array(
-    list(itertools.product((0, 1), (0, 1), (0, 1)))
-)  # X, Y, Z
-
-CULL_DIRECTION_NAMES = (
-    "down",
-    "up",
-    "north",
-    "east",
-    "south",
-    "west",
-)
-
-# This maps face direction to the vertices used (defined in UNIT_BOX_COORDINATES)
-VERTEX_INDEXES = (
-    numpy.array([0, 4, 5, 1]),
-    numpy.array([3, 7, 6, 2]),
-    numpy.array([4, 0, 2, 6]),
-    numpy.array([5, 4, 6, 7]),
-    numpy.array([1, 5, 7, 3]),
-    numpy.array([0, 1, 3, 2]),
-)
-
-# This maps face direction to the vertices used (defined in UNIT_BOX_COORDINATES)
-CUBE_FACE_LUT = dict(zip(CULL_DIRECTION_NAMES, VERTEX_INDEXES))
-
-TRI_FACE = numpy.array([0, 1, 2, 0, 2, 3], numpy.uint32)
-
-# cube_vert_lut = {  # This maps from vertex index to index in [minx, miny, minz, maxx, maxy, maxz]
-# 	1: [0, 1, 5],
-# 	3: [0, 4, 5],
-# 	0: [0, 1, 2],
-# 	2: [0, 4, 2],
-# 	5: [3, 1, 5],
-# 	7: [3, 4, 5],
-# 	4: [3, 1, 2],
-# 	6: [3, 4, 2],
-# }
-#
-# # combines the above two to map from face to index in [minx, miny, minz, maxx, maxy, maxz]. Used to index a numpy array
-# # The above two have been kept separate because the merged result is unintuitive and difficult to edit.
-# cube_lut = {
-# 	face_dir_: [
-# 		vert_coord_ for vert_ in vert_index_ for vert_coord_ in cube_vert_lut[vert_]
-# 	]
-# 	for face_dir_, vert_index_ in CUBE_FACE_LUT.items()
-# }
-
-UV_ROTATION_LUT = [0, 3, 2, 3, 2, 1, 0, 1]  # remap
-
-
-# tvert_lut = {  # TODO: implement this for the cases where the UV is not defined
-# 	'down': [],
-# 	'up': [],
-# 	'north': [],
-# 	'east': [],
-# 	'south': [],
-# 	'west': []
-# }
-
-
-def get_cube(
-    down: str,
-    up: str,
-    north: str,
-    east: str,
-    south: str,
-    west: str,
-    transparency: BlockMeshTransparency = BlockMeshTransparency.FullOpaque,
-    tint: tuple[int, int, int] = (1, 1, 1),
-    bounds: BoundsType = ((0, 1), (0, 1), (0, 1)),
-    texture_uv: TextureUVType = ((0, 0, 1, 1),) * 6,
-    do_not_cull: tuple[bool, bool, bool, bool, bool, bool] = (
-        False,
-        False,
-        False,
-        False,
-        False,
-        False,
-    ),
-) -> BlockMesh:
-    texture_paths: dict[str, int] = {}
-    mesh_parts: list[tuple[list[Vertex], list[Triangle]] | None] = [
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-        None,
-    ]
-    box_coordinates = list(itertools.product(*bounds))
-    tint_vec = FloatVec3(*tint)
-
-    for (
-        cull_direction,
-        vertex_index,
-        do_not_cull_face,
-        texture_path,
-        texture_coords,
-    ) in zip(
-        (
-            BlockMeshCullDirection.CullDown,
-            BlockMeshCullDirection.CullUp,
-            BlockMeshCullDirection.CullNorth,
-            BlockMeshCullDirection.CullEast,
-            BlockMeshCullDirection.CullSouth,
-            BlockMeshCullDirection.CullWest,
-        ),
-        VERTEX_INDEXES,
-        do_not_cull,
-        (down, up, north, east, south, west),
-        texture_uv,
-    ):
-        # Get the index of the texture path. Add if it is not contained.
-        texture_index = texture_paths.setdefault(texture_path, len(texture_paths))
-        if do_not_cull_face:
-            cull_direction = BlockMeshCullDirection.CullNone
-        part = mesh_parts[cull_direction]
-        if part is None:
-            mesh_parts[cull_direction] = part = ([], [])
-        verts, tris = part
-        vert_count = len(verts)
-
-        for i in range(4):
-            x, y, z = box_coordinates[vertex_index[i]]
-            uvx = texture_coords[UV_ROTATION_LUT[i * 2]]
-            uvy = texture_coords[UV_ROTATION_LUT[i * 2 + 1]]
-            verts.append(
-                Vertex(
-                    FloatVec3(x, y, z),
-                    FloatVec2(uvx, uvy),
-                    tint_vec,
-                )
-            )
-        for a, b, c in TRI_FACE.reshape((2, 3)):
-            tris.append(
-                Triangle(a + vert_count, b + vert_count, c + vert_count, texture_index)
-            )
-
-    def create_part(
-        part: tuple[list[Vertex], list[Triangle]] | None
-    ) -> BlockMeshPart | None:
-        return None if part is None else BlockMeshPart(*part)
-
-    return BlockMesh(
-        transparency,
-        list(texture_paths),
-        (
-            create_part(mesh_parts[0]),
-            create_part(mesh_parts[1]),
-            create_part(mesh_parts[2]),
-            create_part(mesh_parts[3]),
-            create_part(mesh_parts[4]),
-            create_part(mesh_parts[5]),
-            create_part(mesh_parts[6]),
-        ),
-    )
-
-
-def get_unit_cube(
-    down: str,
-    up: str,
-    north: str,
-    east: str,
-    south: str,
-    west: str,
-    transparency: BlockMeshTransparency = BlockMeshTransparency.FullOpaque,
-    tint: tuple[int, int, int] = (1, 1, 1),
-) -> BlockMesh:
-    return get_cube(down, up, north, east, south, west, transparency, tint)

amulet/mesh/block/_missing_block.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING
-
-from amulet.mesh.block import BlockMesh
-from ._cube import get_unit_cube
-
-if TYPE_CHECKING:
-    from amulet.resource_pack.abc import BaseResourcePackManager
-
-
-def get_missing_block(resource_pack: BaseResourcePackManager) -> BlockMesh:
-    texture_path = resource_pack.get_texture_path("minecraft", "missing_no")
-    return get_unit_cube(
-        texture_path,
-        texture_path,
-        texture_path,
-        texture_path,
-        texture_path,
-        texture_path,
-    )

amulet/mesh/block/block_mesh.cpp

@@ -1,107 +0,0 @@
-#include <string>
-#include <array>
-#include <functional>
-#include "block_mesh.hpp"
-
-namespace Amulet {
-
-const std::array<BlockMeshCullDirection, 4> roty_map = { BlockMeshCullNorth, BlockMeshCullEast, BlockMeshCullSouth, BlockMeshCullWest };
-
-const RotationCullMapType RotationCullMap = []() {
-    RotationCullMapType cull_map;
-    for (std::int8_t roty = -3; roty < 4; roty++) {
-        // Create the rotated Y array
-        std::array<BlockMeshCullDirection, 4> roty_map_rotated;
-        auto split_y_point = 0 <= roty ? roty : roty + roty_map.size();
-        std::copy(roty_map.begin() + split_y_point, roty_map.end(), roty_map_rotated.begin());
-        std::copy(roty_map.begin(), roty_map.begin() + split_y_point, roty_map_rotated.end() - split_y_point);
-        // Create the X array
-        const std::array<BlockMeshCullDirection, 4> rotx_map = { roty_map_rotated[0], BlockMeshCullDown, roty_map_rotated[2], BlockMeshCullUp };
-        
-        for (std::int8_t rotx = -3; rotx < 4; rotx++) { 
-            // Create the rotated X array
-            std::array<BlockMeshCullDirection, 4> rotx_map_rotated;
-            auto split_x_point = 0 <= rotx ? rotx : rotx + rotx_map.size();
-            std::copy(rotx_map.begin() + split_x_point, rotx_map.end(), rotx_map_rotated.begin());
-            std::copy(rotx_map.begin(), rotx_map.begin() + split_x_point, rotx_map_rotated.end() - split_x_point);
-
-            cull_map[std::make_pair(roty, rotx)] = {
-                BlockMeshCullNone,
-                rotx_map_rotated[3],
-                rotx_map_rotated[1],
-                rotx_map_rotated[0],
-                roty_map_rotated[1],
-                rotx_map_rotated[2],
-                roty_map_rotated[3]
-            };
-        }
-    }
-    return cull_map;
-}();
-
-BlockMesh merge_block_meshes(std::vector<std::reference_wrapper<const BlockMesh>> meshes) {
-    BlockMesh new_mesh;
-    new_mesh.transparency = BlockMeshTransparency::Partial;
-    std::map<std::string, size_t> texture_index_map;
-    for (const auto& wrapper : meshes) {
-        const auto& temp_mesh = wrapper.get();
-        // Get the minimum transparency of the two meshes.
-        new_mesh.transparency = std::min(new_mesh.transparency, temp_mesh.transparency);
-        
-        // Copy over mesh parts
-        for (std::uint8_t cull_direction = 0; cull_direction < 7; cull_direction++) {
-            const auto& temp_mesh_part = temp_mesh.parts[cull_direction];
-            if (temp_mesh_part) {
-                auto& new_mesh_part = new_mesh.parts[cull_direction];
-                if (!new_mesh_part) {
-                    // Initialise the mesh part if it is null.
-                    new_mesh_part = BlockMeshPart();
-                }
-                // Get the number of triangles before copying
-                size_t vert_count = new_mesh_part->verts.size();
-                size_t triangle_count = new_mesh_part->triangles.size();
-
-                auto& new_verts = new_mesh_part->verts;
-                auto& temp_verts = temp_mesh_part->verts;
-                auto& new_triangles = new_mesh_part->triangles;
-                auto& temp_triangles = temp_mesh_part->triangles;
-                
-                // Copy over vertices
-                new_verts.insert(
-                    new_verts.end(),
-                    temp_verts.begin(),
-                    temp_verts.end());
-                // Copy over triangles
-                new_triangles.insert(
-                    new_triangles.end(),
-                    temp_triangles.begin(),
-                    temp_triangles.end());
-                
-                for (size_t i = triangle_count; i < new_mesh_part->triangles.size(); i++) {
-                    // Update the triangle indexes
-                    auto& triangle = new_mesh_part->triangles[i];
-                    triangle.vert_index_a += vert_count;
-                    triangle.vert_index_b += vert_count;
-                    triangle.vert_index_c += vert_count;
-                    if (temp_mesh.textures.size() <= triangle.texture_index) {
-                        throw std::invalid_argument("Texture index is higher than the number of textures.");
-                    }
-                    const auto& texture_path = temp_mesh.textures[triangle.texture_index];
-                    auto it = texture_index_map.find(texture_path);
-                    if (it == texture_index_map.end()) {
-                        // Texture has not been added yet.
-                        size_t texture_index = new_mesh.textures.size();
-                        new_mesh.textures.push_back(texture_path);
-                        triangle.texture_index = texture_index;
-                        texture_index_map[texture_path] = texture_index;
-                    } else {
-                        triangle.texture_index = it->second;
-                    }
-                }
-            }
-        }
-    }
-    return new_mesh;
-}
-
-}