falso
/
botw
mirror of https://github.com/zeldaret/botw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #145 from Pistonight/param_renaming 

Rename LoadRequest::_c to LoadRequest::mLaneId
This commit is contained in:
Léo Lam 2025-06-19 00:54:21 +01:00 committed by GitHub
parent 1f833303f9 4010977b94
commit f18a3f4f94
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
9 changed files with 100 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.clang-tidy
View File

@ -6,7 +6,6 @@ bugprone-*,
-bugprone-easily-swappable-parameters, -bugprone-easily-swappable-parameters,
clang-analyzer-*, clang-analyzer-*,
-clang-analyzer-apiModeling.Errno, -clang-analyzer-apiModeling.Errno,
cppcoreguidelines-pro-type-member-init,
cppcoreguidelines-slicing, cppcoreguidelines-slicing,
cppcoreguidelines-interfaces-global-init, cppcoreguidelines-interfaces-global-init,
cppcoreguidelines-narrowing-conversions, cppcoreguidelines-narrowing-conversions,

154
src/KingSystem/ActorSystem/actActorParamMgr.cpp
View File

@ -131,8 +131,7 @@ void ActorParamMgr::init(sead::Heap* heap, sead::Heap* debug_heap) {
req.mEntryFactory = dummy_gparam_factory; req.mEntryFactory = dummy_gparam_factory;
getDummyResHandle(ResType::GParamList) getDummyResHandle(ResType::GParamList)
.load("Actor/GeneralParamList/Dummy.bgparamlist", &req); .load("Actor/GeneralParamList/Dummy.bgparamlist", &req);
if (dummy_gparam_factory) delete dummy_gparam_factory;
delete dummy_gparam_factory;
auto* modellist = static_cast<res::ModelList*>( auto* modellist = static_cast<res::ModelList*>(
getDummyResHandle(ResType::ModelList).getResourceUnchecked()); getDummyResHandle(ResType::ModelList).getResourceUnchecked());
@ -191,12 +190,12 @@ ActorParam* ActorParamMgr::getParam(const char* actor_name, ActorParam** out_fre
} }
ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* pack_handle, void* x, ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* pack_handle, void* x,
u32 load_req_c) { u32 lane_id) {
bool allocated_new = false; bool allocated_new = false;
ActorParam* param = allocParam(actor_name, &allocated_new); ActorParam* param = allocParam(actor_name, &allocated_new);
if (allocated_new) { if (allocated_new) {
loadFiles(param, mTempHeap, pack_handle, x, load_req_c); loadFiles(param, mTempHeap, pack_handle, x, lane_id);
param->setEventSignal(); param->setEventSignal();
} else { } else {
param->waitForEvent(); param->waitForEvent();
@ -206,14 +205,14 @@ ActorParam* ActorParamMgr::loadParam(const char* actor_name, res::Handle* pack_h
} }
void ActorParamMgr::loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void ActorParamMgr::loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle,
void* x, u32 load_req_c) { void* x, u32 lane_id) {
param->deleteResHandles(); param->deleteResHandles();
param->allocResHandles(heap, 0, ActorParam::NumResourceTypes + 1); param->allocResHandles(heap, 0, ActorParam::NumResourceTypes + 1);
param->mActiveBufferIdx = 0; param->mActiveBufferIdx = 0;
const auto* link = const auto* link =
loadFile<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml", loadFile<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml",
param->getActorName().cstr(), pack_handle, x, load_req_c); param->getActorName().cstr(), pack_handle, x, lane_id);
if (link) if (link)
param->setProfileAndPriority(link->getUserName(User::Profile), link->getPriority().cstr()); param->setProfileAndPriority(link->getUserName(User::Profile), link->getPriority().cstr());
@ -225,20 +224,20 @@ void ActorParamMgr::loadFiles(ActorParam* param, sead::Heap* heap, res::Handle*
param->mActiveBufferIdx = 0; param->mActiveBufferIdx = 0;
loadFile<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist", loadFile<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist",
actor_link->getUserName(User::Model), pack_handle, x, load_req_c); actor_link->getUserName(User::Model), pack_handle, x, lane_id);
loadFile<res::UMii>(param, Type::UMii, "Actor/UMii", "umii", loadFile<res::UMii>(param, Type::UMii, "Actor/UMii", "umii",
actor_link->getUserName(User::UMii), pack_handle, x, load_req_c); actor_link->getUserName(User::UMii), pack_handle, x, lane_id);
loadFile<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist", loadFile<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist",
actor_link->getUserName(res::ActorLink::User::AS), pack_handle, x, actor_link->getUserName(res::ActorLink::User::AS), pack_handle, x,
load_req_c); lane_id);
loadFilesStep2(param, heap, pack_handle, x, load_req_c); loadFilesStep2(param, heap, pack_handle, x, lane_id);
} }
bool ActorParamMgr::requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name, bool ActorParamMgr::requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
u32 load_req_c) { u32 lane_id) {
sead::FixedSafeString<128> path; sead::FixedSafeString<128> path;
res::LoadRequest req; res::LoadRequest req;
@ -247,14 +246,14 @@ bool ActorParamMgr::requestLoadActorPack(res::Handle* handle, const sead::SafeSt
path.format("Actor/Pack/%s.bactorpack", actor_name.cstr()); path.format("Actor/Pack/%s.bactorpack", actor_name.cstr());
req.mRequester = actor_name; req.mRequester = actor_name;
req._c = load_req_c; req.mLaneId = lane_id;
req._8 = true; req._8 = true;
req._28 = false; req._28 = false;
return handle->requestLoad(path, &req); return handle->requestLoad(path, &req);
} }
ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* pack_handle, ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* pack_handle,
bool* allocated_new, void* x, u32 load_req_c) { bool* allocated_new, void* x, u32 lane_id) {
auto* param = allocParam(actor_name, allocated_new); auto* param = allocParam(actor_name, allocated_new);
if (!*allocated_new) if (!*allocated_new)
return param; return param;
@ -264,7 +263,7 @@ ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* p
param->mActiveBufferIdx = 0; param->mActiveBufferIdx = 0;
loadFileAsync<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml", loadFileAsync<res::ActorLink>(param, Type::ActorLink, "Actor/ActorLink", "xml",
param->getActorName().cstr(), pack_handle, x, load_req_c); param->getActorName().cstr(), pack_handle, x, lane_id);
return param; return param;
} }
@ -272,19 +271,19 @@ template <typename T>
bool ActorParamMgr::loadFileAsync(ActorParam* param, ActorParam::ResourceType type, bool ActorParamMgr::loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
const sead::SafeString& dir_name, const sead::SafeString& dir_name,
const sead::SafeString& extension, const sead::SafeString& name, const sead::SafeString& extension, const sead::SafeString& name,
res::Handle* pack_handle, void* x, u32 load_req_c) { res::Handle* pack_handle, void* x, u32 lane_id) {
auto* handle = param->allocHandle(); auto* handle = param->allocHandle();
if (name != "Dummy" && !name.isEmpty()) { if (name != "Dummy" && !name.isEmpty()) {
sead::FixedSafeString<128> path; sead::FixedSafeString<128> path;
res::LoadRequest req; res::LoadRequest req;
prepareLoadFromActorPack(&path, &req, x, dir_name, extension, name, pack_handle, load_req_c, prepareLoadFromActorPack(&path, &req, x, dir_name, extension, name, pack_handle, lane_id,
param->getActorName()); param->getActorName());
return handle->requestLoad(path, &req); return handle->requestLoad(path, &req);
} }
if (ActorParam::isValidType(type)) { if (ActorParam::isValidType(type)) {
auto* res = sead::DynamicCast<T>(mDummyResources[u32(type)].getResource()); auto* res = sead::DynamicCast<T>(mDummyResources[s32(type)].getResource());
param->setResource(type, res); param->setResource(type, res);
} }
@ -300,7 +299,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
*idx = current_idx + 1; *idx = current_idx + 1;
if (ActorParam::isValidType(type)) { if (ActorParam::isValidType(type)) {
if (auto* res = static_cast<T*>(param->getRes().mArray[u32(type)])) if (auto* res = static_cast<T*>(param->getRes().mArray[s32(type)]))
return res; return res;
} }
@ -313,7 +312,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
handle.parseResource(nullptr); handle.parseResource(nullptr);
if (handle.checkLoadStatus() && type != Type::EventFlow) if (handle.checkLoadStatus() && type != Type::EventFlow)
param->_a = 1; param->_a = true;
auto* res = sead::DynamicCast<T>(handle.getResource()); auto* res = sead::DynamicCast<T>(handle.getResource());
if (res) { if (res) {
@ -344,72 +343,71 @@ bool ActorParamMgr::finishLoadingActorLink(ActorParam* param, void* x) {
} }
void ActorParamMgr::loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x, void ActorParamMgr::loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x,
u32 load_req_c) { u32 lane_id) {
const auto* link = param->getRes().mActorLink; const auto* link = param->getRes().mActorLink;
loadFileAsync<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist", loadFileAsync<res::ModelList>(param, Type::ModelList, "Actor/ModelList", "modellist",
link->getUsers().getModel(), pack_handle, x, load_req_c); link->getUsers().getModel(), pack_handle, x, lane_id);
loadFileAsync<res::UMii>(param, Type::UMii, "Actor/UMii", "umii", link->getUsers().getUMii(), loadFileAsync<res::UMii>(param, Type::UMii, "Actor/UMii", "umii", link->getUsers().getUMii(),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
loadFileAsync<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist", loadFileAsync<res::ASList>(param, Type::ASList, "Actor/ASList", "aslist",
link->getUsers().getAS(), pack_handle, x, load_req_c); link->getUsers().getAS(), pack_handle, x, lane_id);
loadFileAsync<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist", loadFileAsync<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist",
link->getUserName(User::Attention), pack_handle, x, link->getUserName(User::Attention), pack_handle, x, lane_id);
load_req_c);
loadFileAsync<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList", loadFileAsync<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList",
"rgconfiglist", link->getUserName(User::RgConfigList), "rgconfiglist", link->getUserName(User::RgConfigList),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
loadFileAsync<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog", loadFileAsync<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog",
link->getUsers().getAIProgram(), pack_handle, x, load_req_c); link->getUsers().getAIProgram(), pack_handle, x, lane_id);
loadFileAsync<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist", loadFileAsync<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist",
link->getUsers().getGParam(), pack_handle, x, load_req_c); link->getUsers().getGParam(), pack_handle, x, lane_id);
loadFileAsync<res::Physics>(param, Type::Physics, "Actor/Physics", "physics", loadFileAsync<res::Physics>(param, Type::Physics, "Actor/Physics", "physics",
link->getUsers().getPhysics(), pack_handle, x, load_req_c); link->getUsers().getPhysics(), pack_handle, x, lane_id);
loadFileAsync<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical", loadFileAsync<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical",
link->getUsers().getChemical(), pack_handle, x, load_req_c); link->getUsers().getChemical(), pack_handle, x, lane_id);
loadFileAsync<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam", loadFileAsync<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam",
link->getUsers().getDamageParam(), pack_handle, x, load_req_c); link->getUsers().getDamageParam(), pack_handle, x, lane_id);
loadFileAsync<res::RagdollBlendWeight>( loadFileAsync<res::RagdollBlendWeight>(
param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight", "rgbw", param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight", "rgbw",
link->getUsers().getRgBlendWeight(), pack_handle, x, load_req_c); link->getUsers().getRgBlendWeight(), pack_handle, x, lane_id);
loadFileAsync<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness", loadFileAsync<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness",
link->getUsers().getAwareness(), pack_handle, x, load_req_c); link->getUsers().getAwareness(), pack_handle, x, lane_id);
loadFileAsync<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop", loadFileAsync<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop",
link->getUsers().getDropTable(), pack_handle, x, load_req_c); link->getUsers().getDropTable(), pack_handle, x, lane_id);
loadFileAsync<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop", loadFileAsync<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop",
link->getUsers().getShopData(), pack_handle, x, load_req_c); link->getUsers().getShopData(), pack_handle, x, lane_id);
loadFileAsync<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe", loadFileAsync<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe",
link->getUsers().getRecipe(), pack_handle, x, load_req_c); link->getUsers().getRecipe(), pack_handle, x, lane_id);
loadFileAsync<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(), loadFileAsync<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
loadFileAsync<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule", loadFileAsync<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule",
link->getUsers().getAISchedule(), pack_handle, x, load_req_c); link->getUsers().getAISchedule(), pack_handle, x, lane_id);
loadFileAsync<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl", loadFileAsync<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl",
link->getUsers().getBoneControl(), pack_handle, x, load_req_c); link->getUsers().getBoneControl(), pack_handle, x, lane_id);
loadFileAsync<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition", loadFileAsync<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition",
"lifecondition", link->getUsers().getLifeCondition(), "lifecondition", link->getUsers().getLifeCondition(),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
loadFileAsync<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo", loadFileAsync<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo",
link->getUsers().getAnimationInfo(), pack_handle, x, load_req_c); link->getUsers().getAnimationInfo(), pack_handle, x, lane_id);
} }
bool ActorParamMgr::finishLoadingStep2(ActorParam* param, void* x) { bool ActorParamMgr::finishLoadingStep2(ActorParam* param, void* x) {
@ -479,7 +477,7 @@ bool ActorParamMgr::finishLoadingStep2(ActorParam* param, void* x) {
} }
void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x, void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x,
u32 load_req_c) { u32 lane_id) {
const auto* aslist = param->getRes().mASList; const auto* aslist = param->getRes().mASList;
const auto* atcllist = param->getRes().mAttClientList; const auto* atcllist = param->getRes().mAttClientList;
const auto* rgconfiglist = param->getRes().mRagdollConfigList; const auto* rgconfiglist = param->getRes().mRagdollConfigList;
@ -495,7 +493,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
for (s32 i = 0; i < num_as; ++i) { for (s32 i = 0; i < num_as; ++i) {
loadFileAsync<res::AS>(param, Type::AS, "Actor/AS", "as", loadFileAsync<res::AS>(param, Type::AS, "Actor/AS", "as",
aslist->getASDefines()[i].getFileName(), pack_handle, x, aslist->getASDefines()[i].getFileName(), pack_handle, x,
load_req_c); lane_id);
} }
} }
@ -503,7 +501,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
for (s32 i = 0; i < num_att; ++i) { for (s32 i = 0; i < num_att; ++i) {
loadFileAsync<res::AttClient>(param, Type::AttClient, "Actor/AttClient", "atcl", loadFileAsync<res::AttClient>(param, Type::AttClient, "Actor/AttClient", "atcl",
atcllist->getClients()[i].getFileName(), pack_handle, x, atcllist->getClients()[i].getFileName(), pack_handle, x,
load_req_c); lane_id);
} }
} }
@ -511,7 +509,7 @@ void ActorParamMgr::loadExtraResAsync(ActorParam* param, res::Handle* pack_handl
for (s32 i = 0; i < num_rg; ++i) { for (s32 i = 0; i < num_rg; ++i) {
loadFileAsync<res::RagdollConfig>( loadFileAsync<res::RagdollConfig>(
param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig", param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig",
rgconfiglist->getImpulseParams()[i].getFileName(), pack_handle, x, load_req_c); rgconfiglist->getImpulseParams()[i].getFileName(), pack_handle, x, lane_id);
} }
} }
} }
@ -627,16 +625,16 @@ void ActorParamMgr::allocExtraResHandles(ActorParam* param, sead::Heap* heap) co
} }
void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle,
void* x, u32 load_req_c) { void* x, u32 lane_id) {
const auto* link = param->getRes().mActorLink; const auto* link = param->getRes().mActorLink;
param->mActiveBufferIdx = 0; param->mActiveBufferIdx = 0;
loadFile<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist", loadFile<res::AttClientList>(param, Type::AttClientList, "Actor/AttClientList", "atcllist",
link->getUserName(User::Attention), pack_handle, x, load_req_c); link->getUserName(User::Attention), pack_handle, x, lane_id);
loadFile<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList", loadFile<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList",
"rgconfiglist", link->getUserName(User::RgConfigList), "rgconfiglist", link->getUserName(User::RgConfigList),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
// Start loading the extra ActorParam files. // Start loading the extra ActorParam files.
allocExtraResHandles(param, heap); allocExtraResHandles(param, heap);
@ -644,9 +642,9 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
if (auto* aslist = param->getRes().mASList) { if (auto* aslist = param->getRes().mASList) {
for (s32 i = 0; i < aslist->getASDefines().size(); ++i) { for (s32 i = 0; i < aslist->getASDefines().size(); ++i) {
auto* as = loadFile<res::AS>(param, Type::AS, "Actor/AS", "as", auto* as =
aslist->getASDefines()[i].getFileName(), pack_handle, x, loadFile<res::AS>(param, Type::AS, "Actor/AS", "as",
load_req_c); aslist->getASDefines()[i].getFileName(), pack_handle, x, lane_id);
if (as) { if (as) {
as->setIndex(u32(Type::AS)); as->setIndex(u32(Type::AS));
aslist->addAS_(i, as); aslist->addAS_(i, as);
@ -658,7 +656,7 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
for (s32 i = 0; i < list->getClients().size(); ++i) { for (s32 i = 0; i < list->getClients().size(); ++i) {
auto* client = loadFile<res::AttClient>(param, Type::AttClient, "Actor/AttClient", auto* client = loadFile<res::AttClient>(param, Type::AttClient, "Actor/AttClient",
"atcl", list->getClients()[i].getFileName(), "atcl", list->getClients()[i].getFileName(),
pack_handle, x, load_req_c); pack_handle, x, lane_id);
if (client) { if (client) {
client->setIndex(u32(Type::AttClient)); client->setIndex(u32(Type::AttClient));
list->addClient_(i, client); list->addClient_(i, client);
@ -670,7 +668,7 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
for (s32 i = 0; i < list->getImpulseParams().size(); ++i) { for (s32 i = 0; i < list->getImpulseParams().size(); ++i) {
auto* config = loadFile<res::RagdollConfig>( auto* config = loadFile<res::RagdollConfig>(
param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig", param, Type::RagdollConfig, "Actor/RagdollConfig", "rgconfig",
list->getImpulseParams()[i].getFileName(), pack_handle, x, load_req_c); list->getImpulseParams()[i].getFileName(), pack_handle, x, lane_id);
if (config) { if (config) {
config->setIndex(u32(Type::RagdollConfig)); config->setIndex(u32(Type::RagdollConfig));
list->addImpulseParamConfig_(i, config); list->addImpulseParamConfig_(i, config);
@ -683,50 +681,50 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
param->mActiveBufferIdx = 0; param->mActiveBufferIdx = 0;
loadFile<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog", loadFile<res::AIProgram>(param, Type::AIProgram, "Actor/AIProgram", "aiprog",
link->getUsers().getAIProgram(), pack_handle, x, load_req_c); link->getUsers().getAIProgram(), pack_handle, x, lane_id);
loadFile<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist", loadFile<res::GParamList>(param, Type::GParamList, "Actor/GeneralParamList", "gparamlist",
link->getUsers().getGParam(), pack_handle, x, load_req_c); link->getUsers().getGParam(), pack_handle, x, lane_id);
loadFile<res::Physics>(param, Type::Physics, "Actor/Physics", "physics", loadFile<res::Physics>(param, Type::Physics, "Actor/Physics", "physics",
link->getUsers().getPhysics(), pack_handle, x, load_req_c); link->getUsers().getPhysics(), pack_handle, x, lane_id);
loadFile<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical", loadFile<res::Chemical>(param, Type::Chemical, "Actor/Chemical", "chemical",
link->getUsers().getChemical(), pack_handle, x, load_req_c); link->getUsers().getChemical(), pack_handle, x, lane_id);
loadFile<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam", loadFile<res::DamageParam>(param, Type::DamageParam, "Actor/DamageParam", "dmgparam",
link->getUsers().getDamageParam(), pack_handle, x, load_req_c); link->getUsers().getDamageParam(), pack_handle, x, lane_id);
loadFile<res::RagdollBlendWeight>(param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight", loadFile<res::RagdollBlendWeight>(param, Type::RagdollBlendWeight, "Actor/RagdollBlendWeight",
"rgbw", link->getUsers().getRgBlendWeight(), pack_handle, x, "rgbw", link->getUsers().getRgBlendWeight(), pack_handle, x,
load_req_c); lane_id);
loadFile<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness", loadFile<res::Awareness>(param, Type::Awareness, "Actor/Awareness", "awareness",
link->getUsers().getAwareness(), pack_handle, x, load_req_c); link->getUsers().getAwareness(), pack_handle, x, lane_id);
loadFile<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop", loadFile<res::Drop>(param, Type::DropTable, "Actor/DropTable", "drop",
link->getUsers().getDropTable(), pack_handle, x, load_req_c); link->getUsers().getDropTable(), pack_handle, x, lane_id);
loadFile<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop", loadFile<res::Shop>(param, Type::ShopData, "Actor/ShopData", "shop",
link->getUsers().getShopData(), pack_handle, x, load_req_c); link->getUsers().getShopData(), pack_handle, x, lane_id);
loadFile<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe", loadFile<res::Recipe>(param, Type::Recipe, "Actor/Recipe", "recipe",
link->getUsers().getRecipe(), pack_handle, x, load_req_c); link->getUsers().getRecipe(), pack_handle, x, lane_id);
loadFile<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(), pack_handle, loadFile<res::Lod>(param, Type::Lod, "Actor/LOD", "lod", link->getUsers().getLOD(), pack_handle,
x, load_req_c); x, lane_id);
loadFile<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule", loadFile<res::AISchedule>(param, Type::AISchedule, "Actor/AISchedule", "aischedule",
link->getUsers().getAISchedule(), pack_handle, x, load_req_c); link->getUsers().getAISchedule(), pack_handle, x, lane_id);
loadFile<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl", loadFile<res::BoneControl>(param, Type::BoneControl, "Actor/BoneControl", "bonectrl",
link->getUsers().getBoneControl(), pack_handle, x, load_req_c); link->getUsers().getBoneControl(), pack_handle, x, lane_id);
loadFile<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition", "lifecondition", loadFile<res::LifeCondition>(param, Type::LifeCondition, "Actor/LifeCondition", "lifecondition",
link->getUsers().getLifeCondition(), pack_handle, x, load_req_c); link->getUsers().getLifeCondition(), pack_handle, x, lane_id);
loadFile<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo", loadFile<res::AnimInfo>(param, Type::AnimationInfo, "Actor/AnimationInfo", "animinfo",
link->getUsers().getAnimationInfo(), pack_handle, x, load_req_c); link->getUsers().getAnimationInfo(), pack_handle, x, lane_id);
param->_9 = 0; param->_9 = 0;
param->onLoadFinished(this); param->onLoadFinished(this);
@ -741,7 +739,7 @@ bool ActorParamMgr::prepareLoadFromActorPack(sead::BufferedSafeString* path, res
void*, const sead::SafeString& dir_name, void*, const sead::SafeString& dir_name,
const sead::SafeString& extension, const sead::SafeString& extension,
const sead::SafeString& file_name, const sead::SafeString& file_name,
res::Handle* pack_handle, u32 load_req_c, res::Handle* pack_handle, u32 lane_id,
const sead::SafeString& requester) { const sead::SafeString& requester) {
path->format("%s/%s.b%s", dir_name.cstr(), file_name.cstr(), extension.cstr()); path->format("%s/%s.b%s", dir_name.cstr(), file_name.cstr(), extension.cstr());
@ -764,14 +762,14 @@ bool ActorParamMgr::prepareLoadFromActorPack(sead::BufferedSafeString* path, res
req->_24 = false; req->_24 = false;
} }
req->_c = load_req_c; req->mLaneId = lane_id;
req->mRequester = requester; req->mRequester = requester;
req->_8 = true; req->_8 = true;
return ret; return ret;
} }
res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::SafeString& actor_name, res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
u32 load_req_c) { u32 lane_id) {
sead::FixedSafeString<128> path; sead::FixedSafeString<128> path;
res::TempResourceLoader::LoadArg arg; res::TempResourceLoader::LoadArg arg;
arg.retry_on_failure = true; arg.retry_on_failure = true;
@ -782,7 +780,7 @@ res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::Safe
path.format("Actor/Pack/%s.bactorpack", actor_name.cstr()); path.format("Actor/Pack/%s.bactorpack", actor_name.cstr());
arg.load_req.mRequester = actor_name; arg.load_req.mRequester = actor_name;
arg.load_req._c = load_req_c; arg.load_req.mLaneId = lane_id;
arg.load_req._8 = true; arg.load_req._8 = true;
arg.load_req._28 = false; arg.load_req._28 = false;
arg.load_req.mPath = path; arg.load_req.mPath = path;
@ -797,14 +795,14 @@ res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::Safe
res::SimpleLoadRequest req; res::SimpleLoadRequest req;
req.mRequester = "tap::ActorParamMgr"; req.mRequester = "tap::ActorParamMgr";
req.mPath = path; req.mPath = path;
req._c = 2; req.mLaneId = 2;
return sead::DynamicCast<res::Archive>(handle->load(path, &req)); return sead::DynamicCast<res::Archive>(handle->load(path, &req));
} }
template <typename T> template <typename T>
T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c, T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c,
const char* extension_c, const char* name_c, res::Handle* pack_handle, const char* extension_c, const char* name_c, res::Handle* pack_handle,
void* x, u32 load_req_c) { void* x, u32 lane_id) {
const sead::SafeString name = name_c; const sead::SafeString name = name_c;
const sead::SafeString extension = extension_c; const sead::SafeString extension = extension_c;
sead::FixedSafeString<128> path; sead::FixedSafeString<128> path;
@ -821,18 +819,18 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
actor_name = &param->getActorName(); actor_name = &param->getActorName();
req.mRequester = *actor_name; req.mRequester = *actor_name;
req.mPath = path; req.mPath = path;
req._c = 2; req.mLaneId = 2;
res = sead::DynamicCast<T>(temp_handle->load(path, &req)); res = sead::DynamicCast<T>(temp_handle->load(path, &req));
} }
// If loading the resource from the RomFS has failed, try to load it from the actor pack. // If loading the resource from the RomFS has failed, try to load it from the actor pack.
if (!res) { if (!res) {
if (!pack_handle->isSuccess()) if (!pack_handle->isSuccess())
loadActorPack(pack_handle, *actor_name, load_req_c); loadActorPack(pack_handle, *actor_name, lane_id);
res::LoadRequest req; res::LoadRequest req;
prepareLoadFromActorPack(&path, &req, x, dir_name_c, extension_c, name_c, pack_handle, prepareLoadFromActorPack(&path, &req, x, dir_name_c, extension_c, name_c, pack_handle,
load_req_c, *actor_name); lane_id, *actor_name);
res = sead::DynamicCast<T>(temp_handle->load(path, &req)); res = sead::DynamicCast<T>(temp_handle->load(path, &req));
if (!res) { if (!res) {
@ -868,7 +866,7 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
} }
if (extension != "fevfl") if (extension != "fevfl")
param->_a = 1; param->_a = true;
// Fall back to using the dummy resource. // Fall back to using the dummy resource.
res = sead::DynamicCast<T>(mDummyResources[s32(type)].getResource()); res = sead::DynamicCast<T>(mDummyResources[s32(type)].getResource());

26
src/KingSystem/ActorSystem/actActorParamMgr.h
View File

@ -42,19 +42,17 @@ public:
ActorParam* allocParam(const char* actor_name, bool* allocated_new); ActorParam* allocParam(const char* actor_name, bool* allocated_new);
ActorParam* getParam(const char* actor_name, ActorParam** out_free_param) const; ActorParam* getParam(const char* actor_name, ActorParam** out_free_param) const;
ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x, ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x, u32 lane_id);
u32 load_req_c);
void unloadParam(ActorParam* param); void unloadParam(ActorParam* param);
bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name, bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name, u32 lane_id);
u32 load_req_c);
ActorParam* loadParamAsync(const char* actor_name, res::Handle* pack_handle, ActorParam* loadParamAsync(const char* actor_name, res::Handle* pack_handle,
bool* allocated_new, void* x, u32 load_req_c); bool* allocated_new, void* x, u32 lane_id);
bool finishLoadingActorLink(ActorParam* param, void* x); bool finishLoadingActorLink(ActorParam* param, void* x);
void loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x, u32 load_req_c); void loadParamAsyncStep2(ActorParam* param, res::Handle* pack_handle, void* x, u32 lane_id);
bool finishLoadingStep2(ActorParam* param, void* x); bool finishLoadingStep2(ActorParam* param, void* x);
void loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x, u32 load_req_c); void loadExtraResAsync(ActorParam* param, res::Handle* pack_handle, void* x, u32 lane_id);
bool finishLoadingExtraRes(ActorParam* param, void* x); bool finishLoadingExtraRes(ActorParam* param, void* x);
res::GParamList* getDummyGParamList() const; res::GParamList* getDummyGParamList() const;
@ -67,31 +65,31 @@ private:
}; };
void loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x, void loadFiles(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x,
u32 load_req_c); u32 lane_id);
bool prepareLoadFromActorPack(sead::BufferedSafeString* path, res::LoadRequest* req, void* x, bool prepareLoadFromActorPack(sead::BufferedSafeString* path, res::LoadRequest* req, void* x,
const sead::SafeString& dir_name, const sead::SafeString& dir_name,
const sead::SafeString& extension, const sead::SafeString& extension,
const sead::SafeString& file_name, res::Handle* pack_handle, const sead::SafeString& file_name, res::Handle* pack_handle,
u32 load_req_c, const sead::SafeString& requester); u32 lane_id, const sead::SafeString& requester);
res::Archive* loadActorPack(res::Handle* handle, const sead::SafeString& actor_name, res::Archive* loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
u32 load_req_c); u32 lane_id);
template <typename T> template <typename T>
T* loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c, T* loadFile(ActorParam* param, ActorParam::ResourceType type, const char* dir_name_c,
const char* extension_c, const char* name_c, res::Handle* pack_handle, void* x, const char* extension_c, const char* name_c, res::Handle* pack_handle, void* x,
u32 load_req_c); u32 lane_id);
template <typename T> template <typename T>
bool loadFileAsync(ActorParam* param, ActorParam::ResourceType type, bool loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
const sead::SafeString& dir_name, const sead::SafeString& extension, const sead::SafeString& dir_name, const sead::SafeString& extension,
const sead::SafeString& name, res::Handle* pack_handle, void* x, const sead::SafeString& name, res::Handle* pack_handle, void* x,
u32 load_req_c); u32 lane_id);
template <typename T> template <typename T>
T* handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::ResourceType type, void* x); T* handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::ResourceType type, void* x);
void loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x, void loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Handle* pack_handle, void* x,
u32 load_req_c); u32 lane_id);
void allocExtraResHandles(ActorParam* param, sead::Heap* heap) const; void allocExtraResHandles(ActorParam* param, sead::Heap* heap) const;
@ -101,7 +99,7 @@ private:
static constexpr s32 NumParams = 0x400; static constexpr s32 NumParams = 0x400;
sead::TypedBitFlag<Flag> mFlags{}; sead::TypedBitFlag<Flag> mFlags;
ActorParam* mParams = nullptr; ActorParam* mParams = nullptr;
DebugMessage mDebugMessage{"アクタパラメータ"}; DebugMessage mDebugMessage{"アクタパラメータ"};
void* _e0 = nullptr; void* _e0 = nullptr;

4
src/KingSystem/Resource/resCache.cpp
View File

@ -118,7 +118,7 @@ Handle::Status Cache::loadResource(const ControlTaskData& data) {
} }
u8 lane_id = 0xff; u8 lane_id = 0xff;
if (data.mResLoadReq._c <= 2) { if (data.mResLoadReq.mLaneId <= 2) {
const bool x = result->mStatusFlags.isOn(ResourceUnit::StatusFlag::LoadFromArchive); const bool x = result->mStatusFlags.isOn(ResourceUnit::StatusFlag::LoadFromArchive);
#ifdef MATCHING_HACK_NX_CLANG #ifdef MATCHING_HACK_NX_CLANG
// This makes absolutely no sense at all, but this prevents InstCombine from // This makes absolutely no sense at all, but this prevents InstCombine from
@ -127,7 +127,7 @@ Handle::Status Cache::loadResource(const ControlTaskData& data) {
// so the conditional still works fine. // so the conditional still works fine.
__builtin_assume(x); __builtin_assume(x);
#endif #endif
lane_id = 2 * data.mResLoadReq._c + (x ? 1 : 2); lane_id = 2 * data.mResLoadReq.mLaneId + (x ? 1 : 2);
} }
ResourceUnit::RequestInitLoadArg load_arg; ResourceUnit::RequestInitLoadArg load_arg;

4
src/KingSystem/Resource/resHandle.cpp
View File

@ -49,9 +49,9 @@ ILoadRequest::~ILoadRequest() {
LoadRequest::LoadRequest() = default; LoadRequest::LoadRequest() = default;
LoadRequest::LoadRequest(s32 load_data_alignment, u32 arg_c, bool arg_20) LoadRequest::LoadRequest(s32 load_data_alignment, u32 lane_id, bool arg_20)
: _20(arg_20), mLoadDataAlignment(load_data_alignment) { : _20(arg_20), mLoadDataAlignment(load_data_alignment) {
_c = arg_c; mLaneId = lane_id;
} }
SimpleLoadRequest::SimpleLoadRequest() = default; SimpleLoadRequest::SimpleLoadRequest() = default;

7
src/KingSystem/Resource/resInfoContainer.cpp
View File

@ -33,7 +33,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
req._34 = 0; req._34 = 0;
req.mRequester = "ResourceInfoContainer"; req.mRequester = "ResourceInfoContainer";
req.mPath = "System/Resource/ResourceSizeTable.product.rsizetable"; req.mPath = "System/Resource/ResourceSizeTable.product.rsizetable";
req._c = 1; req.mLaneId = 1;
return sead::DynamicCast<Resource>(mRstbHandle.load(req.mPath, &req)); return sead::DynamicCast<Resource>(mRstbHandle.load(req.mPath, &req));
}; };
@ -48,8 +48,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
const auto num_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x4); const auto num_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x4);
const auto num_string_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x8); const auto num_string_entries = sead::BitUtil::bitCastPtr<s32>(data, 0x8);
auto* entries_data = auto* entries_data = reinterpret_cast<const ResEntry*>(data + 0xc);
reinterpret_cast<const ResEntry*>(reinterpret_cast<const u8*>(data) + 0xc);
if (num_entries >= 1) { if (num_entries >= 1) {
mEntries = {num_entries, entries_data}; mEntries = {num_entries, entries_data};
@ -68,7 +67,7 @@ bool ResourceInfoContainer::loadResourceSizeTable() {
stubbedLogFunction(); stubbedLogFunction();
if (resource->getRawSize() != 0) { if (resource->getRawSize() != 0) {
const u32 num_entries = resource->getRawSize() / sizeof(ResEntry); const u32 num_entries = resource->getRawSize() / sizeof(ResEntry);
mEntries.setBuffer(num_entries, mEntries.setBuffer(s32(num_entries),
reinterpret_cast<const ResEntry*>(resource->getRawData())); reinterpret_cast<const ResEntry*>(resource->getRawData()));
} }
} }

4
src/KingSystem/Resource/resLoadRequest.h
View File

@ -29,7 +29,7 @@ public:
virtual ~ILoadRequest(); virtual ~ILoadRequest();
bool _8 = false; bool _8 = false;
u32 _c = 1; u32 mLaneId = 1;
sead::SafeString mRequester; sead::SafeString mRequester;
}; };
KSYS_CHECK_SIZE_NX150(ILoadRequest, 0x20); KSYS_CHECK_SIZE_NX150(ILoadRequest, 0x20);
@ -38,7 +38,7 @@ class LoadRequest : public ILoadRequest {
SEAD_RTTI_OVERRIDE(LoadRequest, ILoadRequest) SEAD_RTTI_OVERRIDE(LoadRequest, ILoadRequest)
public: public:
LoadRequest(); LoadRequest();
LoadRequest(s32 load_data_alignment, u32 arg_c, bool arg_20); LoadRequest(s32 load_data_alignment, u32 lane_id, bool arg_20);
LoadRequest(const LoadRequest&) = default; LoadRequest(const LoadRequest&) = default;
LoadRequest& operator=(const LoadRequest&) = default; LoadRequest& operator=(const LoadRequest&) = default;
~LoadRequest() override = default; ~LoadRequest() override = default;

2
src/KingSystem/Resource/resUnit.cpp
View File

@ -48,7 +48,7 @@ bool ResourceUnit::init(const ResourceUnit::InitArg& arg) {
SimplePackedLoadRequest request; SimplePackedLoadRequest request;
request._8 = true; request._8 = true;
request.mRequester = "ResourceUnit"; request.mRequester = "ResourceUnit";
request._c = 2; request.mLaneId = 2;
request.mPack = arg.load_req->mPackHandle; request.mPack = arg.load_req->mPackHandle;
mArchiveRes = sead::DynamicCast<sead::ArchiveRes>(mArchiveResHandle.load("", &request)); mArchiveRes = sead::DynamicCast<sead::ArchiveRes>(mArchiveResHandle.load("", &request));
} }

