scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor ROM loading methods

Browse Source
This commit is contained in:
scawful
2025-01-18 12:33:33 -05:00
parent 3fc52cce62
commit 339df53674
8 changed files with 183 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/app/editor/graphics/graphics_editor.cc
View File

@@ -702,7 +702,7 @@ absl::Status GraphicsEditor::DrawClipboardImport() {
const auto clipboard_data =
std::vector<uint8_t>(text, text + strlen(text));
ImGui::MemFree((void*)text);
status_ = temp_rom_.LoadFromBytes(clipboard_data);
status_ = temp_rom_.LoadFromData(clipboard_data);
is_open_ = true;
open_memory_editor_ = true;
}

4
src/app/gfx/compression.cc
View File

@@ -756,7 +756,7 @@ absl::Status ValidateCompressionResult(CompressionPiecePointer& chain_head,
if (chain_head->next != nullptr) {
Rom temp_rom;
RETURN_IF_ERROR(
temp_rom.LoadFromBytes(CreateCompressionString(chain_head->next, mode)))
temp_rom.LoadFromData(CreateCompressionString(chain_head->next, mode)))
ASSIGN_OR_RETURN(auto decomp_data,
DecompressV2(temp_rom.data(), 0, temp_rom.size()))
if (!std::equal(decomp_data.begin() + start, decomp_data.end(),
@@ -1176,7 +1176,7 @@ void AddCompressionToChain(CompressionContext& context) {
absl::Status ValidateCompressionResultV3(const CompressionContext& context) {
if (!context.compressed_data.empty()) {
Rom temp_rom;
RETURN_IF_ERROR(temp_rom.LoadFromBytes(context.compressed_data));
RETURN_IF_ERROR(temp_rom.LoadFromData(context.compressed_data));
ASSIGN_OR_RETURN(auto decomp_data,
DecompressV2(temp_rom.data(), 0, temp_rom.size()))

151
src/app/rom.cc
View File

@@ -214,16 +214,15 @@ absl::Status Rom::LoadFromFile(const std::string &filename, bool z3_load) {
return absl::OkStatus();
}
absl::Status Rom::LoadFromPointer(uchar *data, size_t length, bool z3_load) {
if (!data || length == 0)
absl::Status Rom::LoadFromData(const std::vector<uint8_t> &data, bool z3_load) {
if (data.empty()) {
return absl::InvalidArgumentError(
"Could not load ROM: parameter `data` is empty.");
}
if (!palette_groups_.empty()) palette_groups_.clear();
if (rom_data_.size() < length) rom_data_.resize(length);
std::copy(data, data + length, rom_data_.begin());
size_ = length;
rom_data_ = data;
size_ = data.size();
is_loaded_ = true;
if (z3_load) {
@@ -232,17 +231,143 @@ absl::Status Rom::LoadFromPointer(uchar *data, size_t length, bool z3_load) {
return absl::OkStatus();
}
absl::Status Rom::LoadFromBytes(const std::vector<uint8_t> &data) {
if (data.empty()) {
return absl::InvalidArgumentError(
"Could not load ROM: parameter `data` is empty.");
absl::StatusOr<uint8_t> Rom::ReadByte(int offset) {
if (offset >= static_cast<int>(rom_data_.size())) {
return absl::FailedPreconditionError("Offset out of range");
}
rom_data_ = data;
size_ = data.size();
is_loaded_ = true;
return rom_data_[offset];
}
absl::StatusOr<uint16_t> Rom::ReadWord(int offset) {
if (offset + 1 >= static_cast<int>(rom_data_.size())) {
return absl::FailedPreconditionError("Offset out of range");
}
auto result = (uint16_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8));
return result;
}
absl::StatusOr<uint32_t> Rom::ReadLong(int offset) {
if (offset + 2 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError("Offset out of range");
}
auto result = (uint32_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8) |
(rom_data_[offset + 2] << 16));
return result;
}
absl::StatusOr<std::vector<uint8_t>> Rom::ReadByteVector(
uint32_t offset, uint32_t length) const {
if (offset + length > static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError("Offset and length out of range");
}
std::vector<uint8_t> result;
for (uint32_t i = offset; i < offset + length; i++) {
result.push_back(rom_data_[i]);
}
return result;
}
absl::StatusOr<gfx::Tile16> Rom::ReadTile16(uint32_t tile16_id) {
// Skip 8 bytes per tile.
auto tpos = kTile16Ptr + (tile16_id * 0x08);
gfx::Tile16 tile16 = {};
ASSIGN_OR_RETURN(auto new_tile0, ReadWord(tpos))
tile16.tile0_ = gfx::WordToTileInfo(new_tile0);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile1, ReadWord(tpos))
tile16.tile1_ = gfx::WordToTileInfo(new_tile1);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile2, ReadWord(tpos))
tile16.tile2_ = gfx::WordToTileInfo(new_tile2);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile3, ReadWord(tpos))
tile16.tile3_ = gfx::WordToTileInfo(new_tile3);
return tile16;
}
absl::Status Rom::WriteTile16(int tile16_id, const gfx::Tile16 &tile) {
// Skip 8 bytes per tile.
auto tpos = kTile16Ptr + (tile16_id * 0x08);
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile0_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile1_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile2_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile3_)));
return absl::OkStatus();
}
absl::Status Rom::WriteByte(int addr, uint8_t value) {
if (addr >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write byte %#02x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = value;
core::logf("WriteByte: %#06X: %s", addr, core::HexByte(value).data());
return absl::OkStatus();
}
absl::Status Rom::WriteWord(int addr, uint16_t value) {
if (addr + 1 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write word %#04x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
core::logf("WriteWord: %#06X: %s", addr, core::HexWord(value).data());
return absl::OkStatus();
}
absl::Status Rom::WriteShort(int addr, uint16_t value) {
if (addr + 1 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write short %#04x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
core::logf("WriteShort: %#06X: %s", addr, core::HexWord(value).data());
return absl::OkStatus();
}
absl::Status Rom::WriteLong(uint32_t addr, uint32_t value) {
if (addr + 2 >= static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write long %#06x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
rom_data_[addr + 2] = (uint8_t)((value >> 16) & 0xFF);
core::logf("WriteLong: %#06X: %s", addr, core::HexLong(value).data());
return absl::OkStatus();
}
absl::Status Rom::WriteVector(int addr, std::vector<uint8_t> data) {
if (addr + static_cast<int>(data.size()) >
static_cast<int>(rom_data_.size())) {
return absl::InvalidArgumentError(absl::StrFormat(
"Attempt to write vector value failed, address %d out of range", addr));
}
for (int i = 0; i < static_cast<int>(data.size()); i++) {
rom_data_[addr + i] = data[i];
}
core::logf("WriteVector: %#06X: %s", addr, core::HexByte(data[0]).data());
return absl::OkStatus();
}
absl::Status Rom::WriteColor(uint32_t address, const gfx::SnesColor &color) {
uint16_t bgr = ((color.snes() >> 10) & 0x1F) | ((color.snes() & 0x1F) << 10) |
(color.snes() & 0x7C00);
// Write the 16-bit color value to the ROM at the specified address
core::logf("WriteColor: %#06X: %s", address, core::HexWord(bgr).data());
return WriteShort(address, bgr);
}
absl::Status Rom::LoadZelda3() {
// Check if the ROM has a header
constexpr size_t kBaseRomSize = 1048576; // 1MB

189
src/app/rom.h
View File

@@ -41,9 +41,7 @@ constexpr uint32_t kNumRoomBlocksets = 82;
constexpr uint32_t kNumSpritesets = 144;
constexpr uint32_t kNumPalettesets = 72;
constexpr uint32_t kEntranceGfxGroup = 0x5D97;
// TODO: Verify what this was used for in ZS
constexpr uint32_t kMaxGraphics = 0xC3FB5;
constexpr uint32_t kMaxGraphics = 0x0C3FFF; // 0xC3FB5
/**
* @brief A map of version constants for each version of the game.
@@ -69,8 +67,8 @@ class Rom {
*
*/
absl::Status LoadFromFile(const std::string& filename, bool z3_load = true);
absl::Status LoadFromPointer(uchar* data, size_t length, bool z3_load = true);
absl::Status LoadFromBytes(const std::vector<uint8_t>& data);
absl::Status LoadFromData(const std::vector<uint8_t>& data,
bool z3_load = true);
/**
* @brief Saves the Rom data to a file
@@ -102,17 +100,11 @@ class Rom {
*/
absl::Status SaveAllPalettes();
/**
* @brief Expand the Rom data to a specified size.
*/
void Expand(int size) {
rom_data_.resize(size);
size_ = size;
}
/**
* @brief Close the Rom file.
*/
absl::Status Close() {
rom_data_.clear();
size_ = 0;
@@ -120,165 +112,20 @@ class Rom {
return absl::OkStatus();
}
/**
* @brief Precondition check for reading and writing to the Rom.
*/
absl::Status ReadWritePreconditions() const {
if (!is_loaded_) {
return absl::FailedPreconditionError("ROM file not loaded");
}
if (rom_data_.empty() || size_ == 0) {
return absl::FailedPreconditionError(
"File was loaded, but ROM data was empty.");
}
return absl::OkStatus();
}
absl::StatusOr<uint8_t> ReadByte(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset >= static_cast<int>(rom_data_.size())) {
return absl::FailedPreconditionError("Offset out of range");
}
return rom_data_[offset];
}
absl::StatusOr<uint16_t> ReadWord(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + 1 >= static_cast<int>(rom_data_.size())) {
return absl::FailedPreconditionError("Offset out of range");
}
auto result = (uint16_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8));
return result;
}
absl::StatusOr<uint32_t> ReadLong(int offset) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + 2 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError("Offset out of range");
}
auto result = (uint32_t)(rom_data_[offset] | (rom_data_[offset + 1] << 8) |
(rom_data_[offset + 2] << 16));
return result;
}
absl::StatusOr<uint8_t> ReadByte(int offset);
absl::StatusOr<uint16_t> ReadWord(int offset);
absl::StatusOr<uint32_t> ReadLong(int offset);
absl::StatusOr<std::vector<uint8_t>> ReadByteVector(uint32_t offset,
uint32_t length) const {
RETURN_IF_ERROR(ReadWritePreconditions());
if (offset + length > static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError("Offset and length out of range");
}
std::vector<uint8_t> result;
for (uint32_t i = offset; i < offset + length; i++) {
result.push_back(rom_data_[i]);
}
return result;
}
uint32_t length) const;
absl::StatusOr<gfx::Tile16> ReadTile16(uint32_t tile16_id);
absl::StatusOr<gfx::Tile16> ReadTile16(uint32_t tile16_id) {
// Skip 8 bytes per tile.
auto tpos = kTile16Ptr + (tile16_id * 0x08);
gfx::Tile16 tile16 = {};
ASSIGN_OR_RETURN(auto new_tile0, ReadWord(tpos))
tile16.tile0_ = gfx::WordToTileInfo(new_tile0);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile1, ReadWord(tpos))
tile16.tile1_ = gfx::WordToTileInfo(new_tile1);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile2, ReadWord(tpos))
tile16.tile2_ = gfx::WordToTileInfo(new_tile2);
tpos += 2;
ASSIGN_OR_RETURN(auto new_tile3, ReadWord(tpos))
tile16.tile3_ = gfx::WordToTileInfo(new_tile3);
return tile16;
}
absl::Status WriteTile16(int tile16_id, const gfx::Tile16& tile) {
// Skip 8 bytes per tile.
auto tpos = kTile16Ptr + (tile16_id * 0x08);
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile0_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile1_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile2_)));
tpos += 2;
RETURN_IF_ERROR(WriteShort(tpos, gfx::TileInfoToWord(tile.tile3_)));
return absl::OkStatus();
}
absl::Status WriteByte(int addr, uint8_t value) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (addr >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write byte %#02x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = value;
core::logf("WriteByte: %#06X: %s", addr, core::HexByte(value).data());
return absl::OkStatus();
}
absl::Status WriteWord(int addr, uint16_t value) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (addr + 1 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write word %#04x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
core::logf("WriteWord: %#06X: %s", addr, core::HexWord(value).data());
return absl::OkStatus();
}
absl::Status WriteShort(int addr, uint16_t value) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (addr + 1 >= static_cast<int>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write short %#04x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
core::logf("WriteShort: %#06X: %s", addr, core::HexWord(value).data());
return absl::OkStatus();
}
absl::Status WriteLong(uint32_t addr, uint32_t value) {
RETURN_IF_ERROR(ReadWritePreconditions());
if (addr + 2 >= static_cast<uint32_t>(rom_data_.size())) {
return absl::OutOfRangeError(absl::StrFormat(
"Attempt to write long %#06x value failed, address %d out of range",
value, addr));
}
rom_data_[addr] = (uint8_t)(value & 0xFF);
rom_data_[addr + 1] = (uint8_t)((value >> 8) & 0xFF);
rom_data_[addr + 2] = (uint8_t)((value >> 16) & 0xFF);
core::logf("WriteLong: %#06X: %s", addr, core::HexLong(value).data());
return absl::OkStatus();
}
absl::Status WriteVector(int addr, std::vector<uint8_t> data) {
if (addr + static_cast<int>(data.size()) >
static_cast<int>(rom_data_.size())) {
return absl::InvalidArgumentError(absl::StrFormat(
"Attempt to write vector value failed, address %d out of range",
addr));
}
for (int i = 0; i < static_cast<int>(data.size()); i++) {
rom_data_[addr + i] = data[i];
}
core::logf("WriteVector: %#06X: %s", addr, core::HexByte(data[0]).data());
return absl::OkStatus();
}
absl::Status WriteColor(uint32_t address, const gfx::SnesColor& color) {
uint16_t bgr = ((color.snes() >> 10) & 0x1F) |
((color.snes() & 0x1F) << 10) | (color.snes() & 0x7C00);
// Write the 16-bit color value to the ROM at the specified address
core::logf("WriteColor: %#06X: %s", address, core::HexWord(bgr).data());
return WriteShort(address, bgr);
}
absl::Status WriteTile16(int tile16_id, const gfx::Tile16& tile);
absl::Status WriteByte(int addr, uint8_t value);
absl::Status WriteWord(int addr, uint16_t value);
absl::Status WriteShort(int addr, uint16_t value);
absl::Status WriteLong(uint32_t addr, uint32_t value);
absl::Status WriteVector(int addr, std::vector<uint8_t> data);
absl::Status WriteColor(uint32_t address, const gfx::SnesColor& color);
template <typename... Args>
absl::Status WriteTransaction(Args... args) {
@@ -294,18 +141,14 @@ class Rom {
if (!status.ok()) {
return status;
}
if constexpr (sizeof...(args) > 0) {
status = ReadTransaction(std::forward<Args>(args)...);
}
return status;
}
uint8_t& operator[](unsigned long i) {
if (i > size_) {
throw std::out_of_range("Rom index out of range");
}
if (i >= size_) throw std::out_of_range("Rom index out of range");
return rom_data_[i];
}