zoriya/ComSquare
1
0
Fork 0
mirror of https://github.com/zoriya/ComSquare.git synced 2026-05-31 17:33:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

adding unit tests for TileRenderer but 8bpp test isn't finished

Browse Source
This commit is contained in:
Clément Le Bihan
2021-07-09 01:17:37 +02:00
parent 3a70bb9af0
commit 3002f9272e
4 changed files with 178 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+1
View File
@@ -185,6 +185,7 @@ add_executable(unit_tests EXCLUDE_FROM_ALL
tests/CPU/testDMA.cpp
tests/CPU/testAddressingMode.cpp
tests/testMemoryBus.cpp
tests/PPU/testTileRenderer.cpp
)
target_include_directories(unit_tests PUBLIC tests)
target_compile_definitions(unit_tests PUBLIC TESTS)
sources/PPU/TileRenderer.cpp
-1
View File
@@ -65,7 +65,6 @@ namespace ComSquare::PPU
uint8_t TileRenderer::read2BPPValue(uint16_t tileRowAddress, uint8_t pixelIndex)
{
// TODO unit test this
size_t size = this->_ram.getSize();
uint8_t highByte = this->_ram.read(tileRowAddress % size);
uint8_t lowByte = this->_ram.read((tileRowAddress + 1) % size);
sources/PPU/TileRenderer.hpp
+4 -2
View File
@@ -31,9 +31,9 @@ namespace ComSquare::PPU
//! @brief Set the bpp to render graphics
void setBpp(int bpp);
//! @brief Get the current bpp
int getBpp() const;
[[nodiscard]] int getBpp() const;
//! @brief Get the index of the current palette used
int getPaletteIndex() const;
[[nodiscard]] int getPaletteIndex() const;
//! @brief Get the color pixel reference from the tile address and pixelIndex
//! @param tileAddress The starting address of the tile
//! @param pixelIndex The index of the pixel (0 - 255)
@@ -50,6 +50,8 @@ namespace ComSquare::PPU
//! @warning Values are CGRAM colors use PPU::getRealColor function to get the actual real color
std::vector<uint16_t> getPalette(int nbPalette);
//! @brief read the 2bpp value for a pixel (used multple times for 4bpp and 8bpp)
//! @param tileRowAddress Address where the read is done. Usage: Address of the tile row to render
//! @param pixelIndex The offset form tileRowAddress, Usage: the pixel to read
uint8_t read2BPPValue(uint16_t tileRowAddress, uint8_t pixelIndex);
//! @brief render the tile (8x8) at the tileAddress
//! @param tileAddress The address of the tile to render
tests/PPU/testTileRenderer.cpp
+173
View File
@@ -0,0 +1,173 @@
//
// Created by cbihan on 08/07/2021.
//
#include <sstream>
#include <string>
#include <span>
#include <vector>
#include <catch2/catch_test_macros.hpp>
#include "PPU/TileRenderer.hpp"
#include "Ram/Ram.hpp"
#include "PPU/Tile.hpp"
TEST_CASE("read2BPPValue", "[PPU][TileRenderer]")
{
ComSquare::Ram::Ram vram(100, static_cast<ComSquare::Component>(0), "vramTest");
ComSquare::Ram::Ram cgram(512, static_cast<ComSquare::Component>(0), "cgramTest");
ComSquare::PPU::TileRenderer tileRenderer(vram, cgram);
vram.write(0, 0xBA);
vram.write(1, 0x7C);
CHECK(tileRenderer.read2BPPValue(0, 0) == 1);
CHECK(tileRenderer.read2BPPValue(0, 1) == 2);
CHECK(tileRenderer.read2BPPValue(0, 2) == 3);
CHECK(tileRenderer.read2BPPValue(0, 3) == 3);
CHECK(tileRenderer.read2BPPValue(0, 4) == 3);
CHECK(tileRenderer.read2BPPValue(0, 5) == 2);
CHECK(tileRenderer.read2BPPValue(0, 6) == 1);
CHECK(tileRenderer.read2BPPValue(0, 7) == 0);
}
TEST_CASE("read2BPPValue with circular ram", "[PPU][TileRenderer]")
{
ComSquare::Ram::Ram vram(10, static_cast<ComSquare::Component>(0), "vramTest");
ComSquare::Ram::Ram cgram(512, static_cast<ComSquare::Component>(0), "cgramTest");
ComSquare::PPU::TileRenderer tileRenderer(vram, cgram);
vram.write(9, 0xBA);
vram.write(0, 0x7C);
CHECK(tileRenderer.read2BPPValue(9, 0) == 1);
CHECK(tileRenderer.read2BPPValue(9, 1) == 2);
CHECK(tileRenderer.read2BPPValue(9, 2) == 3);
CHECK(tileRenderer.read2BPPValue(9, 3) == 3);
CHECK(tileRenderer.read2BPPValue(9, 4) == 3);
CHECK(tileRenderer.read2BPPValue(9, 5) == 2);
CHECK(tileRenderer.read2BPPValue(9, 6) == 1);
CHECK(tileRenderer.read2BPPValue(9, 7) == 0);
}
TEST_CASE("getPixelReferenceFromTileRow 2bpp", "[PPU][TileRenderer]")
{
ComSquare::Ram::Ram vram(10, static_cast<ComSquare::Component>(0), "vramTest");
ComSquare::Ram::Ram cgram(512, static_cast<ComSquare::Component>(0), "cgramTest");
ComSquare::PPU::TileRenderer tileRenderer(vram, cgram);
tileRenderer.setBpp(2);
vram.write(2, 0xD6);
vram.write(3, 0x00);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 0) == 1);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 1) == 1);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 2) == 0);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 3) == 1);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 4) == 0);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 5) == 1);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 6) == 1);
CHECK(tileRenderer.getPixelReferenceFromTileRow(2, 7) == 0);
}
TEST_CASE("getPixelReferenceFromTileRow 4bpp", "[PPU][TileRenderer]")
{
ComSquare::Ram::Ram vram(40, static_cast<ComSquare::Component>(0), "vramTest");
ComSquare::Ram::Ram cgram(512, static_cast<ComSquare::Component>(0), "cgramTest");
ComSquare::PPU::TileRenderer tileRenderer(vram, cgram);
tileRenderer.setBpp(4);
std::vector<std::string> vramValues {
"7C7C82EE82FE7C7C",
"0000D68254443838",
"7C00AA1082007C00",
"1000540038000000"
};
uint8_t value;
int i = 0;
for (auto row : vramValues) {
while (!row.empty()) {
value = std::stoul(row.substr(0, 2), nullptr, 16);
row.erase(0, 2);
vram.write(i++, value);
}
}
char correctValues[8][8] = {
{0, 7, 7, 7, 7, 7, 0, 0},
{7, 2, 6, 8, 6, 2, 7, 0},
{7, 2, 2, 2, 2, 2, 7, 0},
{0, 7, 7, 7, 7, 7, 0, 0},
{0, 0, 0, 4, 0, 0, 0, 0},
{3, 5, 0, 5, 0, 5, 3, 0},
{0, 3, 4, 5, 4, 3, 0, 0},
{0, 0, 3, 3, 3, 0, 0, 0}
};
i = 0;
int j = 0;
for (const auto &row : correctValues) {
for (const auto &refValue : row) {
CHECK(tileRenderer.getPixelReferenceFromTileRow(i, j++) == refValue);
}
j = 0;
i += 2;
}
}
/*
TEST_CASE("getPixelReferenceFromTileRow 8bpp", "[PPU][TileRenderer]")
{
ComSquare::Ram::Ram vram(100, static_cast<ComSquare::Component>(0), "vramTest");
ComSquare::Ram::Ram cgram(512, static_cast<ComSquare::Component>(0), "cgramTest");
ComSquare::PPU::TileRenderer tileRenderer(vram, cgram);
tileRenderer.setBpp(8);
std::vector<std::string> vramValues {
"0022222223230000",
"2211422141112400",
"2311121212122400",
"0024252525250000",
"0000003300000000",
"3532003100313500",
"0034333133340000",
"0000353636000000",
};
uint8_t value;
int i = 0;
for (auto row : vramValues) {
while (!row.empty()) {
value = std::stoul(row.substr(0, 2), nullptr, 16);
row.erase(0, 2);
vram.write(i++, value);
}
}
uint8_t correctValues[8][8] = {
{0x00, 0x22, 0x22, 0x22, 0x23, 0x23, 0x00, 0x00},
{0x22, 0x11, 0x42, 0x21, 0x41, 0x11, 0x24, 0x00},
{0x23, 0x11, 0x12, 0x12, 0x12, 0x12, 0x24, 0x00},
{0x00, 0x24, 0x25, 0x25, 0x25, 0x25, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00},
{0x35, 0x32, 0x00, 0x31, 0x00, 0x31, 0x35, 0x00},
{0x00, 0x34, 0x33, 0x31, 0x33, 0x34, 0x00, 0x00},
{0x00, 0x00, 0x35, 0x36, 0x36, 0x00, 0x00, 0x00},
};
i = 0;
int j = 0;
for (const auto &row : correctValues) {
for (const auto &refValue : row) {
std::cout << i << ' ' << j << std::endl;
CHECK(tileRenderer.getPixelReferenceFromTileRow(i, j++) == refValue);
}
j = 0;
i += 2;
}
}*/