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;
};
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;
}

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

@ -10,21 +10,20 @@ namespace JabyEngine {
uint32_t reserved[8];
};
struct Configuration;
struct CDDataProcessor;
template<typename T>
using GenericProcessRoutine = Progress (*)(Configuration&, T&);
using GenericProcessRoutine = Progress (*)(CDDataProcessor&, T&);
typedef GenericProcessRoutine<Reserved> ProcessRoutine;
// TODO: Better name!!!!
struct Configuration {
struct CDDataProcessor {
ProcessRoutine process_routine = nullptr;
const uint8_t* data_adr = nullptr;
size_t data_bytes = 0ull;
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};
}
@ -33,7 +32,7 @@ namespace JabyEngine {
static constexpr size_t T_SIZE = sizeof(T);
T value = *reinterpret_cast<const T*>(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;
CDDataProcessor data_proc;
Reserved reserved;
template<typename T>
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));
}
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);
}
};

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

@ -7,9 +7,9 @@ namespace JabyEngine {
namespace FileProcessor {
namespace Helper {
template<typename T>
static Progress exchange_and_execute_process_function(State::GenericProcessRoutine<T> process_routine, State::Configuration& config, T& state) {
config.process_routine = reinterpret_cast<State::ProcessRoutine>(process_routine);
return process_routine(config, state);
static Progress exchange_and_execute_process_function(State::GenericProcessRoutine<T> process_routine, State::CDDataProcessor& data_proc, T& state) {
data_proc.process_routine = reinterpret_cast<State::ProcessRoutine>(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 {

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

@ -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<SimpleTIMSize>();
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<SimpleTIMSize>();
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<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;
}
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<GPU::internal::DMA>(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<const uint32_t*>(config.data_adr), generic_tim.tex_area);
return Helper::exchange_and_execute_process_function<TIMFileProcessor::GenericTIM>(TIMFileProcessor::parse_data, config, generic_tim);
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, 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<const uint32_t*>(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<const uint32_t*>(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;

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;
}
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);
}
}

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

@ -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<uint32_t>();
data_proc.processed(sizeof(uint32_t));
const auto flag = data_proc.simple_read_r<uint32_t>();
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);
}
@ -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<BlockInfo>();
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<BlockInfo>();
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<Callback>(TIMFileProcessor::parse_header));
}
}

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

@ -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;
}

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) {
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<SPU::internal::DMA>(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<const VAGHeader*>(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<const VAGHeader*>(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<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;