amulet-core 2.0a8__cp311-cp311-win_amd64.whl → 2.0.1.0.1297307203.19.43.34808.0a0__cp311-cp311-win_amd64.whl

amulet/mesh/block/block_mesh.hpp

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

@@ -1,17 +0,0 @@
-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/palette/biome_palette.hpp

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <stdexcept>
-
-#include <amulet/version.hpp>
-#include <amulet/biome.hpp>
-
-
-namespace Amulet {
-
-	struct PtrLess {
-		bool operator()(std::shared_ptr<Biome> lhs, std::shared_ptr<Biome> rhs) const {
-			return *lhs < *rhs;
-		}
-	};
-
-	class BiomePalette : public VersionRangeContainer {
-	private:
-		std::vector<std::shared_ptr<Biome>> _index_to_biome;
-		std::map<
-			const std::shared_ptr<Biome>,
-			size_t,
-			PtrLess
-		> _biome_to_index;
-	public:
-		const std::vector<std::shared_ptr<Biome>>& get_biomes() const { return _index_to_biome; }
-
-		BiomePalette(std::shared_ptr<VersionRange> version_range) :
-			VersionRangeContainer(version_range),
-			_index_to_biome(),
-			_biome_to_index() {}
-
-		bool operator==(const BiomePalette& other) const {
-			if (size() != other.size()) {
-				return false;
-			}
-			for (size_t i = 0; i < size(); i++) {
-				if (*_index_to_biome[i] != *other._index_to_biome[i]) {
-					return false;
-				}
-			}
-			return true;
-		};
-
-		size_t size() const { return _index_to_biome.size(); }
-
-		std::shared_ptr<Biome> index_to_biome(size_t index) const {
-			return _index_to_biome[index];
-		};
-
-		size_t biome_to_index(std::shared_ptr<Biome> biome) {
-			auto it = _biome_to_index.find(biome);
-			if (it != _biome_to_index.end()) {
-				return it->second;
-			}
-			const auto& version_range = get_version_range();
-			if (!version_range->contains(biome->get_platform(), *biome->get_version())) {
-				throw std::invalid_argument(
-					"Biome(\"" +
-					biome->get_platform() +
-					"\", " +
-					biome->get_version()->toString() +
-					") is incompatible with VersionRange(\"" +
-					version_range->get_platform() +
-					"\", " +
-					version_range->get_min_version()->toString() +
-					", " +
-					version_range->get_max_version()->toString() +
-					")."
-				);
-			}
-			size_t index = _index_to_biome.size();
-			_index_to_biome.push_back(biome);
-			_biome_to_index[biome] = index;
-			return index;
-		};
-
-		bool contains_biome(std::shared_ptr<Biome> biome) const {
-			return _biome_to_index.contains(biome);
-		}
-	};
-
-}

amulet/palette/block_palette.cpp

@@ -1,32 +0,0 @@
-#include "block_palette.hpp"
-
-namespace Amulet {
-	void BlockPalette::serialise(BinaryWriter& writer) const {
-		writer.writeNumeric<std::uint8_t>(1);
-		get_version_range()->serialise(writer);
-		const auto& blocks = get_blocks();
-		writer.writeNumeric<std::uint64_t>(blocks.size());
-		for (const auto& block : blocks) {
-			block->serialise(writer);
-		}
-	}
-	std::shared_ptr<BlockPalette> BlockPalette::deserialise(BinaryReader& reader) {
-		auto version = reader.readNumeric<std::uint8_t>();
-		switch (version) {
-		case 1:
-		{
-			auto version_range = VersionRange::deserialise(reader);
-			auto count = reader.readNumeric<std::uint64_t>();
-			auto palette = std::make_shared<BlockPalette>(version_range);
-			for (auto i = 0; i < count; i++) {
-				if (palette->size() != palette->block_stack_to_index(BlockStack::deserialise(reader))) {
-					throw std::runtime_error("Error deserialising BlockPalette");
-				}
-			}
-			return palette;
-		}
-		default:
-			throw std::invalid_argument("Unsupported BlockComponentData version " + std::to_string(version));
-		}
-	}
-}

amulet/palette/block_palette.hpp

@@ -1,93 +0,0 @@
-#pragma once
-
-#include <map>
-#include <memory>
-#include <stdexcept>
-
-#include <amulet/version.hpp>
-#include <amulet/block.hpp>
-
-#include <amulet/io/binary_reader.hpp>
-#include <amulet/io/binary_writer.hpp>
-
-
-namespace Amulet {
-
-	struct PtrLess {
-		bool operator()(std::shared_ptr<BlockStack> lhs, std::shared_ptr<BlockStack> rhs) const {
-			return *lhs < *rhs;
-		}
-	};
-
-	class BlockPalette : public VersionRangeContainer {
-	private:
-		std::vector<std::shared_ptr<BlockStack>> _index_to_block;
-		std::map<
-			const std::shared_ptr<BlockStack>, 
-			size_t,
-			PtrLess
-		> _block_to_index;
-	public:
-		const std::vector<std::shared_ptr<BlockStack>>& get_blocks() const { return _index_to_block; }
-
-		BlockPalette(std::shared_ptr<VersionRange> version_range) :
-			VersionRangeContainer(version_range),
-			_index_to_block(),
-			_block_to_index() {}
-
-		void serialise(BinaryWriter&) const;
-		static std::shared_ptr<BlockPalette> deserialise(BinaryReader&);
-
-		bool operator==(const BlockPalette& other) const {
-			if (size() != other.size()) {
-				return false;
-			}
-			for (size_t i = 0; i < size(); i++) {
-				if (*_index_to_block[i] != *other._index_to_block[i]) {
-					return false;
-				}
-			}
-			return true;
-		};
-
-		size_t size() const { return _index_to_block.size(); }
-		
-		std::shared_ptr<BlockStack> index_to_block_stack(size_t index) const {
-			return _index_to_block[index];
-		};
-
-		size_t block_stack_to_index(std::shared_ptr<BlockStack> block) {
-			auto it = _block_to_index.find(block);
-			if (it != _block_to_index.end()) {
-				return it->second;
-			}
-			auto version_range = get_version_range();
-			for (const auto& block : block->get_blocks()) {
-				if (!version_range->contains(block->get_platform(), *block->get_version())) {
-					throw std::invalid_argument(
-						"BlockStack(\"" + 
-						block->get_platform() +
-						"\", " +
-						block->get_version()->toString() +
-						") is incompatible with VersionRange(\"" +
-						version_range->get_platform() +
-						"\", " +
-						version_range->get_min_version()->toString() +
-						", " +
-						version_range->get_max_version()->toString() +
-						")."
-					);
-				}
-			}
-			size_t index = _index_to_block.size();
-			_index_to_block.push_back(block);
-			_block_to_index[block] = index;
-			return index;
-		};
-
-		bool contains_block(std::shared_ptr<BlockStack> block) const {
-			return _block_to_index.contains(block);
-		}
-	};
-
-}

amulet/player.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from amulet.data_types import DimensionId
-
-LOCAL_PLAYER = "~local_player"
-
-
-class Player:
-    def __init__(
-        self,
-        player_id: str,
-        dimension_id: DimensionId,
-        location: tuple[float, float, float],
-        rotation: tuple[float, float],
-    ) -> None:
-        """
-        Creates a new instance of :class:`Player` with the given UUID, location, and rotation
-
-        :param player_id: The ID of the player
-        :param location: The location of the player in world coordinates
-        :param rotation: The rotation of the player
-        :param dimension_id: The dimension the player is in
-        """
-        super().__init__()
-        assert isinstance(player_id, str)
-        assert (
-            isinstance(location, tuple)
-            and len(location) == 3
-            and all(isinstance(f, float) for f in location)
-        )
-        assert (
-            isinstance(rotation, tuple)
-            and len(rotation) == 2
-            and all(isinstance(f, float) for f in rotation)
-        )
-        self._player_id = player_id
-        self._location = location
-        self._rotation = rotation
-        self._dimension_id = dimension_id
-
-    def __repr__(self) -> str:
-        return f"Player({self.player_id}, {self.dimension_id}, {self.location}, {self.rotation})"
-
-    @property
-    def player_id(self) -> str:
-        """The player's ID"""
-        return self._player_id
-
-    @property
-    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]:
-        """The current rotation of the player in the world"""
-        return self._rotation
-
-    @property
-    def dimension_id(self) -> DimensionId:
-        """The current dimension the player is in"""
-        return self._dimension_id

amulet/pybind11/collections.hpp

