amulet-core 2.0a6__cp311-cp311-win_amd64.whl → 2.0a8__cp311-cp311-win_amd64.whl

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)

amulet/mesh/block/_missing_block.py

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

@@ -0,0 +1,107 @@
+#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;
+}
+
+}

amulet/mesh/block/block_mesh.hpp

@@ -0,0 +1,207 @@
+#pragma once
+#include <array>
+#include <cmath>
+#include <map>
+#include <numbers>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <functional>
+
+namespace Amulet {
+
+class FloatVec2 {
+public:
+    float x;
+    float y;
+
+    FloatVec2(float x, float y)
+        : x(x)
+        , y(y)
+    {
+    }
+};
+
+class FloatVec3 {
+public:
+    float x;
+    float y;
+    float z;
+
+    FloatVec3(float x, float y, float z)
+        : x(x)
+        , y(y)
+        , z(z)
+    {
+    }
+};
+
+class Vertex {
+public:
+    // The world coordinate
+    FloatVec3 coord;
+    // The texture coordinate
+    FloatVec2 texture_coord;
+    // The tint colour
+    FloatVec3 tint;
+
+    Vertex(
+        const FloatVec3& coord,
+        const FloatVec2& texture_coord,
+        const FloatVec3& tint)
+        : coord(coord)
+        , texture_coord(texture_coord)
+        , tint(tint)
+    {
+    }
+};
+
+class Triangle {
+public:
+    // The indicies of the vertexes in BlockMeshPart::verts.
+    size_t vert_index_a;
+    size_t vert_index_b;
+    size_t vert_index_c;
+    // The index of the texture in BlockMesh::textures.
+    size_t texture_index;
+
+    Triangle(
+        size_t vert_index_a,
+        size_t vert_index_b,
+        size_t vert_index_c,
+        size_t texture_index)
+        : vert_index_a(vert_index_a)
+        , vert_index_b(vert_index_b)
+        , vert_index_c(vert_index_c)
+        , texture_index(texture_index)
+    {
+    }
+};
+
+class BlockMeshPart {
+public:
+    // The vertices in this mesh part.
+    std::vector<Vertex> verts;
+    // The triangles in this mesh part.
+    std::vector<Triangle> triangles;
+
+    BlockMeshPart(): verts(), triangles() {}
+    BlockMeshPart(
+        const std::vector<Vertex>& verts,
+        const std::vector<Triangle>& triangles)
+        : verts(verts)
+        , triangles(triangles)
+    {
+    }
+};
+
+enum class BlockMeshTransparency : std::uint8_t {
+    // The block is a full block with opaque textures
+    FullOpaque,
+    // The block is a full block with transparent / translucent textures
+    FullTranslucent,
+    // The block is not a full block
+    Partial
+};
+
+enum BlockMeshCullDirection {
+    BlockMeshCullNone,
+    BlockMeshCullUp,
+    BlockMeshCullDown,
+    BlockMeshCullNorth,
+    BlockMeshCullEast,
+    BlockMeshCullSouth,
+    BlockMeshCullWest
+};
+
+typedef std::map<
+    std::pair<std::int8_t, std::int8_t>,
+    std::array<BlockMeshCullDirection, 7>>
+    RotationCullMapType;
+
+// For every combination of 90 degree rotations in y and x axis
+// gives the rotated cull direction.
+extern const RotationCullMapType RotationCullMap;
+
+class BlockMesh {
+public:
+    BlockMeshTransparency transparency;
+    std::vector<std::string> textures;
+    // The mesh parts. Index matches BlockMeshCullDirection.
+    std::array<std::optional<BlockMeshPart>, 7> parts;
+
+    BlockMesh()
+        : transparency()
+        , textures()
+        , parts()
+    {
+    }
+    BlockMesh(
+        BlockMeshTransparency transparency,
+        const std::vector<std::string>& textures,
+        const std::array<std::optional<BlockMeshPart>, 7>& parts)
+        : transparency(transparency)
+        , textures(textures)
+        , parts(parts)
+    {
+    }
+
+    BlockMesh rotate(std::int8_t rotx, std::int8_t roty) const
+    {
+        if (rotx || roty) {
+            auto rotation_key = std::make_pair(rotx, roty);
+            auto it = RotationCullMap.find(rotation_key);
+            if (it != RotationCullMap.end()) {
+                const auto& cull_map = it->second;
+                BlockMesh mesh;
+                mesh.transparency = transparency;
+                mesh.textures = textures;
+
+                // Compuate rotation values
+                float theta_x = std::numbers::pi * rotx / 2.0;
+                float theta_y = std::numbers::pi * roty / 2.0;
+                float sin_x = std::sin(theta_x);
+                float cos_x = std::cos(theta_x);
+                float sin_y = std::sin(theta_y);
+                float cos_y = std::cos(theta_y);
+
+                for (std::uint8_t cull_direction = 0; cull_direction < 7; cull_direction++) {
+                    // Copy the part to the new cull direction.
+                    auto new_cull_direction = cull_map[cull_direction];
+                    auto& part = mesh.parts[new_cull_direction] = parts[cull_direction];
+
+                    if (part) {
+                        // Rotate the vertex coords.
+                        for (auto& vertex : part->verts) {
+                            auto& coord = vertex.coord;
+                            float x = coord.x - 0.5;
+                            float y = coord.y - 0.5;
+                            float z = coord.z - 0.5;
+
+                            // Rotate in X axis
+                            float y_ = y * cos_x - z * sin_x;
+                            z = y * sin_x + z * cos_x;
+                            y = y_;
+
+                            // Rotate in Y axis
+                            float x_ = x * cos_y + z * sin_y;
+                            z = -x * sin_y + z * cos_y;
+                            x = x_;
+
+                            coord.x = x + 0.5;
+                            coord.y = y + 0.5;
+                            coord.z = z + 0.5;
+                        }
+                    }
+                }
+                return mesh;
+            }
+        }
+        return *this;
+    }
+};
+
+ BlockMesh merge_block_meshes(std::vector<std::reference_wrapper<const BlockMesh>>);
+
+}

