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,
clang-analyzer-*,
-clang-analyzer-apiModeling.Errno,
cppcoreguidelines-pro-type-member-init,
cppcoreguidelines-slicing,
cppcoreguidelines-interfaces-global-init,
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;
getDummyResHandle(ResType::GParamList)
.load("Actor/GeneralParamList/Dummy.bgparamlist", &req);
if (dummy_gparam_factory)
delete dummy_gparam_factory;
delete dummy_gparam_factory;
auto* modellist = static_cast<res::ModelList*>(
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,
u32 load_req_c) {
u32 lane_id) {
bool allocated_new = false;
ActorParam* param = allocParam(actor_name, &allocated_new);
if (allocated_new) {
loadFiles(param, mTempHeap, pack_handle, x, load_req_c);
loadFiles(param, mTempHeap, pack_handle, x, lane_id);
param->setEventSignal();
} else {
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* x, u32 load_req_c) {
void* x, u32 lane_id) {
param->deleteResHandles();
param->allocResHandles(heap, 0, ActorParam::NumResourceTypes + 1);
param->mActiveBufferIdx = 0;
const auto* link =
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)
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;
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",
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",
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,
u32 load_req_c) {
u32 lane_id) {
sead::FixedSafeString<128> path;
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());
req.mRequester = actor_name;
req._c = load_req_c;
req.mLaneId = lane_id;
req._8 = true;
req._28 = false;
return handle->requestLoad(path, &req);
}
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);
if (!*allocated_new)
return param;
@ -264,7 +263,7 @@ ActorParam* ActorParamMgr::loadParamAsync(const char* actor_name, res::Handle* p
param->mActiveBufferIdx = 0;
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;
}
@ -272,19 +271,19 @@ template <typename T>
bool ActorParamMgr::loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
const sead::SafeString& dir_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();
if (name != "Dummy" && !name.isEmpty()) {
sead::FixedSafeString<128> path;
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());
return handle->requestLoad(path, &req);
}
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);
}
@ -300,7 +299,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
*idx = current_idx + 1;
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;
}
@ -313,7 +312,7 @@ T* ActorParamMgr::handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::R
handle.parseResource(nullptr);
if (handle.checkLoadStatus() && type != Type::EventFlow)
param->_a = 1;
param->_a = true;
auto* res = sead::DynamicCast<T>(handle.getResource());
if (res) {
@ -344,72 +343,71 @@ bool ActorParamMgr::finishLoadingActorLink(ActorParam* param, 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;
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(),
pack_handle, x, load_req_c);
pack_handle, x, lane_id);
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",
link->getUserName(User::Attention), pack_handle, x,
load_req_c);
link->getUserName(User::Attention), pack_handle, x, lane_id);
loadFileAsync<res::RagdollConfigList>(param, Type::RagdollConfigList, "Actor/RagdollConfigList",
"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",
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",
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",
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",
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",
link->getUsers().getDamageParam(), pack_handle, x, load_req_c);
link->getUsers().getDamageParam(), pack_handle, x, lane_id);
loadFileAsync<res::RagdollBlendWeight>(
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",
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",
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",
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",
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(),
pack_handle, x, load_req_c);
pack_handle, x, lane_id);
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",
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",
"lifecondition", link->getUsers().getLifeCondition(),
pack_handle, x, load_req_c);
pack_handle, x, lane_id);
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) {
@ -479,7 +477,7 @@ bool ActorParamMgr::finishLoadingStep2(ActorParam* param, 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* atcllist = param->getRes().mAttClientList;
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) {
loadFileAsync<res::AS>(param, Type::AS, "Actor/AS", "as",
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) {
loadFileAsync<res::AttClient>(param, Type::AttClient, "Actor/AttClient", "atcl",
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) {
loadFileAsync<res::RagdollConfig>(
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* x, u32 load_req_c) {
void* x, u32 lane_id) {
const auto* link = param->getRes().mActorLink;
param->mActiveBufferIdx = 0;
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",
"rgconfiglist", link->getUserName(User::RgConfigList),
pack_handle, x, load_req_c);
pack_handle, x, lane_id);
// Start loading the extra ActorParam files.
allocExtraResHandles(param, heap);
@ -644,9 +642,9 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
if (auto* aslist = param->getRes().mASList) {
for (s32 i = 0; i < aslist->getASDefines().size(); ++i) {
auto* as = loadFile<res::AS>(param, Type::AS, "Actor/AS", "as",
aslist->getASDefines()[i].getFileName(), pack_handle, x,
load_req_c);
auto* as =
loadFile<res::AS>(param, Type::AS, "Actor/AS", "as",
aslist->getASDefines()[i].getFileName(), pack_handle, x, lane_id);
if (as) {
as->setIndex(u32(Type::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) {
auto* client = loadFile<res::AttClient>(param, Type::AttClient, "Actor/AttClient",
"atcl", list->getClients()[i].getFileName(),
pack_handle, x, load_req_c);
pack_handle, x, lane_id);
if (client) {
client->setIndex(u32(Type::AttClient));
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) {
auto* config = loadFile<res::RagdollConfig>(
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) {
config->setIndex(u32(Type::RagdollConfig));
list->addImpulseParamConfig_(i, config);
@ -683,50 +681,50 @@ void ActorParamMgr::loadFilesStep2(ActorParam* param, sead::Heap* heap, res::Han
param->mActiveBufferIdx = 0;
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",
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",
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",
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",
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",
"rgbw", link->getUsers().getRgBlendWeight(), pack_handle, x,
load_req_c);
lane_id);
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",
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",
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",
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,
x, load_req_c);
x, lane_id);
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",
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",
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",
link->getUsers().getAnimationInfo(), pack_handle, x, load_req_c);
link->getUsers().getAnimationInfo(), pack_handle, x, lane_id);
param->_9 = 0;
param->onLoadFinished(this);
@ -741,7 +739,7 @@ bool ActorParamMgr::prepareLoadFromActorPack(sead::BufferedSafeString* path, res
void*, const sead::SafeString& dir_name,
const sead::SafeString& extension,
const sead::SafeString& file_name,
res::Handle* pack_handle, u32 load_req_c,
res::Handle* pack_handle, u32 lane_id,
const sead::SafeString& requester) {
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->_c = load_req_c;
req->mLaneId = lane_id;
req->mRequester = requester;
req->_8 = true;
return ret;
}
res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
u32 load_req_c) {
u32 lane_id) {
sead::FixedSafeString<128> path;
res::TempResourceLoader::LoadArg arg;
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());
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._28 = false;
arg.load_req.mPath = path;
@ -797,14 +795,14 @@ res::Archive* ActorParamMgr::loadActorPack(res::Handle* handle, const sead::Safe
res::SimpleLoadRequest req;
req.mRequester = "tap::ActorParamMgr";
req.mPath = path;
req._c = 2;
req.mLaneId = 2;
return sead::DynamicCast<res::Archive>(handle->load(path, &req));
}
template <typename T>
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,
void* x, u32 load_req_c) {
void* x, u32 lane_id) {
const sead::SafeString name = name_c;
const sead::SafeString extension = extension_c;
sead::FixedSafeString<128> path;
@ -821,18 +819,18 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
actor_name = &param->getActorName();
req.mRequester = *actor_name;
req.mPath = path;
req._c = 2;
req.mLaneId = 2;
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 (!res) {
if (!pack_handle->isSuccess())
loadActorPack(pack_handle, *actor_name, load_req_c);
loadActorPack(pack_handle, *actor_name, lane_id);
res::LoadRequest req;
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));
if (!res) {
@ -868,7 +866,7 @@ T* ActorParamMgr::loadFile(ActorParam* param, ActorParam::ResourceType type, con
}
if (extension != "fevfl")
param->_a = 1;
param->_a = true;
// Fall back to using the dummy resource.
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* getParam(const char* actor_name, ActorParam** out_free_param) const;
ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x,
u32 load_req_c);
ActorParam* loadParam(const char* actor_name, res::Handle* pack_handle, void* x, u32 lane_id);
void unloadParam(ActorParam* param);
bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name,
u32 load_req_c);
bool requestLoadActorPack(res::Handle* handle, const sead::SafeString& actor_name, u32 lane_id);
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);
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);
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);
res::GParamList* getDummyGParamList() const;
@ -67,31 +65,31 @@ private:
};
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,
const sead::SafeString& dir_name,
const sead::SafeString& extension,
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,
u32 load_req_c);
u32 lane_id);
template <typename T>
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,
u32 load_req_c);
u32 lane_id);
template <typename T>
bool loadFileAsync(ActorParam* param, ActorParam::ResourceType type,
const sead::SafeString& dir_name, const sead::SafeString& extension,
const sead::SafeString& name, res::Handle* pack_handle, void* x,
u32 load_req_c);
u32 lane_id);
template <typename T>
T* handleAsyncFileLoad(ActorParam* param, s32* idx, ActorParam::ResourceType type, 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;
@ -101,7 +99,7 @@ private:
static constexpr s32 NumParams = 0x400;
sead::TypedBitFlag<Flag> mFlags{};
sead::TypedBitFlag<Flag> mFlags;
ActorParam* mParams = nullptr;
DebugMessage mDebugMessage{"アクタパラメータ"};
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;
if (data.mResLoadReq._c <= 2) {
if (data.mResLoadReq.mLaneId <= 2) {
const bool x = result->mStatusFlags.isOn(ResourceUnit::StatusFlag::LoadFromArchive);
#ifdef MATCHING_HACK_NX_CLANG
// 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.
__builtin_assume(x);
#endif
lane_id = 2 * data.mResLoadReq._c + (x ? 1 : 2);
lane_id = 2 * data.mResLoadReq.mLaneId + (x ? 1 : 2);
}
ResourceUnit::RequestInitLoadArg load_arg;

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

@ -49,9 +49,9 @@ ILoadRequest::~ILoadRequest() {
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) {
_c = arg_c;
mLaneId = lane_id;
}
SimpleLoadRequest::SimpleLoadRequest() = default;

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

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

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

@ -29,7 +29,7 @@ public:
virtual ~ILoadRequest();
bool _8 = false;
u32 _c = 1;
u32 mLaneId = 1;
sead::SafeString mRequester;
};
KSYS_CHECK_SIZE_NX150(ILoadRequest, 0x20);
@ -38,7 +38,7 @@ class LoadRequest : public ILoadRequest {
SEAD_RTTI_OVERRIDE(LoadRequest, ILoadRequest)
public:
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& operator=(const LoadRequest&) = 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;
request._8 = true;
request.mRequester = "ResourceUnit";
request._c = 2;
request.mLaneId = 2;
request.mPack = arg.load_req->mPackHandle;
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._22 = false;
req._26 = false;
req._c = 2;
req.mLaneId = 2;
res::Handle::Status status = res::Handle::Status::NoFile;
mTitleLayout.getHandle()->requestLoad("Layout/Title.blarc", &req, &status);
@ -207,7 +207,7 @@ bool LayoutResourceMgr::loadHorseLayout(sead::Heap* heap) {
req.mLoadDataAlignment = 0x1000;
req._22 = false;
req._26 = true;
req._c = 2;
req.mLaneId = 2;
res::Handle::Status status = res::Handle::Status::NoFile;
mHorseLayout.getHandle()->requestLoad("Layout/Horse.blarc", &req, &status);