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

More clean-up

This commit is contained in:
Jaby 2024-12-29 23:40:42 +01:00
parent dc3e5095e4
commit 322f566777
9 changed files with 59 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/PoolBox/application/src/Custom/file_parser.cpp
View File

@ -8,7 +8,7 @@ namespace JabyEngine {
uint32_t sfx_id; uint32_t sfx_id;
}; };
static Progress parse_jingle(State::Configuration& config, JingleState& jingle) { static Progress parse_jingle(State::CDDataProcessor& data_proc, JingleState& jingle) {
SPU::voice[jingle.sfx_id].play(); SPU::voice[jingle.sfx_id].play();
return Progress::Done; return Progress::Done;
} }

21
include/PSX/File/Processor/file_processor.hpp
View File

@ -10,21 +10,20 @@ namespace JabyEngine {
uint32_t reserved[8]; uint32_t reserved[8];
}; };
struct Configuration; struct CDDataProcessor;
template<typename T> template<typename T>
using GenericProcessRoutine = Progress (*)(Configuration&, T&); using GenericProcessRoutine = Progress (*)(CDDataProcessor&, T&);
typedef GenericProcessRoutine<Reserved> ProcessRoutine; typedef GenericProcessRoutine<Reserved> ProcessRoutine;
// TODO: Better name!!!! struct CDDataProcessor {
struct Configuration {
ProcessRoutine process_routine = nullptr; ProcessRoutine process_routine = nullptr;
const uint8_t* data_adr = nullptr; const uint8_t* data_adr = nullptr;
size_t data_bytes = 0ull; size_t data_bytes = 0ull;
template<typename T> template<typename T>
static __always_inline Configuration from(GenericProcessRoutine<T> process_routine, const uint8_t* data_adr) { static __always_inline CDDataProcessor from(GenericProcessRoutine<T> process_routine, const uint8_t* data_adr) {
return {reinterpret_cast<ProcessRoutine>(process_routine), data_adr}; return {reinterpret_cast<ProcessRoutine>(process_routine), data_adr};
} }
@ -33,7 +32,7 @@ namespace JabyEngine {
static constexpr size_t T_SIZE = sizeof(T); static constexpr size_t T_SIZE = sizeof(T);
T value = *reinterpret_cast<const T*>(this->data_adr); T value = *reinterpret_cast<const T*>(this->data_adr);
Configuration::processed(T_SIZE); CDDataProcessor::processed(T_SIZE);
return value; return value;
} }
@ -43,23 +42,23 @@ namespace JabyEngine {
} }
constexpr void skip(size_t bytes) { constexpr void skip(size_t bytes) {
Configuration::processed(bytes); CDDataProcessor::processed(bytes);
} }
}; };
Configuration config; CDDataProcessor data_proc;
Reserved reserved; Reserved reserved;
template<typename T> template<typename T>
static __always_inline State from(const T& state, const uint32_t* data_adr, GenericProcessRoutine<T> process_routine) { static __always_inline State from(const T& state, const uint32_t* data_adr, GenericProcessRoutine<T> process_routine) {
return {Configuration::from(process_routine, reinterpret_cast<const uint8_t*>(data_adr)), *reinterpret_cast<const Reserved*>(&state)}; return {CDDataProcessor::from(process_routine, reinterpret_cast<const uint8_t*>(data_adr)), *reinterpret_cast<const Reserved*>(&state)};
static_assert(sizeof(T) <= sizeof(Reserved)); static_assert(sizeof(T) <= sizeof(Reserved));
} }
public: public:
Progress process(size_t bytes_ready) { Progress process(size_t bytes_ready) {
this->config.data_bytes += bytes_ready; this->data_proc.data_bytes += bytes_ready;
return (*this->config.process_routine)(this->config, this->reserved); return (*this->data_proc.process_routine)(this->data_proc, this->reserved);
} }
}; };

10
include/PSX/File/file_processor_helper.hpp
View File

