From 3002f9272e8538fd903d9a3b84024b363d93a695 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Le=20Bihan?= Date: Fri, 9 Jul 2021 01:17:37 +0200 Subject: [PATCH] adding unit tests for TileRenderer but 8bpp test isn't finished --- CMakeLists.txt | 1 + sources/PPU/TileRenderer.cpp | 1 - sources/PPU/TileRenderer.hpp | 6 +- tests/PPU/testTileRenderer.cpp | 173 +++++++++++++++++++++++++++++++++ 4 files changed, 178 insertions(+), 3 deletions(-) create mode 100644 tests/PPU/testTileRenderer.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index ee9d3d6..cad4546 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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) diff --git a/sources/PPU/TileRenderer.cpp b/sources/PPU/TileRenderer.cpp index f480f82..571134a 100644 --- a/sources/PPU/TileRenderer.cpp +++ b/sources/PPU/TileRenderer.cpp @@ -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); diff --git a/sources/PPU/TileRenderer.hpp b/sources/PPU/TileRenderer.hpp index ec2c20a..7444a33 100644 --- a/sources/PPU/TileRenderer.hpp +++ b/sources/PPU/TileRenderer.hpp @@ -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 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 diff --git a/tests/PPU/testTileRenderer.cpp b/tests/PPU/testTileRenderer.cpp new file mode 100644 index 0000000..a4de5e9 --- /dev/null +++ b/tests/PPU/testTileRenderer.cpp @@ -0,0 +1,173 @@ +// +// Created by cbihan on 08/07/2021. +// + +#include +#include +#include +#include +#include +#include "PPU/TileRenderer.hpp" +#include "Ram/Ram.hpp" +#include "PPU/Tile.hpp" + +TEST_CASE("read2BPPValue", "[PPU][TileRenderer]") +{ + ComSquare::Ram::Ram vram(100, static_cast(0), "vramTest"); + ComSquare::Ram::Ram cgram(512, static_cast(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(0), "vramTest"); + ComSquare::Ram::Ram cgram(512, static_cast(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(0), "vramTest"); + ComSquare::Ram::Ram cgram(512, static_cast(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(0), "vramTest"); + ComSquare::Ram::Ram cgram(512, static_cast(0), "cgramTest"); + ComSquare::PPU::TileRenderer tileRenderer(vram, cgram); + + tileRenderer.setBpp(4); + + std::vector 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(0), "vramTest"); + ComSquare::Ram::Ram cgram(512, static_cast(0), "cgramTest"); + ComSquare::PPU::TileRenderer tileRenderer(vram, cgram); + + tileRenderer.setBpp(8); + + std::vector 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; + } +}*/ \ No newline at end of file