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

amulet/mesh/block/cube.py

@@ -1,149 +0,0 @@
-from typing import Optional
-import numpy
-import itertools
-
-from amulet.mesh.block.block_mesh import BlockMesh, Transparency
-
-BoundsType = tuple[tuple[float, float], tuple[float, float], tuple[float, float]]
-TextureUVType = 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
-cube_face_lut = (
-    {  # This maps face direction to the vertices used (defined in unit_box_coordinates)
-        "down": numpy.array([0, 4, 5, 1]),
-        "up": numpy.array([3, 7, 6, 2]),
-        "north": numpy.array([4, 0, 2, 6]),
-        "east": numpy.array([5, 4, 6, 7]),
-        "south": numpy.array([1, 5, 7, 3]),
-        "west": numpy.array([0, 1, 3, 2]),
-    }
-)
-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: Transparency = Transparency.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:
-    box_coordinates = numpy.array(list(itertools.product(*bounds)))
-    _texture_uv: dict[Optional[str], numpy.ndarray] = {
-        face: numpy.array(texture_uv[i], float) for i, face in enumerate(cube_face_lut)
-    }
-    _verts: dict[Optional[str], numpy.ndarray] = {}
-    _texture_coords: dict[Optional[str], numpy.ndarray] = {}
-    _tint_verts: dict[Optional[str], numpy.ndarray] = {}
-    _tri_faces: dict[Optional[str], numpy.ndarray] = {}
-    for _face_dir in cube_face_lut:
-        _verts[_face_dir] = box_coordinates[
-            cube_face_lut[_face_dir]
-        ].ravel()  # vertex coordinates for this face
-        _texture_coords[_face_dir] = _texture_uv[_face_dir][
-            uv_rotation_lut
-        ]  # texture vertices
-        _tint_verts[_face_dir] = numpy.full((4, 3), tint, dtype=float).ravel()
-        _tri_faces[_face_dir] = tri_face
-
-    texture_paths_arr, texture_index = numpy.unique(
-        (down, up, north, east, south, west), return_inverse=True
-    )
-    texture_paths = tuple(texture_paths_arr)
-    _tri_texture_index: dict[Optional[str], numpy.ndarray] = {
-        side: numpy.full(2, texture_index[side_index], dtype=numpy.uint32)
-        for side_index, side in enumerate(cube_face_lut)
-    }
-
-    if any(do_not_cull):
-        do_not_cull_faces = tuple(
-            face for face, not_cull in zip(cube_face_lut, do_not_cull) if not_cull
-        )
-        for obj in (_verts, _texture_coords, _tint_verts, _tri_texture_index):
-            obj[None] = numpy.concatenate([obj[key] for key in do_not_cull_faces])
-            for key in do_not_cull_faces:
-                del obj[key]
-        _tri_faces[None] = numpy.concatenate(
-            [_tri_faces[key] + 4 * i for i, key in enumerate(do_not_cull_faces)]
-        )
-        for key in do_not_cull_faces:
-            del _tri_faces[key]
-
-    return BlockMesh(
-        3,
-        _verts,
-        _texture_coords,
-        _tint_verts,
-        _tri_faces,
-        _tri_texture_index,
-        texture_paths,
-        transparency,
-    )
-
-
-def get_unit_cube(
-    down: str,
-    up: str,
-    north: str,
-    east: str,
-    south: str,
-    west: str,
-    transparency: Transparency = Transparency.FullOpaque,
-    tint: tuple[int, int, int] = (1, 1, 1),
-) -> BlockMesh:
-    return get_cube(down, up, north, east, south, west, transparency, tint)

amulet/resource_pack/bedrock/__init__.py

@@ -1,2 +0,0 @@
-from .resource_pack import BedrockResourcePack
-from .resource_pack_manager import BedrockResourcePackManager

amulet/resource_pack/bedrock/blockshapes/__init__.py

@@ -1,31 +0,0 @@
-import importlib
-import pkgutil
-
-from .base_blockshape import BaseBlockShape
-
-BlockShapeClasses: dict[str, BaseBlockShape] = {}
-_class_names = set()
-
-
-def _load_blockshape(module_name: str) -> None:
-    blockshape_module = importlib.import_module(module_name)
-    if hasattr(blockshape_module, "BlockShape"):
-        blockshape = getattr(blockshape_module, "BlockShape")
-        if isinstance(blockshape, BaseBlockShape):
-            if blockshape.blockshape in BlockShapeClasses:
-                print(f"Name conflict with blockshape {blockshape.blockshape}")
-            if blockshape.__class__.__name__ in _class_names:
-                print(f"Duplicate class name {blockshape.__class__.__name__}")
-            else:
-                _class_names.add(blockshape.__class__.__name__)
-            BlockShapeClasses[blockshape.blockshape] = blockshape
-
-
-def _load_blockshapes() -> None:
-    package_prefix = __name__ + "."
-
-    for _, name, _ in pkgutil.walk_packages(__path__, package_prefix):
-        _load_blockshape(name)
-
-
-_load_blockshapes()

