sigonasr2
/
EarthboundBattleBackgrounds
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use fast types instead. Add DistortionEffect class. Fix up BackgroundLayer class to not include PGE layer arguments anymore.

Browse Source
master
sigonasr2 5 months ago
parent d1837503e0
commit 41ab66d4c9
2 changed files with 67 additions and 47 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 7
      .vs/VSWorkspaceState.json
  2. 107
      EarthboundBattleBackgrounds/EarthboundBattleBackgrounds/main.cpp

7
.vs/VSWorkspaceState.json
Unescape View File

@ -0,0 +1,7 @@
{
"ExpandedNodes": [
""
],
"SelectedNode": "\\EarthboundBattleBackgrounds.sln",
"PreviewInSolutionExplorer": false
}

107
EarthboundBattleBackgrounds/EarthboundBattleBackgrounds/main.cpp
Unescape View File

@ -8,10 +8,10 @@
using namespace olc;
struct Rom{
const static uint16_t MIN_INDEX{};
const static uint16_t MAX_INDEX{326U};
std::array<uint32_t,114>paletteBits;
std::array<uint32_t,103>graphicsBits;
const static uint_fast16_t MIN_INDEX{};
const static uint_fast16_t MAX_INDEX{326U};
std::array<uint_fast32_t,114>paletteBits;
std::array<uint_fast32_t,103>graphicsBits;
enum Command{
UNCOMPRESSED_BLOCK,
RUN_LENGTH_ENCODED_BYTE,
@ -23,8 +23,8 @@ struct Rom{
UNKNOWN_2,
};
static uint32_t snesToHex(uint32_t addr,bool header=true){
uint32_t newAddr{addr};
static uint_fast32_t snesToHex(uint_fast32_t addr,bool header=true){
uint_fast32_t newAddr{addr};
if(newAddr>=0x400000&&newAddr<0x600000);//NO-OP
else if(newAddr>=0xC00000&&newAddr<0x1000000)newAddr-=0xC00000;
else throw std::out_of_range{std::format("SNES address out of range: {}",newAddr)};
@ -32,8 +32,8 @@ struct Rom{
if(header)newAddr+=0x200;
return newAddr-0xA0200;
}
static uint32_t hexToSnes(uint32_t addr,bool header=true){
uint32_t newAddr{addr};
static uint_fast32_t hexToSnes(uint_fast32_t addr,bool header=true){
uint_fast32_t newAddr{addr};
if(header)newAddr-=0x200;
if(newAddr>=0&&newAddr<0x400000)return newAddr+0xC00000;
else if(newAddr>=0x400000&&newAddr<0x600000)return newAddr;
@ -41,22 +41,22 @@ struct Rom{
}
struct DataBlock{
uint32_t addr,ptr;
uint_fast32_t addr,ptr;
std::u8string_view data;
DataBlock(std::u8string_view data,uint32_t loc)
DataBlock(std::u8string_view data,uint_fast32_t loc)
:data(data){
addr=ptr=loc;
}
uint8_t readInt8(){
uint_fast8_t readInt8(){
return data[ptr++];
}
uint16_t readShort(){
uint_fast16_t readShort(){
return readInt8()|(readInt8()<<8);
}
uint32_t readInt32(){
uint_fast32_t readInt32(){
return readInt8()|(readInt8()<<8)|(readInt8()<<16)|(readInt8()<<24);
}
uint32_t getCompressedSize(uint32_t pointer){
uint_fast32_t getCompressedSize(uint_fast32_t pointer){
int32_t bpos{};
int32_t pos{int32_t(pointer)};
int32_t bpos2{};
@ -111,16 +111,16 @@ struct Rom{
}
return bpos;
}
std::vector<uint16_t>decompress(){
uint32_t size{getCompressedSize(ptr)};
std::vector<uint_fast16_t>decompress(){
uint_fast32_t size{getCompressedSize(ptr)};
if(size<1)throw std::runtime_error(std::format("Got an invalid data size of {}",size));
std::vector<uint16_t>blockOutput;
std::vector<uint_fast16_t>blockOutput;
blockOutput.resize(size);
decompressBlock(ptr,blockOutput);
return blockOutput;
}
private:
void decompressBlock(uint32_t ptrStart,std::vector<uint16_t>&block){
void decompressBlock(uint_fast32_t ptrStart,std::vector<uint_fast16_t>&block){
size_t maxLength{block.size()};
int32_t pos{int32_t(ptrStart)};
int32_t bpos{};
@ -184,8 +184,8 @@ struct Rom{
};
struct BattleBackground{
BattleBackground(std::u8string_view data,uint32_t index){
DataBlock readData{data,0xDCA1+index*uint32_t(this->data.size())};
BattleBackground(std::u8string_view data,uint_fast32_t index){
DataBlock readData{data,0xDCA1+index*uint_fast32_t(this->data.size())};
for(int i=0;i<this->data.size();i++){
this->data[i]=readData.readInt8();
}
@ -206,37 +206,37 @@ struct Rom{
byte verticalMovement;
byte horizontalAcceleration;
byte verticalAcceleration;
uint32_t animationEffectsData;
uint_fast32_t animationEffectsData;
};
};
uint32_t GetAnimation(){
uint_fast32_t GetAnimation(){
return (data[13]<<24)+(data[14]<<16)+(data[15]<<8)+data[16];
}
};
struct BackgroundPalette{
std::vector<Pixel>colors;
byte bpp;
uint32_t addr;
BackgroundPalette(std::u8string_view data,uint16_t index,byte bpp)
uint_fast32_t addr;
BackgroundPalette(std::u8string_view data,uint_fast16_t index,byte bpp)
:bpp(bpp){
DataBlock pointer{data,0xDAD9U+index*4U};
uint32_t addr=snesToHex(pointer.readInt32());
uint_fast32_t addr=snesToHex(pointer.readInt32());
DataBlock dataBlock{data,addr};
this->addr=addr;
if(bpp!=2&&bpp!=4)throw std::invalid_argument{std::format("Palette Error: Incorrect color depth specified. Must be 2 or 4, provided {}",bpp)};
for(uint8_t i:std::views::iota(0,pow(2,bpp))){
uint16_t clr16{dataBlock.readShort()};
uint8_t b{((clr16>>10)&31)*8U};
uint8_t g{((clr16>>5)&31)*8U};
uint8_t r{(clr16&31)*8U};
for(uint_fast8_t i:std::views::iota(0,pow(2,bpp))){
uint_fast16_t clr16{dataBlock.readShort()};
uint_fast8_t b{((clr16>>10)&31)*8U};
uint_fast8_t g{((clr16>>5)&31)*8U};
uint_fast8_t r{(clr16&31)*8U};
colors.emplace_back(r,g,b);
}
}
};
using Tile=std::array<std::array<int,8>,8>;
struct BackgroundGraphics{
std::vector<uint16_t>graphicsData;
std::vector<uint16_t>arrayGraphicsData;
std::vector<uint_fast16_t>graphicsData;
std::vector<uint_fast16_t>arrayGraphicsData;
std::vector<Tile>tiles;
byte bpp;
private:
@ -259,14 +259,14 @@ struct Rom{
}
}
public:
BackgroundGraphics(std::u8string_view data,uint16_t index,byte bpp)
BackgroundGraphics(std::u8string_view data,uint_fast16_t index,byte bpp)
:bpp(bpp){
DataBlock graphicsPtr{data,0xD7A1U+index*4U};
DataBlock loadGraphicsPtr{data,snesToHex(graphicsPtr.readInt32())};
graphicsData=loadGraphicsPtr.decompress();
buildTiles();
DataBlock arrayPtrBlock{data,0xD93DU+index*4};
uint32_t arrayPtr{snesToHex(arrayPtrBlock.readInt32())};
uint_fast32_t arrayPtr{snesToHex(arrayPtrBlock.readInt32())};
DataBlock arrayBlock{data,arrayPtr};
arrayGraphicsData=arrayBlock.decompress();
}
@ -283,6 +283,19 @@ struct Rom{
:bitmap(bitmap){}
};
struct DistortionEffect{
enum{
HORIZONTAL=1,
HORIZONTAL_INTERLACED=2,
VERTICAL=3
};
uint_fast16_t type(){
return std::clamp(data[2],uint_fast8_t(1),uint_fast8_t(3U));
}
private:
std::array<uint_fast8_t,17>data;
};
struct PaletteCycle{
std::vector<Pixel>originalCols;
std::vector<Pixel>currentCols;
@ -301,7 +314,7 @@ struct Rom{
PaletteCycle cycle;
BattleBackground&background;
BackgroundGraphics&graphics;
BackgroundLayer(PixelGameEngine*pge,uint8_t pgeLayer,uint16_t backgroundInd,std::vector<BattleBackground>&backgrounds,std::vector<BackgroundPalette>&palettes,std::vector<BackgroundGraphics>&graphics)
BackgroundLayer(PixelGameEngine*pge,uint_fast16_t backgroundInd,std::vector<BattleBackground>&backgrounds,std::vector<BackgroundPalette>&palettes,std::vector<BackgroundGraphics>&graphics)
:pge(pge),spr(new Sprite(256,256)),distorter(*spr),background(backgrounds[backgroundInd]),graphics(graphics[background.graphicsInd]),cycle(background,palettes[background.paletteInd]){}
};
std::u8string data;
@ -309,14 +322,14 @@ struct Rom{
std::vector<BattleBackground>backgrounds;
std::vector<BackgroundPalette>palettes;
std::vector<BackgroundGraphics>graphics;
BackgroundLayer layer1{nullptr,0U,0U,backgrounds},layer2{nullptr,1U,0U,backgrounds};
BackgroundLayer layer1{nullptr,0U,backgrounds,palettes,graphics},layer2{nullptr,0U,backgrounds,palettes,graphics};
Rom(){
#pragma region Setup Reversed Bytes
reversedBytes.resize(256);
for(int i:std::views::iota(0U,reversedBytes.size())){
uint8_t newNumb{};
uint_fast8_t newNumb{};
for(int digit=0;digit<8;digit++){
uint8_t digitVal{1U<<digit};
uint_fast8_t digitVal{1U<<digit};
if(i&digitVal)newNumb|=1<<(7-digit);
}
reversedBytes[i]=newNumb;
@ -327,15 +340,15 @@ struct Rom{
std::ifstream dataStream{"truncated_backgrounds.dat",std::ios_base::binary};
while(dataStream.good())data+=dataStream.get();
for(uint16_t i:std::views::iota(0U,MAX_INDEX+1U)){
for(uint_fast16_t i:std::views::iota(0U,MAX_INDEX+1U)){
backgrounds.emplace_back(data,i);
paletteBits[backgrounds.back().paletteInd]=backgrounds.back().bbp;
graphicsBits[backgrounds.back().graphicsInd]=backgrounds.back().bbp;
}
for(uint16_t i:std::views::iota(0U,paletteBits.size())){
for(uint_fast16_t i:std::views::iota(0U,paletteBits.size())){
palettes.emplace_back(data,i,paletteBits[i]);
}
for(uint16_t i:std::views::iota(0U,graphicsBits.size())){
for(uint_fast16_t i:std::views::iota(0U,graphicsBits.size())){
graphics.emplace_back(data,i,graphicsBits[i]);
}
}
@ -363,8 +376,8 @@ public:
if(GetMouseWheel()<0)yOffset-=32;
if(GetMouseWheel()>0)yOffset+=32;
for(uint8_t row=0;Rom::BackgroundPalette&palette:rom.palettes){
for(uint8_t index=0;Pixel&col:palette.colors){
for(uint_fast8_t row=0;Rom::BackgroundPalette&palette:rom.palettes){
for(uint_fast8_t index=0;Pixel&col:palette.colors){
FillRectDecal(vf2d{index*8.f+8,row*8.f+yOffset},{8,8},col);
index++;
}
@ -372,7 +385,7 @@ public:
}
}
uint8_t selectedPalette{};
uint_fast8_t selectedPalette{};
void GraphicsDisplayTest(){
if(GetMouseWheel()<0)yOffset-=32;
@ -386,14 +399,14 @@ public:
if(GetKey(PGDN).bPressed)selectedPalette=std::clamp(int(selectedPalette)+1,0,int(rom.palettes.size()-1));;
Rom::BackgroundPalette&palette{rom.palettes[selectedPalette]};
for(uint8_t index=0;Pixel&col:palette.colors){
for(uint_fast8_t index=0;Pixel&col:palette.colors){
FillRectDecal(vf2d{index*8.f,8.f},{8,8},col);
index++;
}
DrawRectDecal(vf2d{8.f,8.f},{8*16,8});
for(uint8_t row=0;Rom::BackgroundGraphics&graphics:rom.graphics){
for(uint8_t col=0;Rom::Tile&tile:graphics.tiles){
for(uint_fast8_t row=0;Rom::BackgroundGraphics&graphics:rom.graphics){
for(uint_fast8_t col=0;Rom::Tile&tile:graphics.tiles){
for(int x{};x<tile.size();x++){
for(int y{};y<tile[x].size();y++){
int paletteInd{tile[x][y]};

Write Preview
Loading…
Cancel
Save