Use own size types

1 files changed, 12 insertions, 12 deletions

diff --git a/src/World/World.cpp b/src/World/World.cpp
index 7570d8c..a0b2b0d 100644
--- a/src/World/World.cpp
+++ b/src/World/World.cpp
@@ -36,8 +36,8 @@ std::vector<World::ChunkData*> World::get_visible_chunks(Vector<3> position) {
 }
 
 Chunk* World::get_chunk_for_position(Vector<3> position) {
-    int32_t x = std::round(position.x() / Chunk::Width);
-    int32_t y = std::round(position.z() / Chunk::Width);
+    I32 x = std::round(position.x() / Chunk::Width);
+    I32 y = std::round(position.z() / Chunk::Width);
     auto& data = get({x, y});
     if (data.chunk.has_value()) {
         return &data.chunk.value();
@@ -56,15 +56,15 @@ void World::process_chunk_visibility_updates(const std::unordered_set<ChunkIndex
 }
 
 std::unordered_set<ChunkIndex> World::get_visible_chunk_indices(const Vector<3> position) const {
-    int32_t center_x = std::round(position.x() / Chunk::Width);
-    int32_t center_y = std::round(position.z() / Chunk::Width);
+    I32 center_x = std::round(position.x() / Chunk::Width);
+    I32 center_y = std::round(position.z() / Chunk::Width);
 
     std::unordered_set<ChunkIndex> indices{};
     indices.reserve(m_view_distance_radius * m_view_distance_radius * 4);
     auto radius = m_view_distance_radius;
-    for (int32_t x = -radius; x <= radius; x++) {
-        int32_t height = std::round(std::sqrt(radius * radius - x * x) + 0.5);
-        for (int32_t y = -height; y <= height; y++) {
+    for (I32 x = -radius; x <= radius; x++) {
+        I32 height = std::round(std::sqrt(radius * radius - x * x) + 0.5);
+        for (I32 y = -height; y <= height; y++) {
             indices.emplace(x + center_x, y + center_y);
         }
     }
@@ -85,7 +85,7 @@ std::unordered_set<ChunkIndex> World::load_finished_chunks_from_queue() {
     return indices;
 }
 
-void World::request_generation(ChunkIndex index, float priority) {
+void World::request_generation(ChunkIndex index, Real priority) {
     m_queue.add(index, priority, [=]() -> GenerationResult {
         auto start = timestamp();
         auto chunk = m_generator.generate(index.x, index.y);
@@ -105,7 +105,7 @@ World::ChunkData& World::get(ChunkIndex index) {
     return entry->second;
 }
 
-uint64_t World::timestamp() {
+U64 World::timestamp() {
     auto time = std::chrono::system_clock::now().time_since_epoch();
     auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(time);
     return ms.count();
@@ -135,12 +135,12 @@ void World::try_to_create_mesh_for_chunk(ChunkData& data) {
     data.status = ChunkStatus::Done;
 }
 
-void World::log_chunk_time(uint64_t chunk_time_ms) {
+void World::log_chunk_time(U64 chunk_time_ms) {
     m_statistics.chunk_time_sample_count++;
-    m_statistics.average_chunk_time_ms += ((float)chunk_time_ms - m_statistics.average_chunk_time_ms) / m_statistics.chunk_time_sample_count;
+    m_statistics.average_chunk_time_ms += ((Real)chunk_time_ms - m_statistics.average_chunk_time_ms) / m_statistics.chunk_time_sample_count;
 }
 
-float World::get_average_chunk_time() const {
+Real World::get_average_chunk_time() const {
     return m_statistics.average_chunk_time_ms;
 }