amulet/resource_pack/bedrock/blockshapes/air.py

@@ -1,35 +0,0 @@
-from amulet.block import Block
-from amulet.mesh.block.block_mesh import BlockMesh, Transparency
-from amulet.resource_pack.bedrock.blockshapes.base_blockshape import (
-    BaseBlockShape,
-)
-
-
-class Air(BaseBlockShape):
-    @property
-    def blockshape(self) -> str:
-        return "air"
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        return True
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        return 0
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-    ) -> BlockMesh:
-        return BlockMesh(3, {}, {}, {}, {}, {}, (), Transparency.Partial)
-
-
-BlockShape = Air()

amulet/resource_pack/bedrock/blockshapes/base_blockshape.py

@@ -1,29 +0,0 @@
-from amulet.block import Block
-from amulet.mesh.block import BlockMesh
-
-
-class BaseBlockShape:
-    @property
-    def blockshape(self) -> str:
-        raise NotImplementedError
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        raise NotImplementedError
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        raise NotImplementedError
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-    ) -> BlockMesh:
-        raise NotImplementedError

amulet/resource_pack/bedrock/blockshapes/bubble_column.py

@@ -1,29 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-from amulet.mesh.block import BlockMesh
-
-
-class BubbleColumn(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "bubble_column"
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-    ) -> BlockMesh:
-        return super().get_block_model(
-            block, north, north, north, north, north, north, transparency
-        )
-
-
-BlockShape = BubbleColumn()

amulet/resource_pack/bedrock/blockshapes/cake.py

@@ -1,46 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet_nbt import AbstractBaseIntTag, IntTag
-
-
-class Cake(PartialBlock):
-    def is_valid(self, block: Block) -> bool:
-        return isinstance(block.properties.get("bite_counter"), IntTag)
-
-    @property
-    def blockshape(self) -> str:
-        return "cake"
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        bite_count = block.properties["bite_counter"]
-        return (
-            (
-                1 / 16
-                + (
-                    bite_count.py_int
-                    if isinstance(bite_count, AbstractBaseIntTag)
-                    else 0
-                )
-                * 2
-                / 16,
-                15 / 16,
-            ),
-            (0, 0.5),
-            (1 / 16, 15 / 16),
-        )
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        bite_counter = block.properties["bite_counter"]
-        assert isinstance(bite_counter, AbstractBaseIntTag)
-        return min(1, bite_counter.py_int)
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, True, True, True, True
-
-
-BlockShape = Cake()

amulet/resource_pack/bedrock/blockshapes/chest.py

@@ -1,54 +0,0 @@
-from typing import Any
-
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet.mesh.block import BlockMesh
-
-
-class Chest(PartialBlock):
-    @property
-    def blockshape(self) -> str:
-        return "chest"
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        return (1 / 16, 15 / 16), (0, 14 / 16), (1 / 16, 15 / 16)
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        return 0
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, True, True, True, True
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-        modify_uv: bool = True,
-        *args: Any,
-        **kwargs: Any
-    ) -> BlockMesh:
-        rotation = {2: 2, 3: 0, 4: 1, 5: 3}.get(
-            block.properties["facing_direction"].py_data, 0
-        )
-
-        return (
-            super()
-            .get_block_model(
-                block, down, up, north, east, south, west, transparency, modify_uv=False
-            )
-            .rotate(0, rotation)
-        )
-
-
-BlockShape = Chest()

amulet/resource_pack/bedrock/blockshapes/comparator.py

@@ -1,51 +0,0 @@
-from typing import Any
-
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.partial_block import (
-    PartialBlock,
-)
-from amulet.mesh.block import BlockMesh
-import amulet_nbt
-
-
-class Comparator(PartialBlock):
-    def is_valid(self, block: Block) -> bool:
-        return isinstance(block.properties.get("direction"), amulet_nbt.TAG_Int)
-
-    @property
-    def blockshape(self) -> str:
-        return "comparator"
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        return (aux_value >> 3) & 1
-
-    def bounds(
-        self, block: Block
-    ) -> tuple[tuple[float, float], tuple[float, float], tuple[float, float]]:
-        return (0, 1), (0, 2 / 16), (0, 1)
-
-    @property
-    def do_not_cull(self) -> tuple[bool, bool, bool, bool, bool, bool]:
-        return False, True, False, False, False, False
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-        *args: Any,
-        **kwargs: Any
-    ) -> BlockMesh:
-        return (
-            super()
-            .get_block_model(block, down, up, north, east, south, west, transparency)
-            .rotate(0, block.properties["direction"].py_data)
-        )
-
-
-BlockShape = Comparator()