@ -7,9 +7,9 @@ namespace JabyEngine {
namespace FileProcessor { namespace FileProcessor {
namespace Helper { namespace Helper {
template<typename T> template<typename T>
static Progress exchange_and_execute_process_function(State::GenericProcessRoutine<T> process_routine, State::Configuration& config, T& state) { static Progress exchange_and_execute_process_function(State::GenericProcessRoutine<T> process_routine, State::CDDataProcessor& data_proc, T& state) {
config.process_routine = reinterpret_cast<State::ProcessRoutine>(process_routine); data_proc.process_routine = reinterpret_cast<State::ProcessRoutine>(process_routine);
return process_routine(config, state); return process_routine(data_proc, state);
} }
namespace DMA { namespace DMA {
@ -17,8 +17,8 @@ namespace JabyEngine {
uint32_t words_to_use; uint32_t words_to_use;
bool is_last; bool is_last;
static constexpr WordsReady calculate(const State::Configuration& config, size_t words_left) { static constexpr WordsReady calculate(const State::CDDataProcessor& data_proc, size_t words_left) {
const auto config_data_words = (config.data_bytes/sizeof(uint32_t)); const auto config_data_words = (data_proc.data_bytes/sizeof(uint32_t));
const auto words_to_use = (config_data_words > words_left) ? words_left : config_data_words; const auto words_to_use = (config_data_words > words_left) ? words_left : config_data_words;
return { return {

10
src/Library/src/File/Processor/TIM/simpletim_processor.cpp
View File

@ -47,9 +47,9 @@ namespace JabyEngine {
return state; return state;
} }
virtual Progress parse_header(State::Configuration& config) override { virtual Progress parse_header(State::CDDataProcessor& data_proc) override {
if(config.data_bytes >= sizeof(SimpleTIMSize)) { if(data_proc.data_bytes >= sizeof(SimpleTIMSize)) {
const auto size_info = config.simple_read_r<SimpleTIMSize>(); const auto size_info = data_proc.simple_read_r<SimpleTIMSize>();
this->clut_area.size = size_info.get_clut_size(); this->clut_area.size = size_info.get_clut_size();
this->tex_area.size = size_info.get_texture_size(); this->tex_area.size = size_info.get_texture_size();
@ -59,14 +59,14 @@ namespace JabyEngine {
return Progress::InProgress; return Progress::InProgress;
} }
virtual Progress pre_data_parsing(State::Configuration& config) { virtual Progress pre_data_parsing(State::CDDataProcessor& data_proc) {
return Progress::Done; return Progress::Done;
} }
}; };
} }
State create(const uint32_t* data_adr, const SimpleTIM& file) { State create(const uint32_t* data_adr, const SimpleTIM& file) {
using Callback = Progress(*)(State::Configuration& config, SimpleTIMState& simple_tim); using Callback = Progress(*)(State::CDDataProcessor& data_proc, SimpleTIMState& simple_tim);
return State::from(SimpleTIMState::create(file), data_adr, reinterpret_cast<Callback>(TIMFileProcessor::parse_header)); return State::from(SimpleTIMState::create(file), data_adr, reinterpret_cast<Callback>(TIMFileProcessor::parse_header));
} }
} }

30
src/Library/src/File/Processor/TIM/tim_helper.cpp
View File

@ -17,48 +17,48 @@ namespace JabyEngine {
return (width*height)/2; return (width*height)/2;
} }
Progress parse_data(State::Configuration& config, GenericTIM& generic_tim) { Progress parse_data(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) {
const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(config, generic_tim.words_left); const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(data_proc, generic_tim.words_left);
const auto words_used = Helper::DMA::send_words<GPU::internal::DMA>(words_to_use, is_last); const auto words_used = Helper::DMA::send_words<GPU::internal::DMA>(words_to_use, is_last);
generic_tim.words_left -= words_used; generic_tim.words_left -= words_used;
config.processed(words_used*sizeof(uint32_t)); data_proc.processed(words_used*sizeof(uint32_t));
return is_last ? Progress::Done : Progress::InProgress; return is_last ? Progress::Done : Progress::InProgress;
} }
Progress switch_state_parse_data(State::Configuration& config, GenericTIM& generic_tim) { Progress switch_state_parse_data(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) {
const auto result = generic_tim.pre_data_parsing(config); const auto result = generic_tim.pre_data_parsing(data_proc);
if(result == Progress::Done) { if(result == Progress::Done) {
generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast<const uint32_t*>(config.data_adr), generic_tim.tex_area); generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast<const uint32_t*>(data_proc.data_adr), generic_tim.tex_area);
return Helper::exchange_and_execute_process_function<TIMFileProcessor::GenericTIM>(TIMFileProcessor::parse_data, config, generic_tim); return Helper::exchange_and_execute_process_function<TIMFileProcessor::GenericTIM>(TIMFileProcessor::parse_data, data_proc, generic_tim);
} }
return result; return result;
} }
Progress parse_clut(State::Configuration& config, GenericTIM& generic_tim) { Progress parse_clut(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) {
if(const auto result = TIMFileProcessor::parse_data(config, generic_tim); result != Progress::Done) { if(const auto result = TIMFileProcessor::parse_data(data_proc, generic_tim); result != Progress::Done) {
return result; return result;
} }
else { else {
return switch_state_parse_data(config, generic_tim); return switch_state_parse_data(data_proc, generic_tim);
} }
} }
} }
Progress parse_header(State::Configuration& config, GenericTIM& generic_tim) { Progress parse_header(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) {
const auto result = generic_tim.parse_header(config); const auto result = generic_tim.parse_header(data_proc);
if(result == Progress::Done) { if(result == Progress::Done) {
//Check if we have a clut to care about //Check if we have a clut to care about
if(generic_tim.has_clut()) { if(generic_tim.has_clut()) {
//CLUTs are 16bit full color anyway //CLUTs are 16bit full color anyway
generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast<const uint32_t*>(config.data_adr), generic_tim.clut_area); generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast<const uint32_t*>(data_proc.data_adr), generic_tim.clut_area);
return Helper::exchange_and_execute_process_function(parse_clut, config, generic_tim); return Helper::exchange_and_execute_process_function(parse_clut, data_proc, generic_tim);
} }
else { else {
return switch_state_parse_data(config, generic_tim); return switch_state_parse_data(data_proc, generic_tim);
} }
} }
return result; return result;

6
src/Library/src/File/Processor/TIM/tim_helper.hpp
View File

@ -17,10 +17,10 @@ namespace JabyEngine {
return this->clut_area.size.width > 0; return this->clut_area.size.width > 0;
} }
virtual Progress parse_header(State::Configuration& config) = 0; virtual Progress parse_header(State::CDDataProcessor& data_proc) = 0;
virtual Progress pre_data_parsing(State::Configuration& config) = 0; virtual Progress pre_data_parsing(State::CDDataProcessor& data_proc) = 0;
}; };
Progress parse_header(State::Configuration& config, GenericTIM& generic_tim); Progress parse_header(State::CDDataProcessor& data_proc, GenericTIM& generic_tim);
} }
} }

