jaby
/
jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Support Overlays #2

Merged
jaby merged 48 commits from Overlay-The-Beginning_CDDrive into main 2023-04-22 09:38:32 +00:00
Conversation 0 Commits 48 Files Changed 64 +126 -117
3 changed files with 126 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 1143f73f9b - Show all commits

32
include/PSX/System/IOPorts/ioport.hpp
View File

@ -52,18 +52,20 @@ namespace JabyEngine {
typedef volatile T Value;
};
#define __declare_new_io_port(name, adr) \
static auto& name = *reinterpret_cast<name##_v*>(adr)
#define __declare_new_named_io_port(type, name, adr) \
static inline auto& name = *reinterpret_cast<type##_v*>(adr)
/*constexpr name##_io_base() = default; \
\
constexpr name##_io_base(type value) : raw_value(value) {} \
\*/
#define __declare_new_io_port(name, adr) \
__declare_new_named_io_port(name, name, adr)
#define __declare_new_io_port_array(name, adr, size) \
static inline auto& name = reinterpret_cast<name##_v(&)[size]>(*reinterpret_cast<name##_v*>(adr))
#define __declare_io_type(name, type, ...) \
template<template<typename> typename T> \
struct name##_io_base { \
T<type>::Value raw_value = 0; \
typedef name##_io_base Self; \
\
__VA_ARGS__ \
template<typename...ARGS> \
@ -173,12 +175,11 @@ namespace JabyEngine {
};
struct __no_align ubus32_t {
typedef ComplexBitMap<uint16_t> Base16;
__declare_io_type(uint16_t, uint16_t,);
uint16_t_v low;
uint16_t_v high;
VolatileBitMapPOD<Base16> low;
VolatileBitMapPOD<Base16> high;
constexpr ubus32_t(uint32_t value) {
constexpr ubus32_t(uint32_t value) : low{0}, high{0} {
*this = value;
}
@ -187,12 +188,15 @@ namespace JabyEngine {
}
constexpr operator uint32_t() const {
return ((this->high.read_raw() << 16) | this->low.read_raw());
const uint32_t high = *this->high;
const uint32_t low = *this->low;
return ((high << 16) | low);
}
constexpr ubus32_t& operator=(uint32_t value) {
this->low.write_raw(value & 0xFFFF);
this->high.write_raw(value >> 16);
this->low = (value & 0xFFFF);
this->high = (value >> 16);
return *this;
}

158
include/PSX/System/IOPorts/spu_io.hpp
View File

@ -25,60 +25,64 @@ namespace JabyEngine {
//0..3 = +7, +6, +5, +4 or -6, -7, -6, -5
typedef uint8_t Step;
typedef int16_t SimpleVolume;
typedef int16_t SimpleVolume;
typedef volatile int16_t SimpleVolume_v;
struct SampleRate : public ComplexBitMap<uint16_t> {
static constexpr SampleRate from_HZ(double freq) {
typedef volatile uint16_t Adr_v;
typedef volatile uint16_t DataTransferControl_v;
__declare_io_type(SampleRate, uint16_t,
static constexpr Self from_HZ(double freq) {
//4096 == 44100Hz
constexpr double Base = (4096.0 / 44100.0);
return {static_cast<uint16_t>((freq*Base))};
}
};
);
struct SweepVolume : public ComplexBitMap<int16_t> {
__declare_io_type(SweepVolume, int16_t,
// For Volume Mode
static constexpr auto SweepEnable = Bit<int16_t>(15);
static constexpr auto SweepEnable = IOBitSet(15);
static constexpr auto VolumeEnable = !SweepEnable;
static constexpr auto Volume = BitRange<int16_t>::from_to(0, 14);
static constexpr auto Volume = IOValueSet::from_to(0, 14);
// For Sweep Mode
static constexpr auto SweepMode = Bit<Mode>(14);
static constexpr auto SweepDirection = Bit<Direction>(13);
static constexpr auto SweepPhase = Bit<Phase>(12);
static constexpr auto SweepShift = BitRange<Shift>::from_to(2, 6);
static constexpr auto SweepStep = BitRange<Step>::from_to(0, 1);
static constexpr auto SweepMode = IOBitSet(14);
static constexpr auto SweepDirection = IOBitSet(13);
static constexpr auto SweepPhase = IOBitSet(12);
static constexpr auto SweepShift = IOValueSet::from_to(2, 6);
static constexpr auto SweepStep = IOValueSet::from_to(0, 1);
);
__declare_io_type(SR, uint16_t,
static constexpr auto SustainMode = IOBitSet(31 - 16);
static constexpr auto SustainDirection = IOBitSet(30 - 16);
static constexpr auto SustainShift = IOValueSet::from_to((24 - 16), (28 - 16));
static constexpr auto SustainStep = IOValueSet::from_to((22 - 16), (23 - 16));
static constexpr auto ReleaseMode = IOBitSet(21 - 16);
static constexpr auto ReleaseShift = IOValueSet::from_to((16 - 16), (20 - 16));
);
__declare_io_type(AD, uint16_t,
static constexpr auto AttackMode = IOBitSet(15);
static constexpr auto AttackShift = IOValueSet::from_to(10, 14);
static constexpr auto AttackStep = IOValueSet::from_to(8, 9);
static constexpr auto DecayShift = IOValueSet::from_to(4, 7);
static constexpr auto SustainLevel = IOValueSet::from_to(0, 3);
);
struct __no_align Voice_v {
SweepVolume_v volumeLeft; //Offset: 0x0
SweepVolume_v volumeRight; //Offset: 0x2
SampleRate_v sampleRate; //Offset: 0x4;
Adr_v adr; //Offset: 0x6
AD_v ad; //Offset: 0x8
SR_v sr; //Offset: 0xA
SimpleVolume_v currentVolume; //Offset: 0xC
Adr_v repeatAdr; //Offset: 0xE
};
struct SR : public ComplexBitMap<uint16_t> {
static constexpr auto SustainMode = Bit<Mode>(31 - 16);
static constexpr auto SustainDirection = Bit<Direction>(30 - 16);
static constexpr auto SustainShift = BitRange<Shift>::from_to((24 - 16), (28 - 16));
static constexpr auto SustainStep = BitRange<Step>::from_to((22 - 16), (23 - 16));
static constexpr auto ReleaseMode = Bit<Mode>(21 - 16);
static constexpr auto ReleaseShift = BitRange<Shift>::from_to((16 - 16), (20 - 16));
};
struct AD : public ComplexBitMap<uint16_t> {
static constexpr auto AttackMode = Bit<Mode>(15);
static constexpr auto AttackShift = BitRange<Shift>::from_to(10, 14);
static constexpr auto AttackStep = BitRange<Step>::from_to(8, 9);
static constexpr auto DecayShift = BitRange<Shift>::from_to(4, 7);
static constexpr auto SustainLevel = BitRange<uint16_t>::from_to(0, 3);
};
struct __no_align Voice {
VolatileBitMapPOD<SweepVolume> volumeLeft; //Offset: 0x0
VolatileBitMapPOD<SweepVolume> volumeRight; //Offset: 0x2
VolatileBitMapPOD<SampleRate> sampleRate; //Offset: 0x4;
VolatilePOD<uint16_t> adr; //Offset: 0x6
VolatileBitMapPOD<AD> ad; //Offset: 0x8
VolatileBitMapPOD<SR> sr; //Offset: 0xA
VolatilePOD<SimpleVolume> currentVolume; //Offset: 0xC
VolatilePOD<uint16_t> repeatAdr; //Offset: 0xE
};
struct ControlRegister : public ComplexBitMap<uint16_t> {
__declare_io_type(ControlRegister, uint16_t,
enum RAMTransferMode {
Stop = 0,
ManualWrite = 1,
@ -86,30 +90,30 @@ namespace JabyEngine {
DMARead = 3
};
static constexpr auto Enable = Bit<uint16_t>(15);
static constexpr auto Unmute = Bit<uint16_t>(14);
static constexpr auto NoiseFrequcenyShift = BitRange<Shift>::from_to(10, 13);
static constexpr auto NoiseFrequcenyStep = BitRange<Step>::from_to(8, 9);
static constexpr auto ReverbMasterEnable = Bit<uint16_t>(7);
static constexpr auto IRQ9Enable = Bit<uint16_t>(6);
static constexpr auto TransferMode = BitRange<RAMTransferMode>::from_to(4, 5);
static constexpr auto ExternalAudioReverb = Bit<uint16_t>(3);
static constexpr auto CDAudioReverb = Bit<uint16_t>(2);
static constexpr auto ExternalAudioEnable = Bit<uint16_t>(1);
static constexpr auto CDAudioEnable = Bit<uint16_t>(0);
};
static constexpr auto Enable = IOBitSet(15);
static constexpr auto Unmute = IOBitSet(14);
static constexpr auto NoiseFrequcenyShift = IOValueSet::from_to(10, 13);
static constexpr auto NoiseFrequcenyStep = IOValueSet::from_to(8, 9);
static constexpr auto ReverbMasterEnable = IOBitSet(7);
static constexpr auto IRQ9Enable = IOBitSet(6);
static constexpr auto TransferMode = IOValueSet::from_to(4, 5);
static constexpr auto ExternalAudioReverb = IOBitSet(3);
static constexpr auto CDAudioReverb = IOBitSet(2);
static constexpr auto ExternalAudioEnable = IOBitSet(1);
static constexpr auto CDAudioEnable = IOBitSet(0);
);
struct PitchModFlags : public ComplexBitMap<uint16_t> {
static constexpr BitRange<uint16_t> EnableBits = BitRange<uint16_t>::from_to(1, 23);
};
__declare_io_type(PMON, uint16_t,
static constexpr auto EnableBits = IOValueSet::from_to(1, 23);
);
struct NoiseGenerator : public ComplexBitMap<uint16_t> {
static constexpr BitRange<uint16_t> NoiseBits = BitRange<uint16_t>::from_to(0, 23);
};
__declare_io_type(NON, uint16_t,
static constexpr auto NoiseBits = IOValueSet::from_to(0, 23);
);
struct EchoOn : public ComplexBitMap<uint16_t> {
static constexpr BitRange<uint16_t> EchoBits = BitRange<uint16_t>::from_to(0, 23);
};
__declare_io_type(EON, uint16_t,
static constexpr auto EchoBits = IOValueSet::from_to(0, 23);
);
static constexpr size_t VoiceCount = 24;
@ -120,35 +124,35 @@ namespace JabyEngine {
};
struct MainVolume {
__declare_io_port_member(SweepVolume, Left, 0x1F801D80);
__declare_io_port_member(SweepVolume, Right, 0x1F801D82);
__declare_new_named_io_port(SweepVolume, Left, 0x1F801D80);
__declare_new_named_io_port(SweepVolume, Right, 0x1F801D82);
};
struct CDVolume {
__declare_io_port_member_simple(SimpleVolume, Left, 0x1F801DB0);
__declare_io_port_member_simple(SimpleVolume, Right, 0x1F801DB2);
__declare_new_named_io_port(SimpleVolume, Left, 0x1F801DB0);
__declare_new_named_io_port(SimpleVolume, Right, 0x1F801DB2);
};
struct ExternalAudioInputVolume {
__declare_io_port_member_simple(SimpleVolume, Left, 0x1F801DB4);
__declare_io_port_member_simple(SimpleVolume, Right, 0x1F801DB6);
__declare_new_named_io_port(SimpleVolume, Left, 0x1F801DB4);
__declare_new_named_io_port(SimpleVolume, Right, 0x1F801DB6);
};
struct Reverb {
struct Volume {
__declare_io_port_member_simple(SimpleVolume, Left, 0x1F801D84);
__declare_io_port_member_simple(SimpleVolume, Right, 0x1F801D86);
__declare_new_named_io_port(SimpleVolume, Left, 0x1F801D84);
__declare_new_named_io_port(SimpleVolume, Right, 0x1F801D86);
};
__declare_io_port_member_simple(uint16_t, WorkAreaAdr, 0x1F801DA2);
__declare_new_named_io_port(Adr, WorkAreaAdr, 0x1F801DA2);
};
__declare_io_port_global(ControlRegister, Control, 0x1F801DAA);
__declare_io_port_global_simple(uint16_t, DataTransferControl, 0x1F801DAC);
__declare_io_port_global(PitchModFlags, PMON, 0x1F801D90);
__declare_io_port_global(NoiseGenerator, NON, 0x1F801D94);
__declare_io_port_global(EchoOn, EON, 0x1F801D98);
__declare_new_io_port(ControlRegister, 0x1F801DAA);
__declare_new_io_port(DataTransferControl, 0x1F801DAC);
__declare_new_io_port(PMON, 0x1F801D90);
__declare_new_io_port(NON, 0x1F801D94);
__declare_new_io_port(EON, 0x1F801D98);
__declare_io_port_global_array(struct Voice, Voice, 0x1F801C00, VoiceCount);
__declare_new_io_port_array(Voice, 0x1F801C00, VoiceCount);
}
}
#endif //!__JABYENGINE_SPU_IO_HPP__

53
src/Library/src/BootLoader/spu_boot.cpp
View File

@ -6,65 +6,66 @@ namespace JabyEngine {
namespace boot {
namespace SPU {
using namespace JabyEngine;
using namespace SPU_IO;
static void clear_main_volume() {
static constexpr auto StartVol = SPU_IO::SweepVolume::with(SPU_IO::SweepVolume::VolumeEnable, SPU_IO::SweepVolume::Volume.with(I16_MAX >> 2));
static constexpr auto StartVol = SweepVolume_t::from(SweepVolume_t::VolumeEnable, SweepVolume_t::Volume.with(static_cast<int16_t>(I16_MAX >> 2)));
SPU_IO::MainVolume::Left.write({StartVol});
SPU_IO::MainVolume::Right.write({StartVol});
MainVolume::Left = *StartVol;
MainVolume::Right = *StartVol;
}
static void clear_cd_and_ext_audio_volume() {
SPU_IO::CDVolume::Left.write(0);
SPU_IO::CDVolume::Right.write(0);
CDVolume::Left = 0;
CDVolume::Right = 0;
SPU_IO::ExternalAudioInputVolume::Left.write(0);
SPU_IO::ExternalAudioInputVolume::Right.write(0);
ExternalAudioInputVolume::Left = 0;
ExternalAudioInputVolume::Right = 0;
}
static void clear_control_register() {
SPU_IO::Control.write(SPU_IO::ControlRegister());
ControlRegister = 0;
}
static void clear_voice() {
for(auto& voice : SPU_IO::Voice) {
voice.volumeLeft.write(SPU_IO::SweepVolume());
voice.volumeRight.write(SPU_IO::SweepVolume());
voice.sampleRate.write(SPU_IO::SampleRate());
voice.ad.write(SPU_IO::AD());
voice.sr.write(SPU_IO::SR());
voice.currentVolume.write(SPU_IO::SimpleVolume(0));
voice.volumeLeft = *SweepVolume_t();
voice.volumeRight = *SweepVolume_t();
voice.sampleRate = *SampleRate_t();
voice.ad = *AD_t();
voice.sr = *SR_t();
voice.currentVolume = 0;
voice.adr.write(0x200);
voice.repeatAdr.write(0x200);
voice.adr = 0x200;
voice.repeatAdr = 0x200;
}
}
static void clear_pmon() {
SPU_IO::PMON.write(SPU_IO::PitchModFlags());
SPU_IO::PMON = *PMON_t();
}
static void clear_noise_and_echo() {
SPU_IO::NON.write(SPU_IO::NoiseGenerator());
SPU_IO::EON.write(SPU_IO::EchoOn());
SPU_IO::NON = *NON_t();
SPU_IO::EON = *EON_t();
}
static void clear_reverb() {
SPU_IO::Reverb::Volume::Left.write(0);
SPU_IO::Reverb::Volume::Right.write(0);
SPU_IO::Reverb::WorkAreaAdr.write(0);
Reverb::Volume::Left = 0;
Reverb::Volume::Right = 0;
Reverb::WorkAreaAdr = 0;
}
static void setup_control_register() {
static constexpr auto SetupValue = SPU_IO::ControlRegister::with(SPU_IO::ControlRegister::Enable, SPU_IO::ControlRegister::Unmute, SPU_IO::ControlRegister::CDAudioEnable);
static constexpr auto SetupValue = ControlRegister_t::from(ControlRegister_t::Enable, ControlRegister_t::Unmute, ControlRegister_t::CDAudioEnable);
SPU_IO::Control.write({SetupValue});
SPU_IO::ControlRegister = *SetupValue;
}
static void setup_data_transfer_control() {
static constexpr uint16_t RequiredValue = (2 << 1);
SPU_IO::DataTransferControl.write(RequiredValue);
DataTransferControl = RequiredValue;
}
static void wait_voices() {
@ -72,7 +73,7 @@ namespace JabyEngine {
try_again:
for(const auto& voice : SPU_IO::Voice) {
if(voice.currentVolume.read() > Treshhold) {
if(voice.currentVolume > Treshhold) {
goto try_again;
}
}