amulet/resource_pack/bedrock/blockshapes/cross_texture.py

@@ -1,186 +0,0 @@
-import numpy
-
-from amulet.block import Block
-from amulet.mesh.block.block_mesh import BlockMesh, Transparency
-from amulet.resource_pack.bedrock.blockshapes.base_blockshape import (
-    BaseBlockShape,
-)
-
-
-class Cross(BaseBlockShape):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture"
-
-    def is_valid(self, block: Block) -> bool:
-        """Does the given block have the correct properties to use this blockshape"""
-        return True
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        return aux_value % 16
-
-    @property
-    def tint(self) -> tuple[float, float, float]:
-        return 1, 1, 1
-
-    def get_block_model(
-        self,
-        block: Block,
-        down: str,
-        up: str,
-        north: str,
-        east: str,
-        south: str,
-        west: str,
-        transparency: tuple[bool, bool, bool, bool, bool, bool],
-    ) -> BlockMesh:
-        return BlockMesh(
-            3,
-            {
-                None: numpy.array(
-                    [
-                        0.0625,
-                        0.0,
-                        0.0625,
-                        0.9375,
-                        0.0,
-                        0.9375,
-                        0.9375,
-                        1.0,
-                        0.9375,
-                        0.0625,
-                        1.0,
-                        0.0625,
-                        0.0625,
-                        0.0,
-                        0.9375,
-                        0.9375,
-                        0.0,
-                        0.0625,
-                        0.9375,
-                        1.0,
-                        0.0625,
-                        0.0625,
-                        1.0,
-                        0.9375,
-                        0.9375,
-                        0.0,
-                        0.0625,
-                        0.0625,
-                        0.0,
-                        0.9375,
-                        0.0625,
-                        1.0,
-                        0.9375,
-                        0.9375,
-                        1.0,
-                        0.0625,
-                        0.9375,
-                        0.0,
-                        0.9375,
-                        0.0625,
-                        0.0,
-                        0.0625,
-                        0.0625,
-                        1.0,
-                        0.0625,
-                        0.9375,
-                        1.0,
-                        0.9375,
-                    ],
-                    dtype=numpy.float32,
-                )
-            },
-            {
-                None: numpy.array(
-                    [
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        1.0,
-                        0.0,
-                        0.0,
-                        0.0,
-                    ],
-                    numpy.float32,
-                )
-            },
-            {None: numpy.array(self.tint * 16, numpy.float32)},
-            {
-                None: numpy.array(
-                    [
-                        0,
-                        1,
-                        2,
-                        0,
-                        2,
-                        3,
-                        4,
-                        5,
-                        6,
-                        4,
-                        6,
-                        7,
-                        8,
-                        9,
-                        10,
-                        8,
-                        10,
-                        11,
-                        12,
-                        13,
-                        14,
-                        12,
-                        14,
-                        15,
-                    ],
-                    numpy.uint32,
-                )
-            },
-            {
-                None: numpy.array(
-                    [
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                    ],
-                    numpy.uint32,
-                )
-            },
-            (up,),
-            Transparency.Partial,
-        )
-
-
-BlockShape = Cross()

amulet/resource_pack/bedrock/blockshapes/cross_texture0.py

@@ -1,17 +0,0 @@
-from amulet.block import Block
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-
-
-class Cross0(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture0"
-
-    def texture_index(self, block: Block, aux_value: int) -> int:
-        """The texture index to use within the list for the given Block"""
-        return 0
-
-
-BlockShape = Cross0()

amulet/resource_pack/bedrock/blockshapes/cross_texture_green.py

@@ -1,16 +0,0 @@
-from amulet.resource_pack.bedrock.blockshapes.cross_texture import (
-    Cross,
-)
-
-
-class CrossGreen(Cross):
-    @property
-    def blockshape(self) -> str:
-        return "cross_texture_green"
-
-    @property
-    def tint(self) -> tuple[float, float, float]:
-        return 0, 1, 0
-
-
-BlockShape = CrossGreen()