amulet/mesh/util.py

@@ -0,0 +1,17 @@
+import numpy
+
+
+def rotate_3d(
+    verts: numpy.ndarray, x: float, y: float, z: float, dx: float, dy: float, dz: float
+) -> numpy.ndarray:
+    sb, sh, sa = numpy.sin(numpy.radians([x, y, z]))
+    cb, ch, ca = numpy.cos(numpy.radians([x, y, z]))
+    trmtx = numpy.array(
+        [
+            [ch * ca, -ch * sa * cb + sh * sb, ch * sa * sb + sh * cb],
+            [sa, ca * cb, -ca * sb],
+            [-sh * ca, sh * sa * cb + ch * sb, -sh * sa * sb + ch * cb],
+        ]
+    )
+    origin = numpy.array([dx, dy, dz])
+    return numpy.matmul(verts - origin, trmtx) + origin  # type: ignore

amulet/player.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Tuple
-
 from amulet.data_types import DimensionId
 
 LOCAL_PLAYER = "~local_player"
@@ -12,8 +10,8 @@ class Player:
         self,
         player_id: str,
         dimension_id: DimensionId,
-        location: Tuple[float, float, float],
-        rotation: Tuple[float, float],
+        location: tuple[float, float, float],
+        rotation: tuple[float, float],
     ) -> None:
         """
         Creates a new instance of :class:`Player` with the given UUID, location, and rotation
@@ -49,12 +47,12 @@ class Player:
         return self._player_id
 
     @property
-    def location(self) -> Tuple[float, float, float]:
+    def location(self) -> tuple[float, float, float]:
         """The current location of the player in the world"""
         return self._location
 
     @property
-    def rotation(self) -> Tuple[float, float]:
+    def rotation(self) -> tuple[float, float]:
         """The current rotation of the player in the world"""
         return self._rotation