mirror of
https://github.com/MonsterDruide1/OdysseyDecomp
synced 2026-04-23 09:04:21 +00:00
1145 lines
38 KiB
C++
1145 lines
38 KiB
C++
#include "Library/Placement/PlacementFunction.h"
|
|
|
|
#include "Library/Area/AreaInitInfo.h"
|
|
#include "Library/Base/StringUtil.h"
|
|
#include "Library/LiveActor/ActorInitInfo.h"
|
|
#include "Library/Math/Axis.h"
|
|
#include "Library/Math/MathUtil.h"
|
|
#include "Library/Placement/PlacementId.h"
|
|
#include "Library/Placement/PlacementInfo.h"
|
|
#include "Library/Yaml/ByamlIter.h"
|
|
#include "Library/Yaml/ByamlUtil.h"
|
|
|
|
namespace al {
|
|
|
|
bool isValidInfo(const PlacementInfo& placementInfo) {
|
|
return placementInfo.getPlacementIter().isValid();
|
|
}
|
|
|
|
bool isPlaced(const ActorInitInfo& initInfo) {
|
|
return isValidInfo(*initInfo.placementInfo);
|
|
}
|
|
|
|
void getObjectName(const char** name, const ActorInitInfo& initInfo) {
|
|
getObjectName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getObjectName(const char** name, const PlacementInfo& placementInfo) {
|
|
tryGetObjectName(name, placementInfo);
|
|
}
|
|
|
|
bool tryGetObjectName(const char** name, const ActorInitInfo& initInfo) {
|
|
return tryGetObjectName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetObjectName(const char** name, const PlacementInfo& placementInfo) {
|
|
const char* obj = "";
|
|
if (tryGetStringArg(&obj, placementInfo, "UnitConfigName")) {
|
|
*name = obj;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool isObjectName(const ActorInitInfo& initInfo, const char* name) {
|
|
return isObjectName(*initInfo.placementInfo, name);
|
|
}
|
|
|
|
bool isObjectName(const PlacementInfo& placementInfo, const char* name) {
|
|
const char* obj;
|
|
return tryGetObjectName(&obj, placementInfo) && isEqualString(obj, name);
|
|
}
|
|
|
|
bool isObjectNameSubStr(const ActorInitInfo& initInfo, const char* name) {
|
|
return isObjectNameSubStr(*initInfo.placementInfo, name);
|
|
}
|
|
|
|
bool isObjectNameSubStr(const PlacementInfo& placementInfo, const char* name) {
|
|
const char* obj;
|
|
return tryGetObjectName(&obj, placementInfo) && isEqualSubString(obj, name);
|
|
}
|
|
|
|
void getClassName(const char** name, const ActorInitInfo& initInfo) {
|
|
getClassName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getClassName(const char** name, const PlacementInfo& placementInfo) {
|
|
tryGetClassName(name, placementInfo);
|
|
}
|
|
|
|
bool tryGetClassName(const char** name, const ActorInitInfo& initInfo) {
|
|
return tryGetClassName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetClassName(const char** name, const PlacementInfo& placementInfo) {
|
|
PlacementInfo unitConfig;
|
|
if (!tryGetPlacementInfoByKey(&unitConfig, placementInfo, "UnitConfig"))
|
|
return false;
|
|
return tryGetStringArg(name, unitConfig, "ParameterConfigName");
|
|
}
|
|
|
|
bool isClassName(const ActorInitInfo& initInfo, const char* name) {
|
|
return isClassName(*initInfo.placementInfo, name);
|
|
}
|
|
|
|
bool isClassName(const PlacementInfo& placementInfo, const char* name) {
|
|
const char* className = nullptr;
|
|
return tryGetClassName(&className, placementInfo) && isEqualString(className, name);
|
|
}
|
|
|
|
void getDisplayName(const char** name, const ActorInitInfo& initInfo) {
|
|
getDisplayName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getDisplayName(const char** name, const PlacementInfo& placementInfo) {
|
|
tryGetDisplayName(name, placementInfo);
|
|
}
|
|
|
|
bool tryGetDisplayName(const char** name, const ActorInitInfo& initInfo) {
|
|
return tryGetDisplayName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetDisplayName(const char** name, const PlacementInfo& placementInfo) {
|
|
PlacementInfo unitConfig;
|
|
if (!tryGetPlacementInfoByKey(&unitConfig, placementInfo, "UnitConfig"))
|
|
return false;
|
|
return tryGetStringArg(name, unitConfig, "DisplayName");
|
|
}
|
|
|
|
void getPlacementTargetFile(const char** targetFile, const PlacementInfo& placementInfo) {
|
|
PlacementInfo unitConfig;
|
|
getPlacementInfoByKey(&unitConfig, placementInfo, "UnitConfig");
|
|
tryGetStringArg(targetFile, unitConfig, "PlacementTargetFile");
|
|
}
|
|
|
|
void getTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo) {
|
|
getTrans(trans, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo) {
|
|
tryGetTrans(trans, placementInfo);
|
|
}
|
|
|
|
void multZoneMtx(sead::Vector3f* trans, const PlacementInfo& placementInfo) {
|
|
sead::Matrix34f mtx;
|
|
if (tryGetZoneMatrixTR(&mtx, placementInfo))
|
|
trans->mul(mtx);
|
|
}
|
|
|
|
bool tryGetTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo) {
|
|
return tryGetTrans(trans, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo) {
|
|
if (!tryGetArgV3f(trans, placementInfo, "Translate"))
|
|
return false;
|
|
multZoneMtx(trans, placementInfo);
|
|
return true;
|
|
}
|
|
|
|
void getRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo) {
|
|
tryGetRotate(rotate, placementInfo);
|
|
}
|
|
|
|
bool tryGetRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo) {
|
|
return tryGetRotate(rotate, *initInfo.placementInfo);
|
|
}
|
|
|
|
template <typename T>
|
|
inline void getRotation(sead::Vector3f* v, const sead::Matrix34f& n) {
|
|
T abs = sead::MathCalcCommon<T>::abs(n.m[2][0]);
|
|
|
|
// making sure pitch stays within bounds, setting roll to 0 otherwise
|
|
if ((1.0f - abs) < sead::MathCalcCommon<T>::epsilon() * 10) {
|
|
const T a12 = n.m[0][1];
|
|
const T a13 = n.m[0][2];
|
|
const T a31 = n.m[2][0];
|
|
|
|
v->x = 0.0f;
|
|
v->y = (a31 / abs) * (-sead::numbers::pi_v<T> / 2);
|
|
v->z = std::atan2(-a12, -(a31 * a13));
|
|
} else {
|
|
const T a11 = n.m[0][0];
|
|
const T a21 = n.m[1][0];
|
|
const T a31 = n.m[2][0];
|
|
const T a32 = n.m[2][1];
|
|
const T a33 = n.m[2][2];
|
|
|
|
v->x = std::atan2(a32, a33);
|
|
v->y = std::asin(-a31);
|
|
v->z = std::atan2(a21, a11);
|
|
}
|
|
}
|
|
|
|
bool tryGetRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo) {
|
|
if (!tryGetArgV3f(rotate, placementInfo, "Rotate"))
|
|
return false;
|
|
|
|
sead::Matrix34f mtx;
|
|
if (tryGetZoneMatrixTR(&mtx, placementInfo)) {
|
|
sead::Matrix34f rot, rot2;
|
|
sead::Vector3f vec1 = {sead::Mathf::deg2rad(rotate->x), sead::Mathf::deg2rad(rotate->y),
|
|
sead::Mathf::deg2rad(rotate->z)};
|
|
rot.makeRT(vec1, sead::Vector3f::zero);
|
|
rot2 = mtx * rot;
|
|
|
|
getRotation<f32>(rotate, rot2);
|
|
rotate->set(sead::Mathf::rad2deg(rotate->x), sead::Mathf::rad2deg(rotate->y),
|
|
sead::Mathf::rad2deg(rotate->z));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool tryGetZoneMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) {
|
|
ByamlIter zone = placementInfo.getZoneIter();
|
|
if (!zone.isValid())
|
|
return false;
|
|
|
|
sead::Vector3f translate = sead::Vector3f::zero;
|
|
if (!tryGetByamlV3f(&translate, zone, "Translate"))
|
|
return false;
|
|
|
|
sead::Vector3f rotate = sead::Vector3f::zero;
|
|
if (!tryGetByamlV3f(&rotate, zone, "Rotate"))
|
|
return false;
|
|
|
|
matrix->makeRT({sead::Mathf::deg2rad(rotate.x), sead::Mathf::deg2rad(rotate.y),
|
|
sead::Mathf::deg2rad(rotate.z)},
|
|
translate);
|
|
return true;
|
|
}
|
|
|
|
void getQuat(sead::Quatf* quat, const ActorInitInfo& initInfo) {
|
|
tryGetQuat(quat, initInfo);
|
|
}
|
|
|
|
void getQuat(sead::Quatf* quat, const PlacementInfo& placementInfo) {
|
|
tryGetQuat(quat, placementInfo);
|
|
}
|
|
|
|
bool tryGetQuat(sead::Quatf* quat, const ActorInitInfo& initInfo) {
|
|
return tryGetQuat(quat, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetQuat(sead::Quatf* quat, const PlacementInfo& placementInfo) {
|
|
sead::Vector3f rotate = sead::Vector3f::zero;
|
|
if (!tryGetRotate(&rotate, placementInfo)) {
|
|
*quat = sead::Quatf::unit;
|
|
return false;
|
|
}
|
|
quat->setRPY(sead::Mathf::deg2rad(rotate.x), sead::Mathf::deg2rad(rotate.y),
|
|
sead::Mathf::deg2rad(rotate.z));
|
|
return true;
|
|
}
|
|
|
|
void getScale(sead::Vector3f* scale, const PlacementInfo& placementInfo) {
|
|
tryGetScale(scale, placementInfo);
|
|
}
|
|
|
|
void getScale(f32* x, f32* y, f32* z, const PlacementInfo& placementInfo) {
|
|
sead::Vector3f scale = {0.0f, 0.0f, 0.0f};
|
|
tryGetScale(&scale, placementInfo);
|
|
|
|
if (x)
|
|
*x = scale.x;
|
|
if (y)
|
|
*y = scale.y;
|
|
if (z)
|
|
*z = scale.z;
|
|
}
|
|
|
|
bool tryGetScale(sead::Vector3f* scale, const ActorInitInfo& initInfo) {
|
|
return tryGetScale(scale, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetScale(sead::Vector3f* scale, const PlacementInfo& placementInfo) {
|
|
return tryGetArgV3f(scale, placementInfo, "Scale");
|
|
}
|
|
|
|
void getSide(sead::Vector3f* side, const ActorInitInfo& initInfo) {
|
|
tryGetSide(side, initInfo);
|
|
}
|
|
|
|
void getSide(sead::Vector3f* side, const PlacementInfo& placementInfo) {
|
|
tryGetSide(side, placementInfo);
|
|
}
|
|
|
|
bool tryGetSide(sead::Vector3f* side, const ActorInitInfo& initInfo) {
|
|
return tryGetSide(side, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetSide(sead::Vector3f* side, const PlacementInfo& placementInfo) {
|
|
sead::Quatf quat = sead::Quatf::unit;
|
|
if (!tryGetQuat(&quat, placementInfo))
|
|
return false;
|
|
calcQuatSide(side, quat);
|
|
return true;
|
|
}
|
|
|
|
void getUp(sead::Vector3f* up, const ActorInitInfo& initInfo) {
|
|
tryGetUp(up, initInfo);
|
|
}
|
|
|
|
void getUp(sead::Vector3f* up, const PlacementInfo& placementInfo) {
|
|
tryGetUp(up, placementInfo);
|
|
}
|
|
|
|
bool tryGetUp(sead::Vector3f* up, const ActorInitInfo& initInfo) {
|
|
return tryGetUp(up, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetUp(sead::Vector3f* up, const PlacementInfo& placementInfo) {
|
|
sead::Quatf quat = sead::Quatf::unit;
|
|
if (!tryGetQuat(&quat, placementInfo))
|
|
return false;
|
|
calcQuatUp(up, quat);
|
|
return true;
|
|
}
|
|
|
|
void getFront(sead::Vector3f* front, const ActorInitInfo& initInfo) {
|
|
tryGetFront(front, initInfo);
|
|
}
|
|
|
|
void getFront(sead::Vector3f* front, const PlacementInfo& placementInfo) {
|
|
tryGetFront(front, placementInfo);
|
|
}
|
|
|
|
bool tryGetFront(sead::Vector3f* front, const ActorInitInfo& initInfo) {
|
|
return tryGetFront(front, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetFront(sead::Vector3f* front, const PlacementInfo& placementInfo) {
|
|
sead::Quatf quat = sead::Quatf::unit;
|
|
if (!tryGetQuat(&quat, placementInfo))
|
|
return false;
|
|
calcQuatFront(front, quat);
|
|
return true;
|
|
}
|
|
|
|
bool tryGetLocalAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis) {
|
|
return tryGetLocalAxis(dir, *initInfo.placementInfo, axis);
|
|
}
|
|
|
|
bool tryGetLocalAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis) {
|
|
switch ((Axis)(axis + 1)) {
|
|
case Axis::X:
|
|
return tryGetSide(dir, placementInfo);
|
|
case Axis::Y:
|
|
return tryGetUp(dir, placementInfo);
|
|
case Axis::Z:
|
|
return tryGetFront(dir, placementInfo);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool tryGetLocalSignAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis) {
|
|
return tryGetLocalSignAxis(dir, *initInfo.placementInfo, axis);
|
|
}
|
|
|
|
bool tryGetLocalSignAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis) {
|
|
switch ((Axis)sead::Mathi::abs(axis)) {
|
|
case Axis::X:
|
|
tryGetSide(dir, placementInfo);
|
|
break;
|
|
case Axis::Y:
|
|
tryGetUp(dir, placementInfo);
|
|
break;
|
|
case Axis::Z:
|
|
tryGetFront(dir, placementInfo);
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (axis < 0)
|
|
*dir *= -1;
|
|
return true;
|
|
}
|
|
|
|
bool tryGetMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) {
|
|
return tryGetMatrixTR(matrix, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) {
|
|
sead::Vector3f trans = sead::Vector3f::zero;
|
|
sead::Vector3f rotate = sead::Vector3f::zero;
|
|
if (!tryGetTrans(&trans, placementInfo))
|
|
return false;
|
|
if (!tryGetRotate(&rotate, placementInfo))
|
|
return false;
|
|
matrix->makeRT({sead::Mathf::deg2rad(rotate.x), sead::Mathf::deg2rad(rotate.y),
|
|
sead::Mathf::deg2rad(rotate.z)},
|
|
trans);
|
|
return true;
|
|
}
|
|
|
|
bool tryGetMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) {
|
|
return tryGetMatrixTRS(matrix, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetMatrixTRS(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) {
|
|
sead::Vector3f trans = sead::Vector3f::zero;
|
|
sead::Vector3f rotate = sead::Vector3f::zero;
|
|
sead::Vector3f scale = sead::Vector3f::ones;
|
|
if (!tryGetTrans(&trans, placementInfo))
|
|
return false;
|
|
if (!tryGetRotate(&rotate, placementInfo))
|
|
return false;
|
|
if (!tryGetScale(&scale, placementInfo))
|
|
return false;
|
|
matrix->makeSRT(scale,
|
|
{sead::Mathf::deg2rad(rotate.x), sead::Mathf::deg2rad(rotate.y),
|
|
sead::Mathf::deg2rad(rotate.z)},
|
|
trans);
|
|
return true;
|
|
}
|
|
|
|
bool tryGetInvertMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) {
|
|
return tryGetInvertMatrixTR(matrix, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetInvertMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) {
|
|
sead::Matrix34f mtx;
|
|
if (!tryGetMatrixTR(&mtx, placementInfo))
|
|
return false;
|
|
matrix->setInverse(mtx);
|
|
return true;
|
|
}
|
|
|
|
void calcMatrixMultParent(sead::Matrix34f* matrix, const ActorInitInfo& initInfo1,
|
|
const ActorInitInfo& initInfo2) {
|
|
calcMatrixMultParent(matrix, *initInfo1.placementInfo, *initInfo2.placementInfo);
|
|
}
|
|
|
|
void calcMatrixMultParent(sead::Matrix34f* matrix, const PlacementInfo& placementInfo1,
|
|
const PlacementInfo& placementInfo2) {
|
|
sead::Matrix34f mtx1;
|
|
mtx1.makeIdentity();
|
|
tryGetMatrixTR(&mtx1, placementInfo1);
|
|
sead::Matrix34f mtx2;
|
|
mtx2.makeIdentity();
|
|
tryGetMatrixTR(&mtx2, placementInfo2);
|
|
matrix->setMul(mtx2, mtx1);
|
|
}
|
|
|
|
void getArg(s32* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
getArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
void getArg(s32* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
tryGetArg(arg, placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(s32* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(s32* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
return placementInfo.getPlacementIter().tryGetIntByKey(arg, key);
|
|
}
|
|
|
|
void getArg(f32* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
getArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
void getArg(f32* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
tryGetArg(arg, placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(f32* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(f32* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
return placementInfo.getPlacementIter().tryGetFloatByKey(arg, key);
|
|
}
|
|
|
|
void getArg(bool* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
getArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
void getArg(bool* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
tryGetArg(arg, placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(bool* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArg(bool* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
return placementInfo.getPlacementIter().tryGetBoolByKey(arg, key);
|
|
}
|
|
|
|
s32 getArgS32(const ActorInitInfo& actorInitInfo, const char* key) {
|
|
s32 arg = 0;
|
|
getArg(&arg, actorInitInfo, key);
|
|
return arg;
|
|
}
|
|
|
|
f32 getArgF32(const ActorInitInfo& actorInitInfo, const char* key) {
|
|
f32 arg = 0.0f;
|
|
getArg(&arg, actorInitInfo, key);
|
|
return arg;
|
|
}
|
|
|
|
void getArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key) {
|
|
tryGetArgV3f(arg, actorInitInfo, key);
|
|
}
|
|
|
|
void getArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
tryGetArgV3f(arg, placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key) {
|
|
return tryGetArgV3f(arg, *actorInitInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key) {
|
|
return tryGetByamlV3f(arg, placementInfo.getPlacementIter(), key);
|
|
}
|
|
|
|
bool isArgBool(const ActorInitInfo& initInfo, const char* key) {
|
|
bool arg = false;
|
|
getArg(&arg, initInfo, key);
|
|
return arg;
|
|
}
|
|
|
|
bool isArgBool(const PlacementInfo& placementInfo, const char* key) {
|
|
bool arg = false;
|
|
getArg(&arg, placementInfo, key);
|
|
return arg;
|
|
}
|
|
|
|
bool isArgString(const ActorInitInfo& initInfo, const char* key, const char* arg) {
|
|
return isArgString(*initInfo.placementInfo, key, arg);
|
|
}
|
|
|
|
bool isArgString(const PlacementInfo& placementInfo, const char* key, const char* arg) {
|
|
return isEqualString(getStringArg(placementInfo, key), arg);
|
|
}
|
|
|
|
void getStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key) {
|
|
getStringArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
void getStringArg(const char** arg, const PlacementInfo& placementInfo, const char* key) {
|
|
tryGetStringArg(arg, placementInfo, key);
|
|
}
|
|
|
|
void getStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key) {
|
|
getStringArg(arg, (const PlacementInfo&)initInfo, key);
|
|
}
|
|
|
|
const char* getStringArg(const ActorInitInfo& initInfo, const char* key) {
|
|
return getStringArg(*initInfo.placementInfo, key);
|
|
}
|
|
|
|
const char* getStringArg(const PlacementInfo& placementInfo, const char* key) {
|
|
const char* str = "";
|
|
if (!placementInfo.getPlacementIter().tryGetStringByKey(&str, key) || isEqualString("", str))
|
|
return nullptr;
|
|
return str;
|
|
}
|
|
|
|
const char* getStringArg(const AreaInitInfo& initInfo, const char* key) {
|
|
return getStringArg((const PlacementInfo&)initInfo, key);
|
|
}
|
|
|
|
bool tryGetStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetStringArg(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetStringArg(const char** arg, const PlacementInfo& initInfo, const char* key) {
|
|
const char* str = "";
|
|
if (!initInfo.getPlacementIter().tryGetStringByKey(&str, key) || isEqualString("", str))
|
|
return false;
|
|
*arg = str;
|
|
return true;
|
|
}
|
|
|
|
bool tryGetStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key) {
|
|
return tryGetStringArg(arg, (const PlacementInfo&)initInfo, key);
|
|
}
|
|
|
|
bool tryGetArgV2f(sead::Vector2f* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetArgV2f(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArgV2f(sead::Vector2f* arg, const PlacementInfo& initInfo, const char* key) {
|
|
return tryGetByamlV2f(arg, initInfo.getPlacementIter(), key);
|
|
}
|
|
|
|
bool tryGetArgColor(sead::Color4f* arg, const ActorInitInfo& initInfo, const char* key) {
|
|
return tryGetArgColor(arg, *initInfo.placementInfo, key);
|
|
}
|
|
|
|
bool tryGetArgColor(sead::Color4f* arg, const PlacementInfo& initInfo, const char* key) {
|
|
return tryGetByamlColor(arg, initInfo.getPlacementIter(), key);
|
|
}
|
|
|
|
void getLayerConfigName(const char** name, const ActorInitInfo& initInfo) {
|
|
getLayerConfigName(name, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getLayerConfigName(const char** name, const PlacementInfo& initInfo) {
|
|
return getStringArg(name, initInfo, "LayerConfigName");
|
|
}
|
|
|
|
bool tryGetZoneNameIfExist(const char** name, const PlacementInfo& placementInfo) {
|
|
PlacementId id;
|
|
getPlacementId(&id, placementInfo);
|
|
if (!id.getUnitConfigName())
|
|
return false;
|
|
*name = id.getUnitConfigName();
|
|
return true;
|
|
}
|
|
|
|
void getPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo) {
|
|
tryGetPlacementId(placementId, placementInfo);
|
|
}
|
|
|
|
bool tryGetBoolArgOrFalse(const ActorInitInfo& initInfo, const char* key) {
|
|
bool val = false;
|
|
if (!tryGetArg(&val, initInfo, key))
|
|
return false;
|
|
return val;
|
|
}
|
|
|
|
s32 getCountPlacementInfo(const PlacementInfo& placementInfo) {
|
|
return placementInfo.getPlacementIter().getSize();
|
|
}
|
|
|
|
void getPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* key) {
|
|
tryGetPlacementInfoByKey(outPlacementInfo, placementInfo, key);
|
|
}
|
|
|
|
bool tryGetPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* key) {
|
|
ByamlIter iter;
|
|
if (!placementInfo.getPlacementIter().tryGetIterByKey(&iter, key))
|
|
return false;
|
|
outPlacementInfo->set(iter, placementInfo.getZoneIter());
|
|
return true;
|
|
}
|
|
|
|
void getPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo,
|
|
s32 index) {
|
|
tryGetPlacementInfoByIndex(outPlacementInfo, placementInfo, index);
|
|
}
|
|
|
|
bool tryGetPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo,
|
|
s32 index) {
|
|
ByamlIter iter;
|
|
if (!placementInfo.getPlacementIter().tryGetIterByIndex(&iter, index))
|
|
return false;
|
|
outPlacementInfo->set(iter, placementInfo.getZoneIter());
|
|
return true;
|
|
}
|
|
|
|
void getPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey,
|
|
const PlacementInfo& placementInfo, s32 index) {
|
|
tryGetPlacementInfoAndKeyNameByIndex(outPlacementInfo, outKey, placementInfo, index);
|
|
}
|
|
|
|
bool tryGetPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey,
|
|
const PlacementInfo& placementInfo, s32 index) {
|
|
ByamlIter iter;
|
|
if (!placementInfo.getPlacementIter().tryGetIterAndKeyNameByIndex(&iter, outKey, index))
|
|
return false;
|
|
outPlacementInfo->set(iter, placementInfo.getZoneIter());
|
|
return true;
|
|
}
|
|
|
|
PlacementId* createPlacementId(const ActorInitInfo& initInfo) {
|
|
return createPlacementId(*initInfo.placementInfo);
|
|
}
|
|
|
|
PlacementId* createPlacementId(const PlacementInfo& placementInfo) {
|
|
PlacementId* id = new PlacementId();
|
|
id->init(placementInfo);
|
|
return id;
|
|
}
|
|
|
|
bool tryGetPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo) {
|
|
return tryGetPlacementId(placementId, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo) {
|
|
return placementId->init(placementInfo);
|
|
}
|
|
|
|
void getPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo) {
|
|
getPlacementId(placementId, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool isEqualPlacementId(const PlacementId& placementId, const PlacementId& otherPlacementId) {
|
|
return PlacementId::isEqual(placementId, otherPlacementId);
|
|
}
|
|
|
|
bool isEqualPlacementId(const PlacementInfo& placementInfo,
|
|
const PlacementInfo& otherPlacementInfo) {
|
|
PlacementId id1;
|
|
if (!tryGetPlacementId(&id1, placementInfo))
|
|
return false;
|
|
PlacementId id2;
|
|
if (!tryGetPlacementId(&id2, otherPlacementInfo))
|
|
return false;
|
|
return isEqualPlacementId(id1, id2);
|
|
}
|
|
|
|
bool isExistRail(const ActorInitInfo& initInfo, const char* linkName) {
|
|
PlacementInfo info;
|
|
return tryGetRailIter(&info, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
bool tryGetRailIter(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
if (!tryGetLinksInfo(railPlacementInfo, placementInfo, linkName))
|
|
return false;
|
|
return railPlacementInfo->getPlacementIter().isTypeContainer();
|
|
}
|
|
|
|
bool tryGetLinksInfo(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
PlacementInfo links;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return false;
|
|
PlacementInfo link;
|
|
if (!tryGetPlacementInfoByKey(&link, links, linkName))
|
|
return false;
|
|
if (!tryGetPlacementInfoByIndex(railPlacementInfo, link, 0))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool tryGetMoveParameterRailIter(PlacementInfo* railPlacementInfo,
|
|
const PlacementInfo& placementInfo) {
|
|
return tryGetRailIter(railPlacementInfo, placementInfo, "RailWithMoveParameter");
|
|
}
|
|
|
|
bool tryGetRailPointPos(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) {
|
|
return tryGetTrans(railPoint, placementInfo);
|
|
}
|
|
|
|
void getRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) {
|
|
tryGetRailPointHandlePrev(railPoint, placementInfo);
|
|
}
|
|
|
|
bool tryGetRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) {
|
|
PlacementInfo controlPoints;
|
|
if (!tryGetPlacementInfoByKey(&controlPoints, placementInfo, "ControlPoints"))
|
|
return false;
|
|
PlacementInfo controlPoint;
|
|
if (!tryGetPlacementInfoByIndex(&controlPoint, controlPoints, 0))
|
|
return false;
|
|
if (!tryGetByamlV3f(railPoint, controlPoint.getPlacementIter()))
|
|
return false;
|
|
multZoneMtx(railPoint, placementInfo);
|
|
return true;
|
|
}
|
|
|
|
void getRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) {
|
|
tryGetRailPointHandleNext(railPoint, placementInfo);
|
|
}
|
|
|
|
bool tryGetRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) {
|
|
PlacementInfo controlPoints;
|
|
if (!tryGetPlacementInfoByKey(&controlPoints, placementInfo, "ControlPoints"))
|
|
return false;
|
|
PlacementInfo controlPoint;
|
|
if (!tryGetPlacementInfoByIndex(&controlPoint, controlPoints, 1))
|
|
return false;
|
|
if (!tryGetByamlV3f(railPoint, controlPoint.getPlacementIter()))
|
|
return false;
|
|
multZoneMtx(railPoint, placementInfo);
|
|
return true;
|
|
}
|
|
|
|
bool isExistGraphRider(const ActorInitInfo& initInfo) {
|
|
PlacementInfo info;
|
|
return tryGetRailIter(&info, *initInfo.placementInfo, "Rail");
|
|
}
|
|
|
|
s32 calcLinkChildNum(const ActorInitInfo& initInfo, const char* linkName) {
|
|
return calcLinkChildNum(*initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
s32 calcLinkChildNum(const PlacementInfo& placementInfo, const char* linkName) {
|
|
PlacementInfo links;
|
|
PlacementInfo link;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return false;
|
|
if (!tryGetPlacementInfoByKey(&link, links, linkName))
|
|
return false;
|
|
return link.getPlacementIter().getSize();
|
|
}
|
|
|
|
bool isExistLinkChild(const ActorInitInfo& initInfo, const char* linkName, s32 index) {
|
|
return isExistLinkChild(*initInfo.placementInfo, linkName, index);
|
|
}
|
|
|
|
bool isExistLinkChild(const PlacementInfo& placementInfo, const char* linkName, s32 index) {
|
|
return calcLinkChildNum(placementInfo, linkName) > index;
|
|
}
|
|
|
|
bool isExistLinkChild(const AreaInitInfo& initInfo, const char* linkName, s32 index) {
|
|
return isExistLinkChild((const PlacementInfo&)initInfo, linkName, index);
|
|
}
|
|
|
|
s32 calcLinkNestNum(const ActorInitInfo& initInfo, const char* linkName) {
|
|
return calcLinkNestNum(*initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
s32 calcLinkNestNum(const PlacementInfo& placementInfo, const char* linkName) {
|
|
PlacementInfo links;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return 0;
|
|
PlacementInfo link = links;
|
|
s32 depth = 0;
|
|
while (tryGetPlacementInfoByKey(&link, links, linkName) &&
|
|
link.getPlacementIter().getSize() != 0) {
|
|
PlacementInfo item;
|
|
getPlacementInfoByIndex(&item, link, 0);
|
|
getPlacementInfoByKey(&links, item, "Links");
|
|
depth++;
|
|
}
|
|
return depth;
|
|
}
|
|
|
|
void getLinksInfo(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
getLinksInfoByIndex(linkPlacementInfo, placementInfo, linkName, 0);
|
|
}
|
|
|
|
void getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo,
|
|
const char* linkName, s32 index) {
|
|
PlacementInfo links;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return;
|
|
PlacementInfo link;
|
|
if (!tryGetPlacementInfoByKey(&link, links, linkName))
|
|
return;
|
|
getPlacementInfoByIndex(linkPlacementInfo, link, index);
|
|
}
|
|
|
|
void getLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
getLinksInfo(linkPlacementInfo, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
void getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo,
|
|
const char* linkName, s32 index) {
|
|
getLinksInfoByIndex(linkPlacementInfo, *initInfo.placementInfo, linkName, index);
|
|
}
|
|
|
|
bool tryGetLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
return tryGetLinksInfo(linkPlacementInfo, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
void getLinksMatrix(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName) {
|
|
getLinksMatrixByIndex(matrix, initInfo, linkName, 0);
|
|
}
|
|
|
|
void getLinksMatrixByIndex(sead::Matrix34f* matrix, const ActorInitInfo& initInfo,
|
|
const char* linkName, s32 index) {
|
|
PlacementInfo info;
|
|
getLinksInfoByIndex(&info, initInfo, linkName, index);
|
|
tryGetMatrixTR(matrix, info);
|
|
}
|
|
|
|
void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
getLinksInfo(&info, placementInfo, linkName);
|
|
getTrans(trans, info);
|
|
getRotate(rotate, info);
|
|
}
|
|
|
|
void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
getLinkTR(trans, rotate, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const AreaInitInfo& initInfo,
|
|
const char* linkName) {
|
|
getLinkTR(trans, rotate, (const PlacementInfo&)initInfo, linkName);
|
|
}
|
|
|
|
void getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
getLinksQT(quat, trans, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
void getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
getLinksInfo(&info, placementInfo, linkName);
|
|
if (quat)
|
|
getQuat(quat, info);
|
|
if (trans)
|
|
getTrans(trans, info);
|
|
}
|
|
|
|
bool tryGetLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, initInfo, linkName))
|
|
return false;
|
|
bool success = true;
|
|
if (quat)
|
|
success &= tryGetQuat(quat, info);
|
|
if (trans)
|
|
success &= tryGetTrans(trans, info);
|
|
return success;
|
|
}
|
|
|
|
bool tryGetLinksQTS(sead::Quatf* quat, sead::Vector3f* trans, sead::Vector3f* scale,
|
|
const ActorInitInfo& initInfo, const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, initInfo, linkName))
|
|
return false;
|
|
bool success = true;
|
|
if (quat)
|
|
success &= tryGetQuat(quat, info);
|
|
if (trans)
|
|
success &= tryGetTrans(trans, info);
|
|
if (scale)
|
|
success &= tryGetScale(scale, info);
|
|
return success;
|
|
}
|
|
|
|
bool tryGetLinksMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, *initInfo.placementInfo, linkName))
|
|
return false;
|
|
return tryGetMatrixTR(matrix, info);
|
|
}
|
|
|
|
bool tryGetLinksMatrixTR(sead::Matrix34f* matrix, const AreaInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, (const PlacementInfo&)initInfo, linkName))
|
|
return false;
|
|
return tryGetMatrixTR(matrix, info);
|
|
}
|
|
|
|
bool tryGetLinksMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, *initInfo.placementInfo, linkName))
|
|
return false;
|
|
return tryGetMatrixTRS(matrix, info);
|
|
}
|
|
|
|
bool tryGetLinksTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName) {
|
|
return tryGetLinksQT(nullptr, trans, initInfo, linkName);
|
|
}
|
|
|
|
bool tryGetLinksTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, placementInfo, linkName))
|
|
return false;
|
|
if (!trans)
|
|
return false;
|
|
return tryGetTrans(trans, info);
|
|
}
|
|
|
|
bool tryGetLinksQuat(sead::Quatf* quat, const ActorInitInfo& initInfo, const char* linkName) {
|
|
return tryGetLinksQT(quat, nullptr, initInfo, linkName);
|
|
}
|
|
|
|
bool tryGetLinksTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
if (!tryGetLinksInfo(&info, initInfo, linkName))
|
|
return false;
|
|
getTrans(trans, info);
|
|
getRotate(rotate, info);
|
|
return true;
|
|
}
|
|
|
|
void getChildTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
getLinksInfo(&info, placementInfo, linkName);
|
|
getTrans(trans, info);
|
|
}
|
|
|
|
void getChildTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName) {
|
|
getChildTrans(trans, *initInfo.placementInfo, linkName);
|
|
}
|
|
|
|
void getChildTrans(sead::Vector3f* trans, const AreaInitInfo& initInfo, const char* linkName) {
|
|
getChildTrans(trans, (const PlacementInfo&)initInfo, linkName);
|
|
}
|
|
|
|
void getChildLinkT(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName,
|
|
s32 index) {
|
|
PlacementInfo info;
|
|
getLinksInfoByIndex(&info, initInfo, linkName, index);
|
|
getTrans(trans, info);
|
|
}
|
|
|
|
void getChildLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo,
|
|
const char* linkName, s32 index) {
|
|
PlacementInfo info;
|
|
getLinksInfoByIndex(&info, initInfo, linkName, index);
|
|
getTrans(trans, info);
|
|
getRotate(rotate, info);
|
|
}
|
|
|
|
s32 calcMatchNameLinkCount(const PlacementInfo& placementInfo, const char* match) {
|
|
PlacementInfo links;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return 0;
|
|
s32 numItems = links.getPlacementIter().getSize();
|
|
s32 count = 0;
|
|
for (s32 i = 0; i < numItems; ++i) {
|
|
PlacementInfo item;
|
|
const char* key = nullptr;
|
|
getPlacementInfoAndKeyNameByIndex(&item, &key, links, i);
|
|
if (isMatchString(key, {match}))
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
s32 calcLinkCountClassName(const PlacementInfo& placementInfo, const char* className) {
|
|
PlacementInfo links;
|
|
if (!tryGetPlacementInfoByKey(&links, placementInfo, "Links"))
|
|
return false;
|
|
s32 numItems = links.getPlacementIter().getSize();
|
|
s32 count = 0;
|
|
for (s32 i = 0; i < numItems; ++i) {
|
|
PlacementInfo item;
|
|
getPlacementInfoByIndex(&item, links, i);
|
|
PlacementInfo first;
|
|
getPlacementInfoByIndex(&first, item, 0);
|
|
|
|
const char* classNameFirst = nullptr;
|
|
if (tryGetClassName(&classNameFirst, first) && isEqualString(classNameFirst, className))
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
bool tryGetZoneMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) {
|
|
return tryGetZoneMatrixTR(matrix, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo) {
|
|
return tryGetDisplayOffset(offset, *initInfo.placementInfo);
|
|
}
|
|
|
|
bool tryGetDisplayOffset(sead::Vector3f* offset, const PlacementInfo& placementInfo) {
|
|
PlacementInfo info;
|
|
if (!tryGetPlacementInfoByKey(&info, placementInfo, "UnitConfig"))
|
|
return false;
|
|
|
|
if (!tryGetArgV3f(offset, info, "DisplayTranslate"))
|
|
return false;
|
|
|
|
sead::Matrix34f tr = sead::Matrix34f::ident;
|
|
if (!tryGetMatrixTR(&tr, placementInfo))
|
|
return false;
|
|
offset->rotate(tr);
|
|
|
|
sead::Matrix34f mtx = sead::Matrix34f::ident;
|
|
if (tryGetZoneMatrixTR(&mtx, placementInfo))
|
|
offset->rotate(mtx);
|
|
return true;
|
|
}
|
|
|
|
bool tryGetChildDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
PlacementInfo info;
|
|
return tryGetLinksInfo(&info, initInfo, linkName) && tryGetDisplayOffset(offset, info);
|
|
}
|
|
|
|
bool tryGetDisplayRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo) {
|
|
PlacementInfo info;
|
|
getPlacementInfoByKey(&info, *initInfo.placementInfo, "UnitConfig");
|
|
return tryGetArgV3f(rotate, info, "DisplayRotate");
|
|
}
|
|
|
|
bool tryGetDisplayScale(sead::Vector3f* scale, const ActorInitInfo& initInfo) {
|
|
PlacementInfo info;
|
|
getPlacementInfoByKey(&info, *initInfo.placementInfo, "UnitConfig");
|
|
return tryGetArgV3f(scale, info, "DisplayScale");
|
|
}
|
|
|
|
} // namespace al
|
|
|
|
namespace alPlacementFunction {
|
|
|
|
s32 getCameraId(const al::ActorInitInfo& initInfo) {
|
|
s32 id = -1;
|
|
if (!al::tryGetArg(&id, initInfo, "CameraId"))
|
|
return -1;
|
|
return id;
|
|
}
|
|
|
|
bool getLinkGroupId(al::PlacementId* groupId, const al::ActorInitInfo& initInfo,
|
|
const char* linkName) {
|
|
al::PlacementInfo info;
|
|
if (al::tryGetLinksInfo(&info, initInfo, linkName) && al::tryGetPlacementId(groupId, info))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool isEnableLinkGroupId(const al::ActorInitInfo& initInfo, const char* linkName) {
|
|
al::PlacementId id;
|
|
return getLinkGroupId(&id, initInfo, linkName);
|
|
}
|
|
|
|
bool isEnableGroupClipping(const al::ActorInitInfo& initInfo) {
|
|
return isEnableLinkGroupId(initInfo, "GroupClipping");
|
|
}
|
|
|
|
bool getClippingGroupId(al::PlacementId* groupId, const al::ActorInitInfo& initInfo) {
|
|
return getLinkGroupId(groupId, initInfo, "GroupClipping");
|
|
}
|
|
|
|
al::PlacementId* createClippingViewId(const al::PlacementInfo& placementInfo) {
|
|
al::PlacementId* id = new al::PlacementId();
|
|
al::PlacementInfo info;
|
|
if (al::tryGetLinksInfo(&info, placementInfo, "ViewGroup"))
|
|
id->init(info);
|
|
return id;
|
|
}
|
|
|
|
bool getClippingViewId(al::PlacementId* viewId, const al::PlacementInfo& placementInfo) {
|
|
al::PlacementInfo info;
|
|
if (al::tryGetLinksInfo(&info, placementInfo, "ViewGroup") &&
|
|
al::tryGetPlacementId(viewId, info))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool getClippingViewId(al::PlacementId* viewId, const al::ActorInitInfo& initInfo) {
|
|
return getClippingViewId(viewId, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getModelName(const char** modelName, const al::ActorInitInfo& initInfo) {
|
|
getModelName(modelName, *initInfo.placementInfo);
|
|
}
|
|
|
|
void getModelName(const char** modelName, const al::PlacementInfo& placementInfo) {
|
|
tryGetModelName(modelName, placementInfo);
|
|
}
|
|
|
|
bool tryGetModelName(const char** modelName, const al::PlacementInfo& placementInfo) {
|
|
return tryGetStringArg(modelName, placementInfo, "ModelName") ||
|
|
tryGetStringArg(modelName, placementInfo, "ArchiveName");
|
|
}
|
|
|
|
bool tryGetModelName(const char** modelName, const al::ActorInitInfo& initInfo) {
|
|
return tryGetModelName(modelName, *initInfo.placementInfo);
|
|
}
|
|
|
|
} // namespace alPlacementFunction
|