dungeon_room_loader.cc

Go to the documentation of this file.

#include "dungeon_room_loader.h"
 
#include <algorithm>
#include <future>
#include <map>
#include <mutex>
#include <thread>
 
#ifdef __EMSCRIPTEN__
#include "app/platform/wasm/wasm_loading_manager.h"
#endif
 
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/types/snes_palette.h"
#include "util/log.h"
#include "util/macro.h"
#include "zelda3/dungeon/room.h"
 
namespace yaze::editor {
 
absl::Status DungeonRoomLoader::LoadRoom(int room_id, zelda3::Room& room) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
  if (room_id < 0 || room_id >= 0x128) {
    return absl::InvalidArgumentError("Invalid room ID");
  }
 
  room = zelda3::LoadRoomFromRom(rom_, room_id);
  room.SetGameData(game_data_);  // Ensure room has access to GameData
 
  return absl::OkStatus();
}
 
absl::Status DungeonRoomLoader::LoadAllRooms(DungeonRoomStore& rooms) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  constexpr int kTotalRooms = 0x100 + 40;  // 296 rooms
 
  // Data structures for collecting results
  std::vector<std::pair<int, zelda3::RoomSize>> room_size_results;
  std::vector<std::pair<int, ImVec4>> room_palette_results;
 
#ifdef __EMSCRIPTEN__
  // WASM: Sequential loading to avoid Web Worker explosion
  // std::async creates pthreads which become Web Workers in browsers,
  // causing excessive worker spawning and main thread blocking.
  LOG_DEBUG("Dungeon", "Loading %d dungeon rooms sequentially (WASM build)",
            kTotalRooms);
 
  if (!game_data_) {
    return absl::FailedPreconditionError("GameData not available");
  }
  auto dungeon_man_pal_group = game_data_->palette_groups.dungeon_main;
 
  // Create loading indicator for progress feedback
  auto loading_handle =
      app::platform::WasmLoadingManager::BeginLoading("Loading Dungeon Rooms");
 
  for (int i = 0; i < kTotalRooms; ++i) {
    // Update progress every 10 rooms to reduce overhead
    if (i % 10 == 0) {
      float progress = static_cast<float>(i) / static_cast<float>(kTotalRooms);
      app::platform::WasmLoadingManager::UpdateProgress(loading_handle,
                                                        progress);
 
      // Check for cancellation
      if (app::platform::WasmLoadingManager::IsCancelled(loading_handle)) {
        app::platform::WasmLoadingManager::EndLoading(loading_handle);
        return absl::CancelledError("Dungeon room loading cancelled by user");
      }
    }
 
    // Lazy load: Only load header/metadata, not objects/graphics
    rooms[i] = zelda3::LoadRoomHeaderFromRom(rom_, i);
    rooms[i].SetGameData(game_data_);  // Ensure room has access to GameData
    auto room_size = zelda3::CalculateRoomSize(rom_, i);
    // rooms[i].LoadObjects(); // DEFERRED: Load on demand
 
    const int p_id = rooms[i].ResolveDungeonPaletteId();
    if (p_id >= 0 && p_id < static_cast<int>(dungeon_man_pal_group.size())) {
      auto color = dungeon_man_pal_group[p_id][3];
      room_size_results.emplace_back(i, room_size);
      room_palette_results.emplace_back(rooms[i].palette(), color.rgb());
    }
  }
 
  app::platform::WasmLoadingManager::EndLoading(loading_handle);
#else
  // Native: Parallel loading for performance
  constexpr int kMaxConcurrency =
      8;  // Reasonable thread limit for room loading
 
  // Determine optimal number of threads
  const int max_concurrency = std::min(
      kMaxConcurrency, static_cast<int>(std::thread::hardware_concurrency()));
  const int rooms_per_thread =
      (kTotalRooms + max_concurrency - 1) / max_concurrency;
 
  LOG_DEBUG("Dungeon",
            "Loading %d dungeon rooms using %d threads (%d rooms per thread)",
            kTotalRooms, max_concurrency, rooms_per_thread);
 
  // Thread-safe data structures for collecting results
  std::mutex results_mutex;
 
  // Process rooms in parallel batches
  std::vector<std::future<absl::Status>> futures;
 
  for (int thread_id = 0; thread_id < max_concurrency; ++thread_id) {
    auto task = [this, &rooms, thread_id, rooms_per_thread, &results_mutex,
                 &room_size_results, &room_palette_results,
                 kTotalRooms]() -> absl::Status {
      const int start_room = thread_id * rooms_per_thread;
      const int end_room = std::min(start_room + rooms_per_thread, kTotalRooms);
 
      if (!game_data_) {
        return absl::FailedPreconditionError("GameData not available");
      }
      auto dungeon_man_pal_group = game_data_->palette_groups.dungeon_main;
 
      for (int i = start_room; i < end_room; ++i) {
        // Lazy load: Only load header/metadata
        rooms[i] = zelda3::LoadRoomHeaderFromRom(rom_, i);
        rooms[i].SetGameData(game_data_);  // Ensure room has access to GameData
 
        // Calculate room size
        auto room_size = zelda3::CalculateRoomSize(rom_, i);
 
        // Load room objects - DEFERRED
        // rooms[i].LoadObjects();
 
        // Process palette (ResolveDungeonPaletteId handles the two-level
        // lookup with out-of-range fallback; skip if group is empty).
        const int p_id = rooms[i].ResolveDungeonPaletteId();
        if (p_id >= 0 &&
            p_id < static_cast<int>(dungeon_man_pal_group.size())) {
          auto color = dungeon_man_pal_group[p_id][3];
 
          // Thread-safe collection of results
          {
            std::lock_guard<std::mutex> lock(results_mutex);
            room_size_results.emplace_back(i, room_size);
            room_palette_results.emplace_back(rooms[i].palette(), color.rgb());
          }
        }
      }
 
      return absl::OkStatus();
    };
 
    futures.emplace_back(std::async(std::launch::async, task));
  }
 
  // Wait for all threads to complete
  for (auto& future : futures) {
    RETURN_IF_ERROR(future.get());
  }
