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

general cleanup can not work with 4bpp going to check

Browse Source
This commit is contained in:
Clément Le Bihan
2021-06-22 23:54:04 +02:00
parent bc0823342c
commit 7b7520ce69
12 changed files with 152 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sources/Debugger/TileViewer/RAMTileRenderer.cpp
+111
View File
@@ -0,0 +1,111 @@
//
// Created by cbihan on 24/05/2021.
//
#include <complex>
#include <cmath>
#include "RAMTileRenderer.hpp"
#include "PPU/PPU.hpp"
#include "PPU/Tile.hpp"
#include <iostream>
namespace ComSquare::Debugger
{
RAMTileRenderer::RAMTileRenderer()
: _ram(nullptr),
_renderSize(0x5000),
_nbColumns(16),
_ramOffset(0),
_bpp(2),
buffer({{{0}}})
{
}
void RAMTileRenderer::setRam(std::shared_ptr<Ram::Ram> ram)
{
this->_ram = ram;
this->_tileRenderer.setRam(ram);
}
void RAMTileRenderer::render()
{
int bufX = 0;
int bufY = 0;
int nbTilesDrawn = 0;
int resetX = bufX;
for (auto &i : buffer)
i.fill(0);
uint24_t limit = fmin(this->_ram->getSize(), this->_renderSize) + this->_ramOffset;
for (uint24_t i = this->_ramOffset; i < limit; i += PPU::Tile::BaseByteSize * this->_bpp, nbTilesDrawn++) {
if (bufX > 1024 || bufY > 1024)
break;
this->_tileRenderer.render(i);
if (nbTilesDrawn) {
resetX += PPU::Tile::NbPixelsWidth;
bufX = resetX;
bufY -= PPU::Tile::NbPixelsHeight;
}
if (nbTilesDrawn && nbTilesDrawn % this->_nbColumns == 0) {
nbTilesDrawn = 0;
resetX = 0;
bufX = resetX;
bufY += PPU::Tile::NbPixelsHeight;
}
for (const auto &raw : this->_tileRenderer.buffer) {
for (const auto &pixel : raw) {
buffer[bufX++][bufY] = pixel;
}
bufY++;
bufX = resetX;
}
}
}
void RAMTileRenderer::setPaletteIndex(int paletteIndex)
{
this->_tileRenderer.setPaletteIndex(paletteIndex);
}
void RAMTileRenderer::setBpp(int bpp)
{
this->_tileRenderer.setBpp(bpp);
}
void RAMTileRenderer::setCgram(std::shared_ptr<Ram::Ram> ram)
{
this->_tileRenderer.setCgram(ram);
}
void RAMTileRenderer::setRenderSize(int size)
{
this->_renderSize = size;
}
void RAMTileRenderer::setNbColumns(int nbColumns)
{
this->_nbColumns = nbColumns;
}
int RAMTileRenderer::getBpp() const
{
return this->_tileRenderer.getBpp();
}
int RAMTileRenderer::getPaletteIndex() const
{
return this->_tileRenderer.getPaletteIndex();
}
int RAMTileRenderer::getNbColumns() const
{
return this->_nbColumns;
}
void RAMTileRenderer::setRamOffset(int offset)
{
this->_ramOffset = offset;
}
}
sources/Debugger/TileViewer/TileRenderer.hpp → sources/Debugger/TileViewer/RAMTileRenderer.hpp
+14 -14
View File
@@ -5,26 +5,25 @@
#pragma once
#include <array>
#include "PPU/TileRenderer.hpp"
#include "Ram/Ram.hpp"
namespace ComSquare::Debugger
{
class TileRenderer {
class RAMTileRenderer {
private:
//! @brief ram to render
std::shared_ptr<Ram::Ram> _ram;
//! @brief cgram to access the colors
std::shared_ptr<Ram::Ram> _cgram;
//! @brief The bpp to use while rendering
int _bpp;
//! @brief The palette number to use while rendering
int _paletteIndex;
//! @brief The size to render in the ram
int _renderSize;
//! @brief The number of tile columns to display
int _nbColumns;
//! @brief Bytes to skip from the start of the ram
int _ramOffset;
//! @brief The actual bpp to render
int _bpp;
//! @brief The class tha actually render the tile
PPU::TileRenderer _tileRenderer;
public:
//! @brief internal buffer
std::array<std::array<uint32_t, 1024>, 1024> buffer;
@@ -48,15 +47,16 @@ namespace ComSquare::Debugger
int getPaletteIndex() const;
//! @brief Get the numbr of maximum tile columns to render
int getNbColumns() const;
uint8_t getPixelReferenceFromTileRow(uint16_t tileRowAddress, uint8_t pixelIndex);
std::vector<uint16_t> getPalette(int nbPalette);
uint8_t read2BPPValue(uint16_t tileRowAddress, uint8_t pixelIndex);
//! @brief render the selected ram
void render();
TileRenderer();
TileRenderer(const TileRenderer &) = default;
~TileRenderer() = default;
TileRenderer &operator=(const TileRenderer &) = default;
//! @brief ctor
RAMTileRenderer();
//! @brief copy ctor
RAMTileRenderer(const RAMTileRenderer &) = default;
//! @brief dtor
~RAMTileRenderer() = default;
//! @brief assignment operator
RAMTileRenderer &operator=(const RAMTileRenderer &) = default;
};
}
sources/Debugger/TileViewer/TileRenderer.cpp
-161
View File
@@ -1,161 +0,0 @@
//
// Created by cbihan on 24/05/2021.
//
#include <complex>
#include <cmath>
#include "TileRenderer.hpp"
#include "PPU/PPU.hpp"
#include "PPU/Tile.hpp"
#include <iostream>
namespace ComSquare::Debugger
{
TileRenderer::TileRenderer()
: _ram(nullptr),
_cgram(nullptr),
_bpp(2),
_paletteIndex(0),
_renderSize(0x5000),
_nbColumns(16),
buffer({{{0}}})
{
}
void TileRenderer::setRam(std::shared_ptr<Ram::Ram> ram)
{
this->_ram = std::move(ram);
}
void TileRenderer::render()
{
uint8_t colorReference;
uint24_t color;
std::vector<uint16_t> palette = this->getPalette(this->_paletteIndex);
int bufX = 0;
int bufY = 0;
int nbTilesDrawn = 0;
int resetX = bufX;
int it = 0;
for (auto &i : buffer)
i.fill(0);
for (uint24_t i = this->_ramOffset; i < fmin(this->_ram->getSize(), this->_renderSize) + this->_ramOffset; i += 2, it++) {
if (bufX > 1024 || bufY > 1024)
break;
if (it && it % 8 == 0) {
resetX += PPU::Tile::NbPixelsWidth;
bufX = resetX;
bufY -= PPU::Tile::NbPixelsHeight;
i += (this->_bpp - 2) * 0x8;
nbTilesDrawn++;
}
if (nbTilesDrawn && nbTilesDrawn % this->_nbColumns == 0) {
nbTilesDrawn = 0;
resetX = 0;
bufX = resetX;
bufY += PPU::Tile::NbPixelsHeight;
}
for (int j = 0; j < 8; j++) {
colorReference = this->getPixelReferenceFromTileRow(i, j);
color = PPU::getRealColor(palette[colorReference]);
buffer[bufX++][bufY] = color;
}
bufY++;
bufX = resetX;
}
}
void TileRenderer::setPaletteIndex(int paletteIndex)
{
this->_paletteIndex = paletteIndex;
}
void TileRenderer::setBpp(int bpp)
{
this->_bpp = bpp;
}
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);
uint8_t shift = 8 - 1U - pixelIndex;
return ((highByte & (1U << shift)) | ((lowByte & (1U << shift)) << 1U)) >> shift;
}
uint8_t TileRenderer::getPixelReferenceFromTileRow(uint16_t tileRowAddress, uint8_t pixelIndex)
{
// TODO unit test this
uint16_t result = 0;
// TODO do a constexpr
const int TileByteSizeRow = 16;
switch (this->_bpp) {
case 8:
result += this->read2BPPValue(tileRowAddress + TileByteSizeRow * 2, pixelIndex) << 4;
result += this->read2BPPValue(tileRowAddress + TileByteSizeRow * 3, pixelIndex) << 6;
FALLTHROUGH
case 4:
result += this->read2BPPValue(tileRowAddress + TileByteSizeRow, pixelIndex) << 2;
FALLTHROUGH
case 2:
result += this->read2BPPValue(tileRowAddress, pixelIndex);
default:
break;
}
return result;
}
std::vector<uint16_t> TileRenderer::getPalette(int nbPalette)
{
uint16_t nbColors = std::pow(2, this->_bpp);
uint16_t addr = nbPalette * this->_bpp * this->_bpp * 2; // 2 because it's 2 addr for 1 color
std::vector<uint16_t> palette(nbColors);
for (int i = 0; i < nbColors; i++) {
palette[i] = this->_cgram->read(addr);
palette[i] += this->_cgram->read(addr + 1) << 8U;
addr += 2;
}
return palette;
}
void TileRenderer::setCgram(std::shared_ptr<Ram::Ram> ram)
{
this->_cgram = std::move(ram);
}
void TileRenderer::setRenderSize(int size)
{
this->_renderSize = size;
}
void TileRenderer::setNbColumns(int nbColumns)
{
this->_nbColumns = nbColumns;
}
int TileRenderer::getBpp() const
{
return this->_bpp;
}
int TileRenderer::getPaletteIndex() const
{
return this->_paletteIndex;
}
int TileRenderer::getNbColumns() const
{
return this->_nbColumns;
}
void TileRenderer::setRamOffset(int offset)
{
this->_ramOffset = offset;
}
}
sources/Debugger/TileViewer/TileViewer.cpp
+1 -1
View File
@@ -15,7 +15,7 @@ namespace ComSquare::Renderer
#include <iostream>
#include <QtWidgets/QTableWidget>
#include "Utility/Utility.hpp"
#include "TileRenderer.hpp"
#include "RAMTileRenderer.hpp"
#include "PPU/PPU.hpp"
namespace ComSquare::Debugger
sources/Debugger/TileViewer/TileViewer.hpp
+2 -2
View File
@@ -18,7 +18,7 @@ namespace ComSquare::PPU
#include "Renderer/QtRenderer/QtSfmlTileRenderer.hpp"
#include "../../../ui/ui_tileView.h"
#include "Ram/Ram.hpp"
#include "TileRenderer.hpp"
#include "RAMTileRenderer.hpp"
namespace ComSquare::Debugger
{
@@ -37,7 +37,7 @@ namespace ComSquare::Debugger
//! @brief the window
std::unique_ptr<Renderer::QtSFMLTileRenderer> _sfWidget;
//! @brief The tile renderer
TileRenderer _tileRenderer;
RAMTileRenderer _tileRenderer;
//! @brief Change the bpp from the index given by the ui (QT combo box)
void _bppChangeUIHandler(int index);
public: