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

amulet/mesh/block/{missing_block.py → _missing_block.py}

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from .block_mesh import BlockMesh
-from .cube import get_unit_cube
+from amulet.mesh.block import BlockMesh
+from ._cube import get_unit_cube
 
 if TYPE_CHECKING:
     from amulet.resource_pack.abc import BaseResourcePackManager

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/resource_pack/__init__.py

@@ -8,18 +8,19 @@ from amulet.resource_pack.java import (
     JavaResourcePack,
     JavaResourcePackManager,
 )
-from amulet.resource_pack.bedrock import (
-    BedrockResourcePack,
-    BedrockResourcePackManager,
-)
+
+# from amulet.resource_pack.bedrock import (
+#     BedrockResourcePack,
+#     BedrockResourcePackManager,
+# )
 from .unknown_resource_pack import UnknownResourcePack
 
 
 def load_resource_pack(resource_pack_path: str) -> BaseResourcePack:
     if JavaResourcePack.is_valid(resource_pack_path):
         return JavaResourcePack(resource_pack_path)
-    elif BedrockResourcePack.is_valid(resource_pack_path):
-        return BedrockResourcePack(resource_pack_path)
+    # elif BedrockResourcePack.is_valid(resource_pack_path):
+    #     return BedrockResourcePack(resource_pack_path)
     else:
         return UnknownResourcePack(resource_pack_path)
 
@@ -48,15 +49,15 @@ def load_resource_pack_manager(
                 [pack for pack in resource_packs if isinstance(pack, JavaResourcePack)],
                 load,
             )
-        elif isinstance(resource_packs[0], BedrockResourcePack):
-            return BedrockResourcePackManager(
-                [
-                    pack
-                    for pack in resource_packs
-                    if isinstance(pack, BedrockResourcePack)
-                ],
-                load,
-            )
+        # elif isinstance(resource_packs[0], BedrockResourcePack):
+        #     return BedrockResourcePackManager(
+        #         [
+        #             pack
+        #             for pack in resource_packs
+        #             if isinstance(pack, BedrockResourcePack)
+        #         ],
+        #         load,
+        #     )
 
     raise NotImplementedError
     # return UnknownResourcePackManager()

amulet/resource_pack/abc/resource_pack_manager.py

@@ -1,12 +1,10 @@
 from typing import Optional, Iterator, TypeVar, Generic
 import json
-import copy
 
 from amulet.block import Block, BlockStack
-from amulet.mesh.block import BlockMesh
+from amulet.mesh.block import BlockMesh, merge_block_meshes, get_missing_block
 from amulet.resource_pack.abc.resource_pack import BaseResourcePack
 from amulet.img import missing_no_icon_path
-from amulet.mesh.block.missing_block import get_missing_block
 
 PackT = TypeVar("PackT", bound=BaseResourcePack)
 
@@ -74,14 +72,14 @@ class BaseResourcePackManager(Generic[PackT]):
                     block_stack.base_block
                 )
             else:
-                self._cached_models[block_stack] = BlockMesh.merge(
+                self._cached_models[block_stack] = merge_block_meshes(
                     (self._get_model(block_stack.base_block),)
                     + tuple(
                         self._get_model(block_) for block_ in block_stack.extra_blocks
                     )
                 )
 
-        return copy.deepcopy(self._cached_models[block_stack])
+        return self._cached_models[block_stack]
 
     def _get_model(self, block: Block) -> BlockMesh:
         raise NotImplementedError