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

More clean-up

Browse Source
This commit is contained in:
jaby
2024-12-29 23:40:42 +01:00
parent c115fed0bd
commit 3fd15f91e2
9 changed files with 59 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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;