diff --git a/examples/PoolBox/application/src/Custom/file_parser.cpp b/examples/PoolBox/application/src/Custom/file_parser.cpp index c22cd4df..ac63977b 100644 --- a/examples/PoolBox/application/src/Custom/file_parser.cpp +++ b/examples/PoolBox/application/src/Custom/file_parser.cpp @@ -8,7 +8,7 @@ namespace JabyEngine { 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(); return Progress::Done; } diff --git a/include/PSX/File/Processor/file_processor.hpp b/include/PSX/File/Processor/file_processor.hpp index d0fbd89a..a31abdeb 100644 --- a/include/PSX/File/Processor/file_processor.hpp +++ b/include/PSX/File/Processor/file_processor.hpp @@ -10,21 +10,20 @@ namespace JabyEngine { uint32_t reserved[8]; }; - struct Configuration; + struct CDDataProcessor; template - using GenericProcessRoutine = Progress (*)(Configuration&, T&); + using GenericProcessRoutine = Progress (*)(CDDataProcessor&, T&); typedef GenericProcessRoutine ProcessRoutine; - // TODO: Better name!!!! - struct Configuration { + struct CDDataProcessor { ProcessRoutine process_routine = nullptr; const uint8_t* data_adr = nullptr; size_t data_bytes = 0ull; template - static __always_inline Configuration from(GenericProcessRoutine process_routine, const uint8_t* data_adr) { + static __always_inline CDDataProcessor from(GenericProcessRoutine process_routine, const uint8_t* data_adr) { return {reinterpret_cast(process_routine), data_adr}; } @@ -33,7 +32,7 @@ namespace JabyEngine { static constexpr size_t T_SIZE = sizeof(T); T value = *reinterpret_cast(this->data_adr); - Configuration::processed(T_SIZE); + CDDataProcessor::processed(T_SIZE); return value; } @@ -43,23 +42,23 @@ namespace JabyEngine { } constexpr void skip(size_t bytes) { - Configuration::processed(bytes); + CDDataProcessor::processed(bytes); } }; - Configuration config; - Reserved reserved; + CDDataProcessor data_proc; + Reserved reserved; template static __always_inline State from(const T& state, const uint32_t* data_adr, GenericProcessRoutine process_routine) { - return {Configuration::from(process_routine, reinterpret_cast(data_adr)), *reinterpret_cast(&state)}; + return {CDDataProcessor::from(process_routine, reinterpret_cast(data_adr)), *reinterpret_cast(&state)}; static_assert(sizeof(T) <= sizeof(Reserved)); } public: Progress process(size_t bytes_ready) { - this->config.data_bytes += bytes_ready; - return (*this->config.process_routine)(this->config, this->reserved); + this->data_proc.data_bytes += bytes_ready; + return (*this->data_proc.process_routine)(this->data_proc, this->reserved); } }; diff --git a/include/PSX/File/file_processor_helper.hpp b/include/PSX/File/file_processor_helper.hpp index c3b8e7da..04b1552a 100644 --- a/include/PSX/File/file_processor_helper.hpp +++ b/include/PSX/File/file_processor_helper.hpp @@ -7,9 +7,9 @@ namespace JabyEngine { namespace FileProcessor { namespace Helper { template - static Progress exchange_and_execute_process_function(State::GenericProcessRoutine process_routine, State::Configuration& config, T& state) { - config.process_routine = reinterpret_cast(process_routine); - return process_routine(config, state); + static Progress exchange_and_execute_process_function(State::GenericProcessRoutine process_routine, State::CDDataProcessor& data_proc, T& state) { + data_proc.process_routine = reinterpret_cast(process_routine); + return process_routine(data_proc, state); } namespace DMA { @@ -17,8 +17,8 @@ namespace JabyEngine { uint32_t words_to_use; bool is_last; - static constexpr WordsReady calculate(const State::Configuration& config, size_t words_left) { - const auto config_data_words = (config.data_bytes/sizeof(uint32_t)); + static constexpr WordsReady calculate(const State::CDDataProcessor& data_proc, size_t words_left) { + 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; return { diff --git a/src/Library/src/File/Processor/TIM/simpletim_processor.cpp b/src/Library/src/File/Processor/TIM/simpletim_processor.cpp index 034fbf80..7d6b2751 100644 --- a/src/Library/src/File/Processor/TIM/simpletim_processor.cpp +++ b/src/Library/src/File/Processor/TIM/simpletim_processor.cpp @@ -47,9 +47,9 @@ namespace JabyEngine { return state; } - virtual Progress parse_header(State::Configuration& config) override { - if(config.data_bytes >= sizeof(SimpleTIMSize)) { - const auto size_info = config.simple_read_r(); + virtual Progress parse_header(State::CDDataProcessor& data_proc) override { + if(data_proc.data_bytes >= sizeof(SimpleTIMSize)) { + const auto size_info = data_proc.simple_read_r(); this->clut_area.size = size_info.get_clut_size(); this->tex_area.size = size_info.get_texture_size(); @@ -59,14 +59,14 @@ namespace JabyEngine { return Progress::InProgress; } - virtual Progress pre_data_parsing(State::Configuration& config) { + virtual Progress pre_data_parsing(State::CDDataProcessor& data_proc) { return Progress::Done; } }; } 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(TIMFileProcessor::parse_header)); } } diff --git a/src/Library/src/File/Processor/TIM/tim_helper.cpp b/src/Library/src/File/Processor/TIM/tim_helper.cpp index 9c2be1a9..6a86ed29 100644 --- a/src/Library/src/File/Processor/TIM/tim_helper.cpp +++ b/src/Library/src/File/Processor/TIM/tim_helper.cpp @@ -17,48 +17,48 @@ namespace JabyEngine { return (width*height)/2; } - Progress parse_data(State::Configuration& config, GenericTIM& generic_tim) { - const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(config, generic_tim.words_left); + Progress parse_data(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) { + 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(words_to_use, is_last); 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; } - Progress switch_state_parse_data(State::Configuration& config, GenericTIM& generic_tim) { - const auto result = generic_tim.pre_data_parsing(config); + Progress switch_state_parse_data(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) { + const auto result = generic_tim.pre_data_parsing(data_proc); if(result == Progress::Done) { - generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast(config.data_adr), generic_tim.tex_area); - return Helper::exchange_and_execute_process_function(TIMFileProcessor::parse_data, config, generic_tim); + generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast(data_proc.data_adr), generic_tim.tex_area); + return Helper::exchange_and_execute_process_function(TIMFileProcessor::parse_data, data_proc, generic_tim); } return result; } - Progress parse_clut(State::Configuration& config, GenericTIM& generic_tim) { - if(const auto result = TIMFileProcessor::parse_data(config, generic_tim); result != Progress::Done) { + Progress parse_clut(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) { + if(const auto result = TIMFileProcessor::parse_data(data_proc, generic_tim); result != Progress::Done) { return result; } 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) { - const auto result = generic_tim.parse_header(config); + Progress parse_header(State::CDDataProcessor& data_proc, GenericTIM& generic_tim) { + const auto result = generic_tim.parse_header(data_proc); if(result == Progress::Done) { //Check if we have a clut to care about if(generic_tim.has_clut()) { //CLUTs are 16bit full color anyway - generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast(config.data_adr), generic_tim.clut_area); - return Helper::exchange_and_execute_process_function(parse_clut, config, generic_tim); + generic_tim.words_left = TIMFileProcessor::set_gpu_receive_data(reinterpret_cast(data_proc.data_adr), generic_tim.clut_area); + return Helper::exchange_and_execute_process_function(parse_clut, data_proc, generic_tim); } else { - return switch_state_parse_data(config, generic_tim); + return switch_state_parse_data(data_proc, generic_tim); } } return result; diff --git a/src/Library/src/File/Processor/TIM/tim_helper.hpp b/src/Library/src/File/Processor/TIM/tim_helper.hpp index 047a6ee1..dc012e92 100644 --- a/src/Library/src/File/Processor/TIM/tim_helper.hpp +++ b/src/Library/src/File/Processor/TIM/tim_helper.hpp @@ -17,10 +17,10 @@ namespace JabyEngine { return this->clut_area.size.width > 0; } - virtual Progress parse_header(State::Configuration& config) = 0; - virtual Progress pre_data_parsing(State::Configuration& config) = 0; + virtual Progress parse_header(State::CDDataProcessor& data_proc) = 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); } } \ No newline at end of file diff --git a/src/Library/src/File/Processor/TIM/tim_processor.cpp b/src/Library/src/File/Processor/TIM/tim_processor.cpp index 362988fd..57d11ca8 100644 --- a/src/Library/src/File/Processor/TIM/tim_processor.cpp +++ b/src/Library/src/File/Processor/TIM/tim_processor.cpp @@ -20,17 +20,17 @@ namespace JabyEngine { 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); - 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); - config.processed(sizeof(uint32_t)); - const auto flag = config.simple_read_r(); + data_proc.processed(sizeof(uint32_t)); + const auto flag = data_proc.simple_read_r(); if(flag & HAS_CLUT_BIT) { - const auto block_info = config.simple_read_r(); + const auto block_info = data_proc.simple_read_r(); 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; } - virtual Progress pre_data_parsing(State::Configuration& config) { - if(config.data_bytes >= sizeof(BlockInfo)) { - const auto block_info = config.simple_read_r(); + virtual Progress pre_data_parsing(State::CDDataProcessor& data_proc) { + if(data_proc.data_bytes >= sizeof(BlockInfo)) { + const auto block_info = data_proc.simple_read_r(); this->tex_area = AreaU16::create(block_info.x, block_info.y, block_info.w, block_info.h); return Progress::Done; } @@ -54,7 +54,7 @@ namespace JabyEngine { } 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(TIMFileProcessor::parse_header)); } } diff --git a/src/Library/src/File/Processor/nothing_processor.cpp b/src/Library/src/File/Processor/nothing_processor.cpp index 8d628e8f..b2ee5e6a 100644 --- a/src/Library/src/File/Processor/nothing_processor.cpp +++ b/src/Library/src/File/Processor/nothing_processor.cpp @@ -5,7 +5,7 @@ namespace JabyEngine { struct NothingState { }; - static Progress parse_nothing(State::Configuration& config, NothingState& state) { + static Progress parse_nothing(State::CDDataProcessor& data_proc, NothingState& state) { return Progress::Done; } diff --git a/src/Library/src/File/Processor/vag_processor.cpp b/src/Library/src/File/Processor/vag_processor.cpp index 1375b4f4..66098ed7 100644 --- a/src/Library/src/File/Processor/vag_processor.cpp +++ b/src/Library/src/File/Processor/vag_processor.cpp @@ -39,19 +39,19 @@ namespace JabyEngine { } }; - static Progress parse_sample(State::Configuration& config, VAGState& state) { - const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(config, state.words_left); + static Progress parse_sample(State::CDDataProcessor& data_proc, VAGState& state) { + const auto [words_to_use, is_last] = Helper::DMA::WordsReady::calculate(data_proc, state.words_left); const auto words_used = Helper::DMA::send_words(words_to_use, is_last); 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; } - static Progress parse_header(State::Configuration& config, VAGState& state) { - if(config.data_bytes >= sizeof(VAGHeader)) { - const auto& header = *reinterpret_cast(config.data_adr); + static Progress parse_header(State::CDDataProcessor& data_proc, VAGState& state) { + if(data_proc.data_bytes >= sizeof(VAGHeader)) { + const auto& header = *reinterpret_cast(data_proc.data_adr); const auto words = bytes_to_words(header.get_sample_size()); 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); - config.processed(sizeof(VAGHeader)); + data_proc.processed(sizeof(VAGHeader)); SPU::internal::DMA::Receive::prepare(); SPU::internal::DMA::Receive::set_dst(sram_adr); - SPU::internal::DMA::Receive::set_src(reinterpret_cast(config.data_adr)); + SPU::internal::DMA::Receive::set_src(reinterpret_cast(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;