@@ -1,118 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-namespace Amulet {
-	namespace pybind11 {
-		namespace collections {
-			template <typename T>
-			class Iterator : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Iterator, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename T>
-			class Sequence : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Sequence, object, PyObject_Type)
-				using object::object;
-			};
-		
-			template <typename K, typename V>
-			class Mapping : public py::object {
-				PYBIND11_OBJECT_DEFAULT(Mapping, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename K, typename V>
-			class MutableMapping : public py::object {
-				PYBIND11_OBJECT_DEFAULT(MutableMapping, object, PyObject_Type)
-				using object::object;
-			};
-
-			template <typename K>
-			class KeysView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(KeysView, object, PyObject_Type)
-					using object::object;
-			};
-
-			template <typename V>
-			class ValuesView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(ValuesView, object, PyObject_Type)
-					using object::object;
-			};
-
-			template <typename K, typename V>
-			class ItemsView : public py::object {
-				PYBIND11_OBJECT_DEFAULT(ItemsView, object, PyObject_Type)
-					using object::object;
-			};
-		}
-	}
-}
-
-namespace pybind11 {
-	namespace detail {
-		template <typename T>
-		struct handle_type_name<Amulet::pybind11::collections::Iterator<T>> {
-			static constexpr auto name =
-				const_name("collections.abc.Iterator[") +
-				make_caster<T>::name +
-				const_name("]");
-		};
-
-		template <typename T>
-		struct handle_type_name<Amulet::pybind11::collections::Sequence<T>> {
-			static constexpr auto name =
-				const_name("collections.abc.Sequence[") +
-				make_caster<T>::name +
-				const_name("]");
-		};
-
-		template <typename K, typename V>
-		struct handle_type_name<Amulet::pybind11::collections::Mapping<K, V>> {
-			static constexpr auto name =
-				const_name("collections.abc.Mapping[") +
-				make_caster<K>::name +
-				const_name(", ") +
-				make_caster<V>::name +
-				const_name("]");
-		};
-
-		template <typename K, typename V>
-		struct handle_type_name<Amulet::pybind11::collections::MutableMapping<K, V>> {
-			static constexpr auto name =
-				const_name("collections.abc.MutableMapping[") +
-				make_caster<K>::name +
-				const_name(", ")
-				+ make_caster<V>::name +
-				const_name("]");
-		};
-
-		template <typename K>
-		struct handle_type_name<Amulet::pybind11::collections::KeysView<K>> {
-			static constexpr auto name =
-				const_name("collections.abc.KeysView[") +
-				make_caster<K>::name +
-				const_name("]");
-		};
-
-		template <typename V>
-		struct handle_type_name<Amulet::pybind11::collections::ValuesView<V>> {
-			static constexpr auto name =
-				const_name("collections.abc.ValuesView[") +
-				make_caster<V>::name +
-				const_name("]");
-		};
-
-		template <typename K, typename V>
-		struct handle_type_name<Amulet::pybind11::collections::ItemsView<K, V>> {
-			static constexpr auto name =
-				const_name("collections.abc.ItemsView[") +
-				make_caster<K>::name +
-				const_name(", ")
-				+ make_caster<V>::name +
-				const_name("]");
-		};
-	}
-}

amulet/pybind11/numpy.hpp

@@ -1,26 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-#include <pybind11/numpy.h>
-
-namespace py = pybind11;
-
-namespace Amulet {
-	namespace pybind11 {
-		namespace numpy {
-			template <typename T, int ExtraFlags = py::array::forcecast>
-			class array_t : public py::array_t<T, ExtraFlags> {
-				using py::array_t<T, ExtraFlags>::array_t;
-			};
-		}
-	}
-}
-
-namespace pybind11 {
-	namespace detail {
-		template <typename T, int Flags>
-		struct handle_type_name<Amulet::pybind11::numpy::array_t<T, Flags>> {
-			static constexpr auto name
-				= const_name("numpy.typing.NDArray[") + npy_format_descriptor<T>::name + const_name("]");
-		};
-	}
-}

amulet/pybind11/py_module.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <string>
-#include <functional>
-#include <filesystem>
-#include <map>
-#include <utility>
-
-#include <pybind11/pybind11.h>
-#include <amulet/pybind11/typing.hpp>
-
-namespace py = pybind11;
-
-namespace pybind11 {
-	inline void def_package_path(py::module m_parent, py::module m, std::string name) {
-		py::list paths;
-		py::list parent_paths = m_parent.attr("__path__").cast<py::list>();
-		for (auto py_path : parent_paths) {
-			if (py::isinstance<py::str>(py_path)) {
-				std::string path = py_path.cast<std::string>();
-				path.push_back(std::filesystem::path::preferred_separator);
-				path.append(name);
-				paths.append(py::cast(path));
-			}
-		}
-		m.attr("__path__") = paths;
-	}
-
-	inline module def_subpackage(py::module m_parent, std::string name) {
-		auto m = m_parent.def_submodule(name.c_str());
-		def_package_path(m_parent, m, name);
-		return m;
-	}
-}