drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 6 Pull Requests Actions Releases 6 Activity

[nostalgia/core] Get TileSheetSet working with 8bpp setting

Browse Source
This commit is contained in:
Gary Talent 2023-12-23 01:23:31 -06:00
parent fcf6f00797
commit 46d1313797
3 changed files with 57 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nostalgia/modules/core/include/nostalgia/core/gfx.hpp
View File

@ -23,6 +23,7 @@ struct Sprite {
unsigned spriteShape = 0;
unsigned spriteSize = 0;
unsigned flipX = 0;
unsigned bpp = 0;
/**
* Valid priorities: 0-3
*/
@ -38,6 +39,7 @@ oxModelBegin(Sprite)
oxModelField(spriteShape)
oxModelField(spriteSize)
oxModelField(flipX)
oxModelField(bpp)
oxModelField(priority)
oxModelEnd()

91
src/nostalgia/modules/core/src/gba/gfx.cpp
View File

@ -60,6 +60,25 @@ constexpr ox::Error model(auto *io, ox::CommonPtrWith<GbaPaletteTarget> auto *t)
}
}
[[nodiscard]]
static bool loadPixel(TileSheetSetEntry const&setEntry, size_t &sectionIdx, int tileIdx) noexcept {
if (setEntry.sections.size() <= sectionIdx) {
return false;
}
auto &section = setEntry.sections[sectionIdx];
if (tileIdx < section.begin) {
return false;
}
if (tileIdx > section.end()) {
if (sectionIdx >= setEntry.sections.size()) {
return false;
}
++sectionIdx;
return tileIdx > section.begin && tileIdx <= section.end();
}
return true;
}
constexpr ox::Error model(auto *io, ox::CommonPtrWith<GbaTileMapTarget> auto *t) noexcept {
oxReturnError(io->template setTypeInfo<CompactTileSheet>());
oxReturnError(io->field("bpp", &t->bpp));
@ -71,43 +90,27 @@ constexpr ox::Error model(auto *io, ox::CommonPtrWith<GbaTileMapTarget> auto *t)
return OxError(1, "Cannot load an 8 BPP tilesheet into a 4 BPP CBB");
}
ox::Error out{};
uint16_t intermediate = 0;
if (t->setEntry) {
// The following code is atrocious, but it works.
// It might be possible to clean it up a little, but it probably
// cannot be seriously optimized without preloading TileSheets.
// Consider building an array of bitmaps (Array<uint64_t, 4>)
// so this can be done with a single bitmap look up.
size_t sectionIdx = 0;
if (t->targetBpp == t->bpp) {
TileSheetSetEntrySection const*section = &t->setEntry->sections[0];
size_t sectionIdx = 1;
size_t writeIt = 0;
uint16_t intermediate = 0;
size_t const fourBpp = t->bpp == 4;
const auto handleTileMap = [t, &intermediate, &section, &sectionIdx, &writeIt, fourBpp]
(std::size_t i, uint8_t const *tile) {
if (!section) {
return ox::Error{};
}
(std::size_t i, uint8_t const*tile) {
auto const tileIdx = static_cast<int>((i * (2 * fourBpp)) / PixelsPerTile);
if (tileIdx < section->begin) {
if (!loadPixel(*t->setEntry, sectionIdx, tileIdx)) {
return ox::Error{};
}
if (tileIdx > section->end()) {
if (sectionIdx >= t->setEntry->sections.size()) {
section = nullptr;
return ox::Error{};
}
section = &t->setEntry->sections[sectionIdx];
++sectionIdx;
if (tileIdx < section->begin || tileIdx > section->end()) {
return ox::Error{};
}
}
if (writeIt & 1) { // writeIt is odd
if (writeIt & 1) { // i is odd
intermediate |= static_cast<uint16_t>(*tile) << 8;
t->tileMap[writeIt / 2] = intermediate;
++t->tileWriteIdx;
} else { // writeIt is even
} else { // i is even
intermediate = *tile & 0x00ff;
}
++writeIt;
@ -115,31 +118,30 @@ constexpr ox::Error model(auto *io, ox::CommonPtrWith<GbaTileMapTarget> auto *t)
};
out = io->template field<uint8_t, decltype(handleTileMap)>("tileMap", handleTileMap);
} else if (t->targetBpp > t->bpp) { // 4 -> 8 bits
const auto handleTileMap = [t, &intermediate](std::size_t i, uint8_t const *tile) {
if (i & 1) { // i is odd
intermediate |= static_cast<uint16_t>(*tile) << 8;
// write 4 pixels from intermediate
t->tileMap[i - 3] = (intermediate & 0b0000'0000'0000'1111) >> 0;
t->tileMap[i - 2] = (intermediate & 0b0000'0000'1111'0000) >> 4;
t->tileMap[i - 1] = (intermediate & 0b0000'1111'0000'0000) >> 8;
t->tileMap[i - 0] = (intermediate & 0b1111'0000'0000'0000) >> 14;
++t->tileWriteIdx;
} else { // i is even
intermediate = *tile & 0x00ff;
const auto handleTileMap = [t, &sectionIdx](std::size_t writeIt, uint8_t const*tile) {
auto constexpr BytesPerTile4Bpp = 32;
auto const tileIdx = static_cast<int>(writeIt / BytesPerTile4Bpp);
if (!loadPixel(*t->setEntry, sectionIdx, tileIdx)) {
return ox::Error{};
}
uint16_t const px1 = *tile & 0xf;
uint16_t const px2 = *tile >> 4;
t->tileMap[t->tileWriteIdx] = static_cast<uint16_t>(px1 | (px2 << 8));
++t->tileWriteIdx;
return ox::Error{};
};
out = io->template field<uint8_t, decltype(handleTileMap)>("tileMap", handleTileMap);
}
} else {
const auto handleTileMap = [t, &intermediate](std::size_t i, const uint8_t *tile) {
uint16_t intermediate = 0;
const auto handleTileMap = [t, &intermediate](std::size_t i, const uint8_t*tile) {
if (i & 1) { // i is odd
intermediate |= static_cast<uint16_t>(*tile) << 8;
t->tileMap[i / 2] = intermediate;
} else { // i is even
intermediate = *tile & 0x00ff;
}
return OxError(0);
return ox::Error{};
};
out = io->template field<uint8_t, decltype(handleTileMap)>("tileMap", handleTileMap);
}
@ -181,7 +183,6 @@ ox::Error loadSpritePalette(
static ox::Error loadTileSheetSet(
Context &ctx,
unsigned &bpp,
uint16_t *tileMapTargetMem,
TileSheetSet const&set) noexcept {
auto &rom = ctx.rom();
@ -189,10 +190,12 @@ static ox::Error loadTileSheetSet(
for (auto const&entry : set.entries) {
oxRequire(tsStat, rom.stat(entry.tilesheet));
oxRequire(ts, rom.directAccess(entry.tilesheet));
unsigned tilesheetBpp{};
GbaTileMapTarget target{
.bpp = bpp,
.bpp = tilesheetBpp,
.defaultPalette = {},
.tileMap = tileMapTargetMem + tileWriteIdx,
.targetBpp = static_cast<unsigned>(set.bpp),
.setEntry = &entry,
};
oxReturnError(ox::readMC(ts, static_cast<std::size_t>(tsStat.size), &target));
@ -232,9 +235,10 @@ ox::Error loadBgTileSheet(
Context &ctx,
unsigned cbb,
TileSheetSet const&set) noexcept {
auto &bpp = ctx.cbbData[cbb].bpp;
oxReturnError(loadTileSheetSet(ctx, bpp, MEM_BG_TILES[cbb].data(), set));
auto const bpp = static_cast<unsigned>(set.bpp);
oxReturnError(loadTileSheetSet(ctx, MEM_BG_TILES[cbb].data(), set));
// update bpp of all bgs with the updated cbb
ctx.cbbData[cbb].bpp = bpp;
teagba::iterateBgCtl([bpp, cbb](volatile BgCtl &bgCtl) {
if (teagba::bgCbb(bgCtl) == cbb) {
teagba::bgSetBpp(bgCtl, bpp);
@ -276,8 +280,8 @@ ox::Error loadSpriteTileSheet(
ox::Error loadSpriteTileSheet(
Context &ctx,
TileSheetSet const&set) noexcept {
unsigned bpp{};
oxReturnError(loadTileSheetSet(ctx, bpp, MEM_SPRITE_TILES, set));
auto const bpp = static_cast<unsigned>(set.bpp);
oxReturnError(loadTileSheetSet(ctx, MEM_SPRITE_TILES, set));
setSpritesBpp(bpp);
return {};
}
@ -340,17 +344,20 @@ void showSprite(Context&, unsigned idx) noexcept {
void setSprite(Context&, uint_t idx, Sprite const&s) noexcept {
//oxAssert(g_spriteUpdates < config::GbaSpriteBufferLen, "Sprite update buffer overflow");
uint16_t const eightBpp = s.bpp == 8;
teagba::addSpriteUpdate({
.attr0 = static_cast<uint16_t>(
(static_cast<uint16_t>(s.y & ox::onMask<uint8_t>(0b111'1111)))
| (static_cast<uint16_t>(1) << 10) // enable alpha
| (static_cast<uint16_t>(eightBpp) << 13)
| (static_cast<uint16_t>(s.spriteShape) << 14)),
.attr1 = static_cast<uint16_t>(
(static_cast<uint16_t>(s.x) & ox::onMask<uint8_t>(8))
| (static_cast<uint16_t>(s.flipX) << 12)
| (static_cast<uint16_t>(s.spriteSize) << 14)),
.attr2 = static_cast<uint16_t>(
(static_cast<uint16_t>(s.tileIdx & ox::onMask<uint16_t>(8)))
// double tileIdx if 8 bpp
(static_cast<uint16_t>((s.tileIdx * (1 + eightBpp)) & ox::onMask<uint16_t>(8)))
| (static_cast<uint16_t>(s.priority & 0b11) << 10)),
.idx = static_cast<uint16_t>(idx),
});

2
src/nostalgia/player/app.cpp
View File

@ -109,12 +109,14 @@ static ox::Error runTileSheetSetTest(turbine::Context &tctx) {
.x = 12 * 8,
.y = 9 * 8,
.tileIdx = 3,
.bpp = static_cast<unsigned>(set.bpp),
});
core::setSprite(*cctx, 17, {
.enabled = true,
.x = 14 * 8,
.y = 9 * 8,
.tileIdx = 5,
.bpp = static_cast<unsigned>(set.bpp),
});
turbine::setKeyEventHandler(tctx, testKeyEventHandler);
return turbine::run(tctx);