int TileMap::readFromData(const Tbyte* data,
TileMapFormat format__,
int w__,
int h__) {
int byteCount = 0;
// Set format data
format_ = format__;
w_ = w__;
h_ = h__;
// Reinitialize tile array
reinitializeTileData(w_, h_);
// Read tile identifiers
for (int j = 0; j < h_; j++) {
for (int i = 0; i < w_; i++) {
// Place in array
tileData_[i][j] = TileReference(ByteConversion::fromBytes(
data + byteCount,
ByteSizes::uint16Size,
EndiannessTypes::little,
SignednessTypes::nosign));
byteCount += ByteSizes::uint16Size;
}
}
return byteCount;
}
int TileMap::readFromData(const Tbyte* data,
TileMapFormat format__,
int w__,
int h__,
Tbyte upperByte__) {
int byteCount = 0;
// Set format data
format_ = format__;
w_ = w__;
h_ = h__;
// Set limits based on upper byte (0 bit = 9th bit of tile num)
if ((upperByte__ & 0x01) == 0) {
lowerLimit_ = 0;
upperLimit_ = 256;
}
else {
lowerLimit_ = 256;
upperLimit_ = 512;
}
// Reinitialize tile array
reinitializeTileData(w_, h_);
// Read tile identifiers
for (int j = 0; j < h_; j++) {
for (int i = 0; i < w_; i++) {
// Read low byte of identifier
unsigned int identifier = ByteConversion::fromBytes(
data + byteCount,
ByteSizes::uint8Size,
EndiannessTypes::little,
SignednessTypes::nosign);
// Incorporate upper byte
identifier |= (((unsigned int)(upperByte__)) << 8);
// Place in array
tileData_[i][j] = TileReference(identifier);
byteCount += ByteSizes::uint8Size;
}
}
return byteCount;
}
int MetatileStructureSet::readFromData(LoadedROM& rom,
Taddress address__) {
address_ = address__;
// Count of read bytes
int byteCount = 0;
// Get bank number of the table
int tableBankNum = LoadedROM::directToBankNum(address__);
// Compute table size.
// The first address in the index always points to the first
// structure definition
Taddress contentStartBankedAddress = ByteConversion::fromBytes(
rom.directRead(address__),
ByteSizes::uint16Size,
EndiannessTypes::little,
SignednessTypes::nosign);
// Convert to direct address
Taddress contentStartAddress = 0;
if (contentStartBankedAddress == invalidStructureToken) {
contentStartAddress = invalidRepairAddress;
}
else {
contentStartAddress = LoadedROM::getDirectAddress(
tableBankNum,
contentStartBankedAddress);
}
// Get size of index, given by ((tableStart - indexStart) / entrySize)
int indexEntries = (contentStartAddress - address__) / ByteSizes::uint16Size;
// Read the index.
// Remember the highest index we encounter
int highestIndex = 0;
for (int i = 0; i < indexEntries; i++) {
// Get banked address
Taddress entryBankedAddress = ByteConversion::fromBytes(
rom.directRead(address__ + (i * ByteSizes::uint16Size)),
ByteSizes::uint16Size,
EndiannessTypes::little,
SignednessTypes::nosign);
byteCount += ByteSizes::uint16Size;
// Convert to direct address
int entryAddress = 0;
// If address is invalid, repair
if (entryBankedAddress == invalidStructureToken) {
// std::cout << contentStartAddress << std::endl;
entryAddress = invalidRepairAddress
+ (i * MetatileStructure::dataSize);
}
else {
entryAddress = LoadedROM::getDirectAddress(
tableBankNum,
entryBankedAddress);
}
// Compute the actual index this address corresponds to
int structureIndex = (entryAddress - contentStartAddress)
/ MetatileStructure::dataSize;
// Add mapping to index map
index_.insert(MetatileIndexToStructurePair(i, structureIndex));
if (structureIndex > highestIndex) {
highestIndex = structureIndex;
}
}
// Increment highest index (we're using it as a limit for the read loop)
++highestIndex;
// Read the structure definitions.
// The highest index indicates the actual number of structure definitions
// in the table
for (int i = 0; i < highestIndex; i++) {
// Read each metatile
MetatileStructure metatile;
metatile.readFromData(rom.directRead(contentStartAddress
+ (i * MetatileStructure::dataSize)));
// If reading invalid table, repair tiles
if (contentStartAddress == invalidRepairAddress) {
// std::cout << highestIndex << std::endl;
metatile.upperLeft() = TileReference(invalidRepairTile);
metatile.upperRight() = TileReference(invalidRepairTile);
metatile.lowerLeft() = TileReference(invalidRepairTile);
metatile.lowerRight() = TileReference(invalidRepairTile);
}
// Add to content
primaryStorage_.push_back(metatile);
byteCount += MetatileStructure::dataSize;
}
// HACK: (sort of) Add dummy entries to fill rest of set.
// This fixes issues that I think are caused by out-of-range
// values in the index.
// while (primaryStorage_.size() < 256) {
// primaryStorage_.push_back(MetatileStructure());
// }
return byteCount;
}