#endif
 
  // Process collected results on main thread
  {
    gfx::ScopedTimer postprocess_timer("DungeonRoomLoader::PostProcessResults");
 
    // Sort results by room ID for consistent ordering
    std::sort(room_size_results.begin(), room_size_results.end(),
              [](const auto& a, const auto& b) { return a.first < b.first; });
    std::sort(room_palette_results.begin(), room_palette_results.end(),
              [](const auto& a, const auto& b) { return a.first < b.first; });
 
    // Process room size results
    for (const auto& [room_id, room_size] : room_size_results) {
      room_size_pointers_.push_back(room_size.room_size_pointer);
      room_sizes_.push_back(room_size.room_size);
      if (room_size.room_size_pointer != 0x0A8000) {
        room_size_addresses_[room_id] = room_size.room_size_pointer;
      }
    }
 
    // Process palette results
    for (const auto& [palette_id, color] : room_palette_results) {
      room_palette_[palette_id] = color;
    }
  }
 
  LoadDungeonRoomSize();
  return absl::OkStatus();
}
 
absl::Status DungeonRoomLoader::LoadRoomEntrances(
    std::array<zelda3::RoomEntrance, zelda3::kNumDungeonEntranceSlots>&
        entrances) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Load entrances
  for (int i = 0; i < zelda3::kNumDungeonSpawnPoints; ++i) {
    entrances[i] = zelda3::RoomEntrance(rom_, i, true);
  }
 
  for (int i = 0; i < zelda3::kNumRegularDungeonEntrances; ++i) {
    entrances[i + zelda3::kNumDungeonSpawnPoints] =
        zelda3::RoomEntrance(rom_, i, false);
  }
 
  return absl::OkStatus();
}
 
absl::Status DungeonRoomLoader::LoadDungeonSpawnPoints(
    std::array<zelda3::DungeonSpawnPoint, zelda3::kNumDungeonSpawnPoints>&
        spawn_points) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  for (int spawn_id = 0; spawn_id < zelda3::kNumDungeonSpawnPoints;
       ++spawn_id) {
    ASSIGN_OR_RETURN(spawn_points[spawn_id],
                     zelda3::DungeonSpawnPoint::Load(*rom_, spawn_id));
  }
  return absl::OkStatus();
}
 
void DungeonRoomLoader::LoadDungeonRoomSize() {
  std::map<int, std::vector<int>> rooms_by_bank;
  for (const auto& room : room_size_addresses_) {
    int bank = room.second >> 16;
    rooms_by_bank[bank].push_back(room.second);
  }
 
  // Process and calculate room sizes within each bank
  for (auto& bank_rooms : rooms_by_bank) {
    std::ranges::sort(bank_rooms.second);
 
    for (size_t i = 0; i < bank_rooms.second.size(); ++i) {
      int room_ptr = bank_rooms.second[i];
 
      // Identify the room ID for the current room pointer
      int room_id =
          std::ranges::find_if(room_size_addresses_, [room_ptr](
                                                         const auto& entry) {
            return entry.second == room_ptr;
          })->first;
 
      if (room_ptr != 0x0A8000) {
        if (i < bank_rooms.second.size() - 1) {
          room_sizes_[room_id] = bank_rooms.second[i + 1] - room_ptr;
        } else {
          int bank_end_address = (bank_rooms.first << 16) | 0xFFFF;
          room_sizes_[room_id] = bank_end_address - room_ptr + 1;
        }
        total_room_size_ += room_sizes_[room_id];
      } else {
        room_sizes_[room_id] = 0x00;
      }
    }
  }
}
 
absl::Status DungeonRoomLoader::LoadAndRenderRoomGraphics(zelda3::Room& room) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  room.ReloadGraphics();
 
  return absl::OkStatus();
}
 
absl::Status DungeonRoomLoader::ReloadAllRoomGraphics(DungeonRoomStore& rooms) {
  if (!rom_ || !rom_->is_loaded()) {
    return absl::FailedPreconditionError("ROM not loaded");
  }
 
  // Reload graphics for all rooms
  for (int room_id = 0; room_id < static_cast<int>(rooms.size()); ++room_id) {
    auto* room = rooms.GetIfLoaded(room_id);
    if (room == nullptr) {
      continue;
    }
    auto status = LoadAndRenderRoomGraphics(*room);
    if (!status.ok()) {
      continue;  // Log error but continue with other rooms
    }
  }
 
  return absl::OkStatus();
}
 
}  // namespace yaze::editor