4
src/KingSystem/System/UI/LayoutResourceMgr.cpp
View File

@ -179,7 +179,7 @@ void LayoutResourceMgr::loadTitleLayout(sead::Heap* heap) {
req.mLoadDataAlignment = 0x1000; req.mLoadDataAlignment = 0x1000;
req._22 = false; req._22 = false;
req._26 = false; req._26 = false;
req._c = 2; req.mLaneId = 2;
res::Handle::Status status = res::Handle::Status::NoFile; res::Handle::Status status = res::Handle::Status::NoFile;
mTitleLayout.getHandle()->requestLoad("Layout/Title.blarc", &req, &status); mTitleLayout.getHandle()->requestLoad("Layout/Title.blarc", &req, &status);
@ -207,7 +207,7 @@ bool LayoutResourceMgr::loadHorseLayout(sead::Heap* heap) {
req.mLoadDataAlignment = 0x1000; req.mLoadDataAlignment = 0x1000;
req._22 = false; req._22 = false;
req._26 = true; req._26 = true;
req._c = 2; req.mLaneId = 2;
res::Handle::Status status = res::Handle::Status::NoFile; res::Handle::Status status = res::Handle::Status::NoFile;
mHorseLayout.getHandle()->requestLoad("Layout/Horse.blarc", &req, &status); mHorseLayout.getHandle()->requestLoad("Layout/Horse.blarc", &req, &status);