diff --git a/CMakeLists.txt b/CMakeLists.txt index dbc442d..979715d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ project(ComSquare) add_compile_options(-W -Wall -Wextra -Wshadow) # make unit tests -add_executable(unit_tests +add_executable(unit_tests EXCLUDE_FROM_ALL tests/CPU/testAddressingMode.cpp tests/CPU/testInterupts.cpp tests/testMemoryBus.cpp @@ -240,6 +240,7 @@ add_executable(ComSquare ) target_compile_definitions(ComSquare PUBLIC DEBUGGER_ENABLED) +include_directories(ComSquare sources) find_package(Qt5 COMPONENTS Widgets REQUIRED) diff --git a/sources/PPU/Background.cpp b/sources/PPU/Background.cpp index fcb3d14..ddf5417 100644 --- a/sources/PPU/Background.cpp +++ b/sources/PPU/Background.cpp @@ -6,44 +6,43 @@ #include "PPU.hpp" #include "Background.hpp" #include -#include "../Models/Vector2.hpp" +#include "Models/Vector2.hpp" namespace ComSquare::PPU { Background::Background(ComSquare::PPU::PPU &ppu, int backGroundNumber, bool hasPriority): + _ppu(ppu), + _tileMapsConfig(ppu.getBackgroundSize(backGroundNumber)), + _characterNbPixels(ppu.getCharacterSize(backGroundNumber)), + _bpp(ppu.getBPP(backGroundNumber)), + _directColor(false), + _highRes(false), + _tileMapStartAddress(ppu.getTileMapStartAddress(backGroundNumber)), + _tilesetAddress(ppu.getTilesetAddress(backGroundNumber)), _priority(hasPriority), _bgNumber(backGroundNumber), - _ppu(ppu) + _vram(ppu.vram), + _cgram(ppu.cgram), + buffer({{{0}}}) { - _cgram = ppu.cgram; - _vram = ppu.vram; - _bpp = ppu.getBPP(backGroundNumber); - _characterSize = ppu.getCharacterSize(backGroundNumber); - _tileMapStartAddress = ppu.getTileMapStartAddress(backGroundNumber); - _tilesetAddress = ppu.getTilesetAddress(backGroundNumber); - _tileMaps = ppu.getBackgroundSize(backGroundNumber); - _directColor = false; - _highRes = false; - this->buffer = {{{0}}}; } - void Background::renderBackground() { uint16_t vramAddress = this->_tileMapStartAddress; Vector2 offset = this->_ppu.getBgScroll(this->_bgNumber); - this->backgroundSize.x = this->_tileMaps.x * this->_characterSize.x * NB_CHARACTER_WIDTH; - this->backgroundSize.y = this->_tileMaps.y * this->_characterSize.y * NB_CHARACTER_HEIGHT; + this->backgroundSize.x = this->_tileMapsConfig.x * this->_characterNbPixels.x * NbCharacterWidth; + this->backgroundSize.y = this->_tileMapsConfig.y * this->_characterNbPixels.y * NbCharacterHeight; for (int i = 0; i < 4; i++) { - if (!(i == 1 && this->_tileMaps.x == 1) && !(i > 1 && this->_tileMaps.y == 1)) { + if (!(i == 1 && this->_tileMapsConfig.x == 1) && !(i > 1 && this->_tileMapsConfig.y == 1)) { drawBasicTileMap(vramAddress, offset); } - vramAddress += 0x800; - offset.x += NB_CHARACTER_WIDTH * this->_characterSize.x; + vramAddress += TileMapByteSize; + offset.x += NbCharacterWidth * this->_characterNbPixels.x; if (i == 2) { offset.x = 0; - offset.y += NB_CHARACTER_HEIGHT * this->_characterSize.y; + offset.y += NbCharacterHeight * this->_characterNbPixels.y; } } } @@ -61,14 +60,14 @@ namespace ComSquare::PPU palette = getPalette(tileData.palette); // X horizontal // Y vertical - graphicAddress = this->_tilesetAddress + (tileData.posY * NB_TILE_PER_ROW * this->_bpp * TILE_SIZE) + (tileData.posX * this->_bpp * TILE_SIZE); - for (int i = 0; i < this->_characterSize.y; i++) { - index = i * this->_characterSize.x; + graphicAddress = this->_tilesetAddress + (tileData.posY * NbTilePerRow * this->_bpp * TileBaseByteSize) + (tileData.posX * this->_bpp * TileBaseByteSize); + for (int i = 0; i < this->_characterNbPixels.y; i++) { + index = i * this->_characterNbPixels.x; if (tileData.verticalFlip) - index = (this->_characterSize.y - 1 - i) * this->_characterSize.x; + index = (this->_characterNbPixels.y - 1 - i) * this->_characterNbPixels.x; if (tileData.horizontalFlip) - index += this->_characterSize.x - 1; - for (int j = 0; j < this->_characterSize.x; j++) { + index += this->_characterNbPixels.x - 1; + for (int j = 0; j < this->_characterNbPixels.x; j++) { reference = getPixelReferenceFromTile(graphicAddress, index); color = getRealColor(palette[reference]); if (tileData.tilePriority == this->_priority) // reference 0 is considered as transparency @@ -76,7 +75,7 @@ namespace ComSquare::PPU index += (tileData.horizontalFlip) ? -1 : 1; pos.x++; } - pos.x -= this->_characterSize.x; + pos.x -= this->_characterNbPixels.x; pos.y++; } } @@ -105,18 +104,18 @@ namespace ComSquare::PPU uint8_t Background::getPixelReferenceFromTile(uint16_t tileAddress, uint8_t pixelIndex) { - uint8_t row = pixelIndex / this->_characterSize.x; - uint8_t column = pixelIndex % this->_characterSize.y; + uint8_t row = pixelIndex / this->_characterNbPixels.x; + uint8_t column = pixelIndex % this->_characterNbPixels.y; - if (row >= TILE_PIXEL_HEIGHT) { + if (row >= TileNbPixelsHeight) { tileAddress += 0x80 * this->_bpp; - row -= TILE_PIXEL_HEIGHT; + row -= TileNbPixelsHeight; } - if (column >= TILE_PIXEL_WIDTH) { + if (column >= TileNbPixelsWidth) { tileAddress += 0x8 * this->_bpp; - column -= TILE_PIXEL_WIDTH; + column -= TileNbPixelsWidth; } - // might not work with 8 bpp must check + // TODO might not work with 8 bpp must check tileAddress += 2 * row; return this->getPixelReferenceFromTileRow(tileAddress, column); @@ -129,7 +128,7 @@ namespace ComSquare::PPU uint8_t secondHighByte; uint8_t secondLowByte; uint16_t result = 0; - uint8_t shift = (TILE_PIXEL_WIDTH - 1U - pixelIndex); + uint8_t shift = TileNbPixelsWidth - 1U - pixelIndex; switch (this->_bpp) { case 8: @@ -151,14 +150,14 @@ namespace ComSquare::PPU void Background::drawBasicTileMap(uint16_t baseAddress, Vector2 offset) { uint16_t tileMapValue = 0; - Vector2 pos(0,0); + Vector2 pos(0, 0); uint16_t vramAddress = baseAddress; - while (vramAddress < baseAddress + 0x800) { + while (vramAddress < baseAddress + TileMapByteSize) { // TODO function to read 2 bytes (LSB order or bits reversed) tileMapValue = this->_vram->read(vramAddress); tileMapValue += this->_vram->read(vramAddress + 1) << 8U; - drawBgTile(tileMapValue, {(pos.x * this->_characterSize.x) + offset.x, (pos.y * this->_characterSize.y) + offset.y}); + drawBgTile(tileMapValue, {(pos.x * this->_characterNbPixels.x) + offset.x, (pos.y * this->_characterNbPixels.y) + offset.y}); vramAddress += 2; if (pos.x % 31 == 0 && pos.x) { pos.y++; @@ -181,7 +180,7 @@ namespace ComSquare::PPU void Background::setCharacterSize(Vector2 size) { - this->_characterSize = size; + this->_characterNbPixels = size; } void Background::setBpp(int bpp) @@ -194,7 +193,7 @@ namespace ComSquare::PPU void Background::setTilemaps(Vector2 tileMaps) { - this->_tileMaps = tileMaps; + this->_tileMapsConfig = tileMaps; } void Background::setBgNumber(int bgNumber) diff --git a/sources/PPU/Background.hpp b/sources/PPU/Background.hpp index 907c9fd..b1e7083 100644 --- a/sources/PPU/Background.hpp +++ b/sources/PPU/Background.hpp @@ -19,26 +19,48 @@ namespace ComSquare::PPU { class PPU; class Background { - #define NB_CHARACTER_WIDTH 32 - #define NB_CHARACTER_HEIGHT 32 - #define TILE_PIXEL_WIDTH 8U - #define TILE_PIXEL_HEIGHT 8U - #define TILE_SIZE 8 - #define NB_TILE_PER_ROW 16 + //! @brief The number of character a TileMap has in width + static constexpr int NbCharacterWidth = 32; + //! @brief The number of character a TileMap has in height + static constexpr int NbCharacterHeight = 32; + //! @brief The minimum number of pixel a tile can have in width + static constexpr int TileNbPixelsWidth = 8; + //! @brief The minimum number of pixel a tile can have in height + static constexpr int TileNbPixelsHeight = 8; + //! @brief The number of bytes used by a range of pixels (1 pixel per byte) + //! @note Used like: bpp * TileBaseByteSize to get the size of byte of 1 row of pixels + static constexpr unsigned TileBaseByteSize = 8; + //! @brief The number of rows in one line of VRAM + //! @note If you're lost by this description, open a tile viewer in an emulator, and set the number of tiles in width to 16 graphics + static constexpr unsigned NbTilePerRow = 16; + //! @brief The size of a TileMap in memory + static constexpr unsigned short TileMapByteSize = 0x800; private: - Vector2 _tileMaps; - Vector2 _characterSize; - int _bpp; - bool _directColor; - bool _highRes; - uint16_t _tileMapStartAddress; - uint16_t _tilesetAddress; - bool _priority; - int _bgNumber; + //! @brief the ppu used to get registers values (ex: bg scroll) ComSquare::PPU::PPU &_ppu; - + //! @brief The tilemap configuration nb of tileMap vertically and horizontally + Vector2 _tileMapsConfig; + //! @brief The number of pixels of a character (x: width, y:height) + Vector2 _characterNbPixels; + //! @brief The number of bits per pixels to currently look for each pixel + int _bpp; + // TODO make better doc for direct color & high res + //! @brief PPU official direct color mode + bool _directColor; + //! @brief PPU offical highRes mode + bool _highRes; + //! @brief The first address of the tilemap data + uint16_t _tileMapStartAddress; + //! @brief The first address for tileset data + uint16_t _tilesetAddress; + //! @brief If pixel from this background should be treated as primarily + bool _priority; + //! @brief The bg number (used to get the corresponding scroll) + int _bgNumber; + //! @brief the access to vram std::shared_ptr _vram; + //! @brief The access to cgram std::shared_ptr _cgram; //! @brief Draw a tile on the screen at x y pos void drawBgTile(uint16_t data, Vector2 pos); @@ -61,7 +83,9 @@ namespace ComSquare::PPU //! @param offset The rendering offeset in pixels void drawBasicTileMap(uint16_t baseAddress, Vector2 offset); public: - Vector2 backgroundSize; + //! @brief The size of the background (x, y) + Vector2 backgroundSize; + //! @brief The output buffer (pixels are written on it) std::array, 1024> buffer; Background(ComSquare::PPU::PPU &_ppu, int backGroundNumber, bool hasPriority); //! @brief Render a background on his internal buffer