18
src/Library/src/File/Processor/TIM/tim_processor.cpp
View File

@ -20,17 +20,17 @@ namespace JabyEngine {
return state; return state;
} }
virtual Progress parse_header(State::Configuration& config) override { virtual Progress parse_header(State::CDDataProcessor& data_proc) override {
static constexpr auto HEADER_SIZE = 2*sizeof(uint32_t); static constexpr auto HEADER_SIZE = 2*sizeof(uint32_t);
if(config.data_bytes >= (HEADER_SIZE + sizeof(BlockInfo))) { if(data_proc.data_bytes >= (HEADER_SIZE + sizeof(BlockInfo))) {
static constexpr auto HAS_CLUT_BIT = (0x1 << 3); static constexpr auto HAS_CLUT_BIT = (0x1 << 3);
config.processed(sizeof(uint32_t)); data_proc.processed(sizeof(uint32_t));
const auto flag = config.simple_read_r<uint32_t>(); const auto flag = data_proc.simple_read_r<uint32_t>();
if(flag & HAS_CLUT_BIT) { if(flag & HAS_CLUT_BIT) {
const auto block_info = config.simple_read_r<BlockInfo>(); const auto block_info = data_proc.simple_read_r<BlockInfo>();
this->clut_area = AreaU16::create(block_info.x, block_info.y, block_info.w, block_info.h); this->clut_area = AreaU16::create(block_info.x, block_info.y, block_info.w, block_info.h);
} }
@ -42,9 +42,9 @@ namespace JabyEngine {
return Progress::Error; return Progress::Error;
} }
virtual Progress pre_data_parsing(State::Configuration& config) { virtual Progress pre_data_parsing(State::CDDataProcessor& data_proc) {
if(config.data_bytes >= sizeof(BlockInfo)) { if(data_proc.data_bytes >= sizeof(BlockInfo)) {
const auto block_info = config.simple_read_r<BlockInfo>(); const auto block_info = data_proc.simple_read_r<BlockInfo>();
this->tex_area = AreaU16::create(block_info.x, block_info.y, block_info.w, block_info.h); this->tex_area = AreaU16::create(block_info.x, block_info.y, block_info.w, block_info.h);
return Progress::Done; return Progress::Done;
} }
@ -54,7 +54,7 @@ namespace JabyEngine {
} }
State create(const uint32_t* data_adr, const TIM& file) { State create(const uint32_t* data_adr, const TIM& file) {
using Callback = Progress(*)(State::Configuration& config, TIMState& simple_tim); using Callback = Progress(*)(State::CDDataProcessor& data_proc, TIMState& simple_tim);
return State::from(TIMState::create(), data_adr, reinterpret_cast<Callback>(TIMFileProcessor::parse_header)); return State::from(TIMState::create(), data_adr, reinterpret_cast<Callback>(TIMFileProcessor::parse_header));
} }
} }

2
src/Library/src/File/Processor/nothing_processor.cpp
View File

@ -5,7 +5,7 @@ namespace JabyEngine {
struct NothingState { struct NothingState {
}; };
static Progress parse_nothing(State::Configuration& config, NothingState& state) { static Progress parse_nothing(State::CDDataProcessor& data_proc, NothingState& state) {
return Progress::Done; return Progress::Done;
} }

18
src/Library/src/File/Processor/vag_processor.cpp
View File

@ -39,19 +39,19 @@ namespace JabyEngine {
} }
}; };
static Progress parse_sample(State::Configuration& config, VAGState& state) { static Progress parse_sample(State::CDDataProcessor& data_proc, VAGState& state) {
const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(config, state.words_left); const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(data_proc, state.words_left);
const auto words_used = Helper::DMA::send_words<SPU::internal::DMA>(words_to_use, is_last); const auto words_used = Helper::DMA::send_words<SPU::internal::DMA>(words_to_use, is_last);
state.words_left -= words_used; state.words_left -= words_used;
config.processed(words_used*sizeof(uint32_t)); data_proc.processed(words_used*sizeof(uint32_t));
return is_last ? Progress::Done : Progress::InProgress; return is_last ? Progress::Done : Progress::InProgress;
} }
static Progress parse_header(State::Configuration& config, VAGState& state) { static Progress parse_header(State::CDDataProcessor& data_proc, VAGState& state) {
if(config.data_bytes >= sizeof(VAGHeader)) { if(data_proc.data_bytes >= sizeof(VAGHeader)) {
const auto& header = *reinterpret_cast<const VAGHeader*>(config.data_adr); const auto& header = *reinterpret_cast<const VAGHeader*>(data_proc.data_adr);
const auto words = bytes_to_words(header.get_sample_size()); const auto words = bytes_to_words(header.get_sample_size());
const auto bytes = words_to_bytes(words); const auto bytes = words_to_bytes(words);
@ -61,12 +61,12 @@ namespace JabyEngine {
SPU::voice[state.voice_id].set_volume(state.inital_vol, state.inital_vol); SPU::voice[state.voice_id].set_volume(state.inital_vol, state.inital_vol);
config.processed(sizeof(VAGHeader)); data_proc.processed(sizeof(VAGHeader));
SPU::internal::DMA::Receive::prepare(); SPU::internal::DMA::Receive::prepare();
SPU::internal::DMA::Receive::set_dst(sram_adr); SPU::internal::DMA::Receive::set_dst(sram_adr);
SPU::internal::DMA::Receive::set_src(reinterpret_cast<uintptr_t>(config.data_adr)); SPU::internal::DMA::Receive::set_src(reinterpret_cast<uintptr_t>(data_proc.data_adr));
return Helper::exchange_and_execute_process_function(parse_sample, config, state); return Helper::exchange_and_execute_process_function(parse_sample, data_proc, state);
} }
return Progress::InProgress; return Progress::InProgress;