amulet-core 2.0a7__cp312-cp312-win_amd64.whl → 2.0a8__cp312-cp312-win_amd64.whl

amulet/__init__.py.cpp

@@ -11,6 +11,7 @@ void init_palette(py::module);
 void init_chunk(py::module);
 void init_chunk_components(py::module);
 void init_level(py::module);
+void init_block_mesh(py::module);
 
 static bool init_run = false;
 
@@ -37,6 +38,7 @@ void init_amulet(py::module m){
     init_chunk(m);
     init_chunk_components(m);
     init_level(m);
+    init_block_mesh(m);
 }
 
 PYBIND11_MODULE(__init__, m) { init_amulet(m); }

amulet/__init__.pyi

@@ -8,6 +8,7 @@ from . import (
     chunk_components,
     collections,
     level,
+    mesh,
     palette,
     utils,
     version,
@@ -21,6 +22,7 @@ __all__ = [
     "chunk_components",
     "collections",
     "level",
+    "mesh",
     "palette",
     "utils",
     "version",

amulet/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-09-25T13:37:55+0100",
+ "date": "2024-10-27T10:30:17+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "bef077cfb019dd2608e14edab047d37d75dfba61",
- "version": "2.0a7"
+ "full-revisionid": "7844bec50b93c8711ae703840b1a0e43b8283df6",
+ "version": "2.0a8"
 }
 '''  # END VERSION_JSON
 

amulet/chunk.hpp

@@ -90,7 +90,8 @@ namespace Amulet {
 		void reconstruct_chunk(SerialisedComponents component_data) override {
 			(
 				[&]{
-					Components::deserialise(component_data.extract(Components::ComponentID).mapped());
+					auto node = component_data.extract(Components::ComponentID);
+					Components::deserialise(node ? node.mapped() : std::nullopt);
 				}(),
 				...
 			);

amulet/level/abc/_chunk_handle.py

@@ -12,6 +12,7 @@ from amulet.chunk import Chunk, get_null_chunk
 from amulet.data_types import DimensionId
 from amulet.errors import ChunkDoesNotExist, ChunkLoadError
 from amulet.utils.signal import Signal
+from amulet.utils.shareable_lock import ShareableRLock
 
 from ._level import LevelFriend, LevelT
 from ._history import HistoryManagerLayer
@@ -58,7 +59,7 @@ class ChunkHandle(
     Some internal synchronisation is done to catch some threading issues.
     """
 
-    _lock: RLock
+    _lock: ShareableRLock
     _dimension: DimensionId
     _key: ChunkKey
     _chunk_history: HistoryManagerLayer[ChunkKey]
@@ -84,7 +85,7 @@ class ChunkHandle(
         cz: int,
     ) -> None:
         super().__init__(level_ref)
-        self._lock = RLock()
+        self._lock = ShareableRLock()
         self._dimension_id = dimension_id
         self._key = ChunkKey(cx, cz)
         self._chunk_history = chunk_history
@@ -135,13 +136,7 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the lock could not be acquired.
         """
-        if not self._lock.acquire(blocking, timeout):
-            # Thread was not acquired
-            raise LockNotAcquired("Lock was not acquired.")
-        try:
-            yield
-        finally:
-            self._lock.release()
+        return self._lock.unique(blocking, timeout)
 
     @contextmanager
     def edit(
@@ -171,7 +166,7 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the lock could not be acquired.
         """
-        with self.lock(blocking=blocking, timeout=timeout):
+        with self._lock.unique(blocking=blocking, timeout=timeout):
             chunk = self.get(components)
             yield chunk
             # If an exception occurs in user code, this line won't be run.
@@ -187,14 +182,18 @@ class ChunkHandle(
 
         :return: True if the chunk exists. Calling get on this chunk handle may still throw ChunkLoadError
         """
-        if self._chunk_history.has_resource(self._key):
-            return self._chunk_history.resource_exists(self._key)
-        else:
-            # The history system is not aware of the chunk. Look in the level data
-            return self._get_raw_dimension().has_chunk(self.cx, self.cz)
+        with self._lock.shared():
+            if self._chunk_history.has_resource(self._key):
+                return self._chunk_history.resource_exists(self._key)
+            else:
+                # The history system is not aware of the chunk. Look in the level data
+                return self._get_raw_dimension().has_chunk(self.cx, self.cz)
 
     def _preload(self) -> None:
-        """Load the chunk data if it has not already been loaded."""
+        """
+        Load the chunk data if it has not already been loaded.
+        The lock must be acquired in unique mode before calling this.
+        """
         if not self._chunk_history.has_resource(self._key):
             # The history system is not aware of the chunk. Load from the level data
             chunk: Chunk
@@ -260,8 +259,9 @@ class ChunkHandle(
         :param components: None to load all components or an iterable of component strings to load.
         :return: A unique copy of the chunk data.
         """
-        with self.lock(blocking=False):
-            self._preload()
+
+        def get_chunk() -> ChunkT:
+            nonlocal components
             chunk = self._get_null_chunk()
             if components is None:
                 components = chunk.component_ids
@@ -276,8 +276,25 @@ class ChunkHandle(
             chunk.reconstruct_chunk(chunk_components)
             return chunk
 
+        # Block if the chunk is locked in unique mode.
+        with self._lock.shared():
+            if self._chunk_history.has_resource(self._key):
+                # Does not need loading from disk.
+                return get_chunk()
+
+        # Acquire the lock in unique mode.
+        with self._lock.unique():
+            # If it wasn't already loaded by another thread.
+            if not self._chunk_history.has_resource(self._key):
+                # Load it from disk.
+                self._preload()
+
+        with self._lock.shared():
+            # If it was loaded in another thread just read it from the cache.
+            return get_chunk()
+
     def _set(self, chunk: ChunkT | None) -> None:
-        """Lock must be acquired before calling this"""
+        """lock must be acquired in unique mode before calling this."""
         history = self._chunk_history
         if not history.has_resource(self._key):
             if self._l.history_enabled:
@@ -322,14 +339,20 @@ class ChunkHandle(
         :raises:
             LockNotAcquired: If the chunk is already locked by another thread.
         """
-        with self.lock(blocking=False):
+        with self._lock.unique(blocking=False):
             self._set(chunk)
         self.changed.emit()
         self._l.changed.emit()
 
     def delete(self) -> None:
-        """Delete the chunk from the level."""
-        with self.lock(blocking=False):
+        """
+        Delete the chunk from the level.
+        You must acquire the chunk lock before deleting.
+
+        :raises:
+            LockNotAcquired: If the chunk is already locked by another thread.
+        """
+        with self._lock.unique(blocking=False):
             self._set(None)
         self.changed.emit()
         self._l.changed.emit()

amulet/mesh/block/__init__.pyi

@@ -0,0 +1,301 @@
+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

@@ -0,0 +1,198 @@
+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)