Runtime: Make use of std::make_unique where applicable

Makes use of the C++14 make_unique allocation function to allocate class
instances where applicable instead of a reset with a new operator within
it.

This doesn't touch cases where buffers are allocated, given make_unique
would zero-initialize them.
This commit is contained in:
Lioncash 2019-09-11 23:50:38 -04:00
parent d6166ad666
commit f9079f0215
42 changed files with 227 additions and 205 deletions

View File

@ -7,17 +7,19 @@ static logvisor::Module Log("CResLoader");
CResLoader::CResLoader() { x48_curPak = x18_pakLoadedList.end(); } CResLoader::CResLoader() { x48_curPak = x18_pakLoadedList.end(); }
const std::vector<CAssetId>* CResLoader::GetTagListForFile(std::string_view name) const { const std::vector<CAssetId>* CResLoader::GetTagListForFile(std::string_view name) const {
std::string namePak = std::string(name) + ".upak"; const std::string namePak = std::string(name).append(".upak");
for (const std::unique_ptr<CPakFile>& pak : x18_pakLoadedList) for (const std::unique_ptr<CPakFile>& pak : x18_pakLoadedList) {
if (!CStringExtras::CompareCaseInsensitive(namePak, pak->x18_path)) if (!CStringExtras::CompareCaseInsensitive(namePak, pak->x18_path)) {
return &pak->GetDepList(); return &pak->GetDepList();
}
}
return nullptr; return nullptr;
} }
void CResLoader::AddPakFileAsync(std::string_view name, bool buildDepList, bool worldPak) { void CResLoader::AddPakFileAsync(std::string_view name, bool buildDepList, bool worldPak) {
std::string namePak = std::string(name) + ".upak"; const std::string namePak = std::string(name).append(".upak");
if (CDvdFile::FileExists(namePak.c_str())) { if (CDvdFile::FileExists(namePak)) {
x30_pakLoadingList.emplace_back(new CPakFile(namePak, buildDepList, worldPak)); x30_pakLoadingList.emplace_back(std::make_unique<CPakFile>(namePak, buildDepList, worldPak));
++x44_pakLoadingCount; ++x44_pakLoadingCount;
} }
} }
@ -35,11 +37,13 @@ void CResLoader::WaitForPakFileLoadingComplete() {
std::unique_ptr<CInputStream> CResLoader::LoadNewResourcePartSync(const SObjectTag& tag, u32 length, u32 offset, std::unique_ptr<CInputStream> CResLoader::LoadNewResourcePartSync(const SObjectTag& tag, u32 length, u32 offset,
void* extBuf) { void* extBuf) {
void* buf = extBuf; void* buf = extBuf;
CPakFile* file = FindResourceForLoad(tag); if (buf == nullptr) {
if (!buf)
buf = new u8[length]; buf = new u8[length];
}
CPakFile* const file = FindResourceForLoad(tag);
file->SyncSeekRead(buf, length, ESeekOrigin::Begin, x50_cachedResInfo->GetOffset() + offset); file->SyncSeekRead(buf, length, ESeekOrigin::Begin, x50_cachedResInfo->GetOffset() + offset);
return std::unique_ptr<CInputStream>(new athena::io::MemoryReader((atUint8*)buf, length, !extBuf)); return std::make_unique<athena::io::MemoryReader>(buf, length, !extBuf);
} }
void CResLoader::LoadMemResourceSync(const SObjectTag& tag, std::unique_ptr<u8[]>& bufOut, int* sizeOut) { void CResLoader::LoadMemResourceSync(const SObjectTag& tag, std::unique_ptr<u8[]>& bufOut, int* sizeOut) {
@ -52,29 +56,36 @@ void CResLoader::LoadMemResourceSync(const SObjectTag& tag, std::unique_ptr<u8[]
std::unique_ptr<CInputStream> CResLoader::LoadResourceFromMemorySync(const SObjectTag& tag, const void* buf) { std::unique_ptr<CInputStream> CResLoader::LoadResourceFromMemorySync(const SObjectTag& tag, const void* buf) {
FindResourceForLoad(tag); FindResourceForLoad(tag);
CInputStream* newStrm = new athena::io::MemoryReader((atUint8*)buf, x50_cachedResInfo->GetSize()); std::unique_ptr<CInputStream> newStrm = std::make_unique<athena::io::MemoryReader>(buf, x50_cachedResInfo->GetSize());
if (x50_cachedResInfo->IsCompressed()) { if (x50_cachedResInfo->IsCompressed()) {
newStrm->readUint32Big(); newStrm->readUint32Big();
newStrm = new CZipInputStream(std::unique_ptr<CInputStream>(newStrm)); newStrm = std::make_unique<CZipInputStream>(std::move(newStrm));
} }
return std::unique_ptr<CInputStream>(newStrm); return newStrm;
} }
std::unique_ptr<CInputStream> CResLoader::LoadNewResourceSync(const SObjectTag& tag, void* extBuf) { std::unique_ptr<CInputStream> CResLoader::LoadNewResourceSync(const SObjectTag& tag, void* extBuf) {
void* buf = extBuf; if (CPakFile* const file = FindResourceForLoad(tag)) {
if (CPakFile* file = FindResourceForLoad(tag)) { const size_t resSz = ROUND_UP_32(x50_cachedResInfo->GetSize());
size_t resSz = ROUND_UP_32(x50_cachedResInfo->GetSize());
if (!buf) void* buf = extBuf;
if (buf == nullptr) {
buf = new u8[resSz]; buf = new u8[resSz];
}
file->SyncSeekRead(buf, resSz, ESeekOrigin::Begin, x50_cachedResInfo->GetOffset()); file->SyncSeekRead(buf, resSz, ESeekOrigin::Begin, x50_cachedResInfo->GetOffset());
CInputStream* newStrm = new athena::io::MemoryReader((atUint8*)buf, resSz, !extBuf);
const bool takeOwnership = extBuf == nullptr;
std::unique_ptr<CInputStream> newStrm = std::make_unique<athena::io::MemoryReader>(buf, resSz, takeOwnership);
if (x50_cachedResInfo->IsCompressed()) { if (x50_cachedResInfo->IsCompressed()) {
newStrm->readUint32Big(); newStrm->readUint32Big();
newStrm = new CZipInputStream(std::unique_ptr<CInputStream>(newStrm)); newStrm = std::make_unique<CZipInputStream>(std::move(newStrm));
} }
return std::unique_ptr<CInputStream>(newStrm);
return newStrm;
} }
return {};
return nullptr;
} }
std::shared_ptr<IDvdRequest> CResLoader::LoadResourcePartAsync(const SObjectTag& tag, u32 off, u32 size, void* buf) { std::shared_ptr<IDvdRequest> CResLoader::LoadResourcePartAsync(const SObjectTag& tag, u32 off, u32 size, void* buf) {

View File

@ -11,15 +11,17 @@ CSimplePool::CSimplePool(IFactory& factory)
CSimplePool::~CSimplePool() { assert(x8_resources.empty() && "Dangling CSimplePool resources detected"); } CSimplePool::~CSimplePool() { assert(x8_resources.empty() && "Dangling CSimplePool resources detected"); }
CToken CSimplePool::GetObj(const SObjectTag& tag, const CVParamTransfer& paramXfer) { CToken CSimplePool::GetObj(const SObjectTag& tag, const CVParamTransfer& paramXfer) {
if (!tag) if (!tag) {
return {}; return {};
}
auto iter = x8_resources.find(tag); const auto iter = x8_resources.find(tag);
if (iter != x8_resources.end()) if (iter != x8_resources.end()) {
return CToken(iter->second); return CToken(iter->second);
}
CObjectReference* ret = new CObjectReference(*this, std::unique_ptr<IObj>(), tag, paramXfer); auto* const ret = new CObjectReference(*this, nullptr, tag, paramXfer);
x8_resources.emplace(std::make_pair<SObjectTag, CObjectReference*>((SObjectTag)tag, std::move(ret))); x8_resources.emplace(tag, ret);
return CToken(ret); return CToken(ret);
} }

View File

@ -71,7 +71,7 @@ CStateManager::CStateManager(const std::weak_ptr<CRelayTracker>& relayTracker,
, x8c0_mapWorldInfo(mwInfo) , x8c0_mapWorldInfo(mwInfo)
, x8c4_worldTransManager(wtMgr) , x8c4_worldTransManager(wtMgr)
, x8c8_worldLayerState(layerState) { , x8c8_worldLayerState(layerState) {
x86c_stateManagerContainer.reset(new CStateManagerContainer); x86c_stateManagerContainer = std::make_unique<CStateManagerContainer>();
x870_cameraManager = &x86c_stateManagerContainer->x0_cameraManager; x870_cameraManager = &x86c_stateManagerContainer->x0_cameraManager;
x874_sortedListManager = &x86c_stateManagerContainer->x3c0_sortedListManager; x874_sortedListManager = &x86c_stateManagerContainer->x3c0_sortedListManager;
x878_weaponManager = &x86c_stateManagerContainer->xe3d8_weaponManager; x878_weaponManager = &x86c_stateManagerContainer->xe3d8_weaponManager;
@ -2146,7 +2146,7 @@ void CStateManager::InitializeState(CAssetId mlvlId, TAreaId aid, CAssetId mreaI
if (xb3c_initPhase == EInitPhase::LoadWorld) { if (xb3c_initPhase == EInitPhase::LoadWorld) {
CreateStandardGameObjects(); CreateStandardGameObjects();
x850_world.reset(new CWorld(*g_SimplePool, *g_ResFactory, mlvlId)); x850_world = std::make_unique<CWorld>(*g_SimplePool, *g_ResFactory, mlvlId);
xb3c_initPhase = EInitPhase::LoadFirstArea; xb3c_initPhase = EInitPhase::LoadFirstArea;
} }
@ -2216,17 +2216,18 @@ void CStateManager::InitializeState(CAssetId mlvlId, TAreaId aid, CAssetId mreaI
} }
void CStateManager::CreateStandardGameObjects() { void CStateManager::CreateStandardGameObjects() {
float height = g_tweakPlayer->GetPlayerHeight(); const float height = g_tweakPlayer->GetPlayerHeight();
float xyHe = g_tweakPlayer->GetPlayerXYHalfExtent(); const float xyHe = g_tweakPlayer->GetPlayerXYHalfExtent();
float stepUp = g_tweakPlayer->GetStepUpHeight(); const float stepUp = g_tweakPlayer->GetStepUpHeight();
float stepDown = g_tweakPlayer->GetStepDownHeight(); const float stepDown = g_tweakPlayer->GetStepDownHeight();
float ballRadius = g_tweakPlayer->GetPlayerBallHalfExtent(); const float ballRadius = g_tweakPlayer->GetPlayerBallHalfExtent();
zeus::CAABox pBounds = {{-xyHe, -xyHe, 0.f}, {xyHe, xyHe, height}}; const zeus::CAABox pBounds = {{-xyHe, -xyHe, 0.f}, {xyHe, xyHe, height}};
auto q = zeus::CQuaternion::fromAxisAngle(zeus::CVector3f{0.f, 0.f, 1.f}, zeus::degToRad(129.6f)); const auto q = zeus::CQuaternion::fromAxisAngle(zeus::CVector3f{0.f, 0.f, 1.f}, zeus::degToRad(129.6f));
x84c_player.reset(
new CPlayer(AllocateUniqueId(), zeus::CTransform(q), pBounds, g_tweakPlayerRes->xc4_ballTransitionsANCS, x84c_player = std::make_unique<CPlayer>(
zeus::CVector3f{1.65f, 1.65f, 1.65f}, 200.f, stepUp, stepDown, ballRadius, AllocateUniqueId(), zeus::CTransform(q), pBounds, g_tweakPlayerRes->xc4_ballTransitionsANCS,
CMaterialList(EMaterialTypes::Player, EMaterialTypes::Solid, EMaterialTypes::GroundCollider))); zeus::CVector3f{1.65f, 1.65f, 1.65f}, 200.f, stepUp, stepDown, ballRadius,
CMaterialList(EMaterialTypes::Player, EMaterialTypes::Solid, EMaterialTypes::GroundCollider));
AddObject(*x84c_player); AddObject(*x84c_player);
x870_cameraManager->CreateStandardCameras(*this); x870_cameraManager->CreateStandardCameras(*this);
} }

View File

@ -45,15 +45,18 @@ void CAnimTreeTimeScale::VSetPhase(float phase) { x14_child->VSetPhase(phase); }
std::optional<std::unique_ptr<IAnimReader>> CAnimTreeTimeScale::VSimplified() { std::optional<std::unique_ptr<IAnimReader>> CAnimTreeTimeScale::VSimplified() {
if (auto simp = x14_child->Simplified()) { if (auto simp = x14_child->Simplified()) {
CAnimTreeTimeScale* newNode = new CAnimTreeTimeScale(CAnimTreeNode::Cast(std::move(*simp)), x18_timeScale->Clone(), auto newNode = std::make_unique<CAnimTreeTimeScale>(CAnimTreeNode::Cast(std::move(*simp)), x18_timeScale->Clone(),
x28_targetAccelTime, x4_name); x28_targetAccelTime, x4_name);
newNode->x20_curAccelTime = x20_curAccelTime; newNode->x20_curAccelTime = x20_curAccelTime;
newNode->x30_initialTime = x30_initialTime; newNode->x30_initialTime = x30_initialTime;
return {std::unique_ptr<IAnimReader>(newNode)}; return {std::move(newNode)};
} else if (x20_curAccelTime == x28_targetAccelTime) { }
if (x20_curAccelTime == x28_targetAccelTime) {
return {x14_child->Clone()}; return {x14_child->Clone()};
} }
return {};
return std::nullopt;
} }
u32 CAnimTreeTimeScale::VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32 CAnimTreeTimeScale::VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator,
@ -112,21 +115,21 @@ CAnimTreeEffectiveContribution CAnimTreeTimeScale::VGetContributionOfHighestInfl
std::shared_ptr<IAnimReader> CAnimTreeTimeScale::VGetBestUnblendedChild() const { std::shared_ptr<IAnimReader> CAnimTreeTimeScale::VGetBestUnblendedChild() const {
if (std::shared_ptr<IAnimReader> bestChild = x14_child->VGetBestUnblendedChild()) { if (std::shared_ptr<IAnimReader> bestChild = x14_child->VGetBestUnblendedChild()) {
CAnimTreeTimeScale* newNode = new CAnimTreeTimeScale(CAnimTreeNode::Cast(bestChild->Clone()), auto newNode = std::make_shared<CAnimTreeTimeScale>(CAnimTreeNode::Cast(bestChild->Clone()),
x18_timeScale->Clone(), x28_targetAccelTime, x4_name); x18_timeScale->Clone(), x28_targetAccelTime, x4_name);
newNode->x20_curAccelTime = x20_curAccelTime; newNode->x20_curAccelTime = x20_curAccelTime;
newNode->x30_initialTime = x30_initialTime; newNode->x30_initialTime = x30_initialTime;
return {std::shared_ptr<IAnimReader>(newNode)}; return {std::move(newNode)};
} }
return {}; return nullptr;
} }
std::unique_ptr<IAnimReader> CAnimTreeTimeScale::VClone() const { std::unique_ptr<IAnimReader> CAnimTreeTimeScale::VClone() const {
CAnimTreeTimeScale* newNode = new CAnimTreeTimeScale(CAnimTreeNode::Cast(x14_child->Clone()), x18_timeScale->Clone(), auto newNode = std::make_unique<CAnimTreeTimeScale>(CAnimTreeNode::Cast(x14_child->Clone()), x18_timeScale->Clone(),
x28_targetAccelTime, x4_name); x28_targetAccelTime, x4_name);
newNode->x20_curAccelTime = x20_curAccelTime; newNode->x20_curAccelTime = x20_curAccelTime;
newNode->x30_initialTime = x30_initialTime; newNode->x30_initialTime = x30_initialTime;
return {std::unique_ptr<IAnimReader>(newNode)}; return {std::move(newNode)};
} }
CSteadyStateAnimInfo CAnimTreeTimeScale::VGetSteadyStateAnimInfo() const { CSteadyStateAnimInfo CAnimTreeTimeScale::VGetSteadyStateAnimInfo() const {

View File

@ -556,15 +556,14 @@ void CGroundMovement::MoveGroundCollider_New(CStateManager& mgr, CPhysicsActor&
std::unique_ptr<CCollisionPrimitive> prim; std::unique_ptr<CCollisionPrimitive> prim;
if (usePrim->GetPrimType() == FOURCC('AABX')) { if (usePrim->GetPrimType() == FOURCC('AABX')) {
const CCollidableAABox& existingAABB = static_cast<const CCollidableAABox&>(*usePrim); const CCollidableAABox& existingAABB = static_cast<const CCollidableAABox&>(*usePrim);
prim.reset( prim = std::make_unique<CCollidableAABox>(
new CCollidableAABox(zeus::CAABox(existingAABB.GetBox().min + 0.0001f, existingAABB.GetBox().max - 0.0001f), zeus::CAABox(existingAABB.GetBox().min + 0.0001f, existingAABB.GetBox().max - 0.0001f), usePrim->GetMaterial());
usePrim->GetMaterial()));
usePrim = prim.get(); usePrim = prim.get();
} else if (usePrim->GetPrimType() == FOURCC('SPHR')) { } else if (usePrim->GetPrimType() == FOURCC('SPHR')) {
const CCollidableSphere& existingSphere = static_cast<const CCollidableSphere&>(*usePrim); const CCollidableSphere& existingSphere = static_cast<const CCollidableSphere&>(*usePrim);
prim.reset(new CCollidableSphere( prim = std::make_unique<CCollidableSphere>(
zeus::CSphere(existingSphere.GetSphere().position, existingSphere.GetSphere().radius - 0.0001f), zeus::CSphere(existingSphere.GetSphere().position, existingSphere.GetSphere().radius - 0.0001f),
usePrim->GetMaterial())); usePrim->GetMaterial());
usePrim = prim.get(); usePrim = prim.get();
} }

View File

@ -336,16 +336,15 @@ void CParticleDatabase::AddAuxiliaryParticleEffect(std::string_view name, int fl
else else
scaleVec = scale * data.GetScale(); scaleVec = scale * data.GetScale();
std::unique_ptr<CParticleGenInfo> newGen;
switch (data.GetTag().type.toUint32()) { switch (data.GetTag().type.toUint32()) {
case SBIG('PART'): { case SBIG('PART'): {
auto search = x0_particleDescs.find(data.GetTag().id); const auto search = x0_particleDescs.find(data.GetTag().id);
if (search != x0_particleDescs.end()) { if (search != x0_particleDescs.cend()) {
auto sys = std::make_shared<CElementGen>(*search->second); auto sys = std::make_shared<CElementGen>(*search->second);
newGen = std::make_unique<CParticleGenInfoGeneric>(data.GetTag(), sys, data.GetDuration(), "NOT_A_VALID_LOCATOR", auto newGen = std::make_unique<CParticleGenInfoGeneric>(
scaleVec, CParticleData::EParentedMode::Initial, flags, mgr, data.GetTag(), sys, data.GetDuration(), "NOT_A_VALID_LOCATOR", scaleVec,
aid, lightId + _getGraphicLightId(sys, *search->second), CParticleData::EParentedMode::Initial, flags, mgr, aid, lightId + _getGraphicLightId(sys, *search->second),
EParticleGenType::Auxiliary); EParticleGenType::Auxiliary);
newGen->SetGlobalTranslation(data.GetTranslation(), mgr); newGen->SetGlobalTranslation(data.GetTranslation(), mgr);
newGen->SetIsGrabInitialData(false); newGen->SetIsGrabInitialData(false);
@ -380,8 +379,8 @@ void CParticleDatabase::AddParticleEffect(std::string_view name, int flags, cons
std::unique_ptr<CParticleGenInfo> newGen; std::unique_ptr<CParticleGenInfo> newGen;
switch (data.GetTag().type.toUint32()) { switch (data.GetTag().type.toUint32()) {
case SBIG('PART'): { case SBIG('PART'): {
auto search = x0_particleDescs.find(data.GetTag().id); const auto search = x0_particleDescs.find(data.GetTag().id);
if (search != x0_particleDescs.end()) { if (search != x0_particleDescs.cend()) {
auto sys = std::make_shared<CElementGen>(*search->second); auto sys = std::make_shared<CElementGen>(*search->second);
newGen = std::make_unique<CParticleGenInfoGeneric>( newGen = std::make_unique<CParticleGenInfoGeneric>(
data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(), scaleVec, data.GetParentedMode(), flags, mgr, data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(), scaleVec, data.GetParentedMode(), flags, mgr,
@ -390,8 +389,8 @@ void CParticleDatabase::AddParticleEffect(std::string_view name, int flags, cons
break; break;
} }
case SBIG('SWHC'): { case SBIG('SWHC'): {
auto search = x14_swooshDescs.find(data.GetTag().id); const auto search = x14_swooshDescs.find(data.GetTag().id);
if (search != x14_swooshDescs.end()) { if (search != x14_swooshDescs.cend()) {
auto sys = std::make_shared<CParticleSwoosh>(*search->second, 0); auto sys = std::make_shared<CParticleSwoosh>(*search->second, 0);
newGen = std::make_unique<CParticleGenInfoGeneric>(data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(), newGen = std::make_unique<CParticleGenInfoGeneric>(data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(),
scaleVec, data.GetParentedMode(), flags, mgr, aid, -1, scaleVec, data.GetParentedMode(), flags, mgr, aid, -1,
@ -400,8 +399,8 @@ void CParticleDatabase::AddParticleEffect(std::string_view name, int flags, cons
break; break;
} }
case SBIG('ELSC'): { case SBIG('ELSC'): {
auto search = x28_electricDescs.find(data.GetTag().id); const auto search = x28_electricDescs.find(data.GetTag().id);
if (search != x28_electricDescs.end()) { if (search != x28_electricDescs.cend()) {
auto sys = std::make_shared<CParticleElectric>(*search->second); auto sys = std::make_shared<CParticleElectric>(*search->second);
newGen = std::make_unique<CParticleGenInfoGeneric>( newGen = std::make_unique<CParticleGenInfoGeneric>(
data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(), scaleVec, data.GetParentedMode(), flags, mgr, data.GetTag(), sys, data.GetDuration(), data.GetSegmentName(), scaleVec, data.GetParentedMode(), flags, mgr,

View File

@ -12,11 +12,11 @@ const CCollisionPrimitive::Type CCollidableOBBTreeGroup::sType(CCollidableOBBTre
u32 CCollidableOBBTreeGroup::sTableIndex = -1; u32 CCollidableOBBTreeGroup::sTableIndex = -1;
CCollidableOBBTreeGroupContainer::CCollidableOBBTreeGroupContainer(CInputStream& in) { CCollidableOBBTreeGroupContainer::CCollidableOBBTreeGroupContainer(CInputStream& in) {
u32 treeCount = in.readUint32Big(); const u32 treeCount = in.readUint32Big();
x0_trees.reserve(treeCount); x0_trees.reserve(treeCount);
for (u32 i = 0; i < treeCount; i++) { for (u32 i = 0; i < treeCount; i++) {
std::unique_ptr<COBBTree> tree(new COBBTree(in)); auto tree = std::make_unique<COBBTree>(in);
x0_trees.push_back(std::move(tree)); x0_trees.push_back(std::move(tree));
} }

View File

@ -20,8 +20,8 @@ CCollisionActor::CCollisionActor(TUniqueId uid1, TAreaId aId, TUniqueId uid2, co
, x25c_owner(uid2) , x25c_owner(uid2)
, x260_boxSize(extent) , x260_boxSize(extent)
, x26c_center(center) , x26c_center(center)
, x278_obbContainer(new CCollidableOBBTreeGroupContainer(extent, center)) , x278_obbContainer(std::make_unique<CCollidableOBBTreeGroupContainer>(extent, center))
, x27c_obbTreeGroupPrimitive(new CCollidableOBBTreeGroup(x278_obbContainer.get(), GetMaterialList())) { , x27c_obbTreeGroupPrimitive(std::make_unique<CCollidableOBBTreeGroup>(x278_obbContainer.get(), GetMaterialList())) {
x10_name += ' '; x10_name += ' ';
x10_name += name; x10_name += name;
SetCoefficientOfRestitutionModifier(0.5f); SetCoefficientOfRestitutionModifier(0.5f);
@ -38,8 +38,9 @@ CCollisionActor::CCollisionActor(TUniqueId uid1, TAreaId aId, TUniqueId uid2, co
, x258_primitiveType(EPrimitiveType::AABox) , x258_primitiveType(EPrimitiveType::AABox)
, x25c_owner(uid2) , x25c_owner(uid2)
, x260_boxSize(boxSize) , x260_boxSize(boxSize)
, x280_aaboxPrimitive(new CCollidableAABox(zeus::CAABox(-0.5f * boxSize, 0.5f * boxSize), , x280_aaboxPrimitive(
CMaterialList(EMaterialTypes::Solid, EMaterialTypes::NoStaticCollision))) { std::make_unique<CCollidableAABox>(zeus::CAABox(-0.5f * boxSize, 0.5f * boxSize),
CMaterialList(EMaterialTypes::Solid, EMaterialTypes::NoStaticCollision))) {
x10_name += ' '; x10_name += ' ';
x10_name += name; x10_name += name;
SetCoefficientOfRestitutionModifier(0.5f); SetCoefficientOfRestitutionModifier(0.5f);
@ -55,8 +56,8 @@ CCollisionActor::CCollisionActor(TUniqueId uid1, TAreaId aId, TUniqueId uid2, bo
zeus::skNullBox, SMoverData(mass), CActorParameters::None(), 0.3f, 0.1f) zeus::skNullBox, SMoverData(mass), CActorParameters::None(), 0.3f, 0.1f)
, x258_primitiveType(EPrimitiveType::Sphere) , x258_primitiveType(EPrimitiveType::Sphere)
, x25c_owner(uid2) , x25c_owner(uid2)
, x284_spherePrimitive(new CCollidableSphere(zeus::CSphere(zeus::skZero3f, radius), , x284_spherePrimitive(std::make_unique<CCollidableSphere>(
CMaterialList(EMaterialTypes::NoStaticCollision, EMaterialTypes::Solid))) zeus::CSphere(zeus::skZero3f, radius), CMaterialList(EMaterialTypes::NoStaticCollision, EMaterialTypes::Solid)))
, x288_sphereRadius(radius) { , x288_sphereRadius(radius) {
x10_name += ' '; x10_name += ' ';
x10_name += name; x10_name += name;

View File

@ -149,13 +149,13 @@ bool CCollisionPrimitive::CollideMoving(const CInternalCollisionStructure::CPrim
} }
void CCollisionPrimitive::InitBeginTypes() { void CCollisionPrimitive::InitBeginTypes() {
sCollisionTypeList.reset(new std::vector<CCollisionPrimitive::Type>()); sCollisionTypeList = std::make_unique<std::vector<Type>>();
sCollisionTypeList->reserve(3); sCollisionTypeList->reserve(3);
sTypesAdding = true; sTypesAdding = true;
InternalColliders::AddTypes(); InternalColliders::AddTypes();
} }
void CCollisionPrimitive::InitAddType(const CCollisionPrimitive::Type& tp) { void CCollisionPrimitive::InitAddType(const Type& tp) {
tp.GetSetter()(sCollisionTypeList->size()); tp.GetSetter()(sCollisionTypeList->size());
sCollisionTypeList->push_back(tp); sCollisionTypeList->push_back(tp);
} }
@ -168,13 +168,10 @@ void CCollisionPrimitive::InitEndTypes() {
} }
void CCollisionPrimitive::InitBeginColliders() { void CCollisionPrimitive::InitBeginColliders() {
sTableOfCollidables.reset(new std::vector<ComparisonFunc>()); const size_t tableSz = sCollisionTypeList->size() * sCollisionTypeList->size();
sTableOfBooleanCollidables.reset(new std::vector<BooleanComparisonFunc>()); sTableOfCollidables = std::make_unique<std::vector<ComparisonFunc>>(tableSz);
sTableOfMovingCollidables.reset(new std::vector<MovingComparisonFunc>()); sTableOfBooleanCollidables = std::make_unique<std::vector<BooleanComparisonFunc>>(tableSz);
size_t tableSz = sCollisionTypeList->size() * sCollisionTypeList->size(); sTableOfMovingCollidables = std::make_unique<std::vector<MovingComparisonFunc>>(tableSz);
sTableOfCollidables->resize(tableSz);
sTableOfBooleanCollidables->resize(tableSz);
sTableOfMovingCollidables->resize(tableSz);
sCollidersAdding = true; sCollidersAdding = true;
InternalColliders::AddColliders(); InternalColliders::AddColliders();
} }

View File

@ -232,7 +232,6 @@ FourCC CCollisionResponseData::UncookedResType() { return SBIG('CRSM'); }
CFactoryFnReturn FCollisionResponseDataFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& vparms, CFactoryFnReturn FCollisionResponseDataFactory(const SObjectTag& tag, CInputStream& in, const CVParamTransfer& vparms,
CObjectReference*) { CObjectReference*) {
CSimplePool* sp = vparms.GetOwnedObj<CSimplePool*>(); CSimplePool* sp = vparms.GetOwnedObj<CSimplePool*>();
return TToken<CCollisionResponseData>::GetIObjObjectFor( return TToken<CCollisionResponseData>::GetIObjObjectFor(std::make_unique<CCollisionResponseData>(in, sp));
std::unique_ptr<CCollisionResponseData>(new CCollisionResponseData(in, sp)));
} }
} // namespace urde } // namespace urde

View File

@ -13,7 +13,7 @@ COBBTree::COBBTree(CInputStream& in)
, x4_version(verify_version(in)) , x4_version(verify_version(in))
, x8_memsize(in.readUint32()) , x8_memsize(in.readUint32())
, x18_indexData(in) , x18_indexData(in)
, x88_root(new CNode(in)) {} , x88_root(std::make_unique<CNode>(in)) {}
static const u8 DefaultEdgeMaterials[] = { static const u8 DefaultEdgeMaterials[] = {
2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 2 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 2, 2
@ -168,10 +168,10 @@ COBBTree::CNode::CNode(CInputStream& in) {
x0_obb = zeus::COBBox::ReadBig(in); x0_obb = zeus::COBBox::ReadBig(in);
x3c_isLeaf = in.readBool(); x3c_isLeaf = in.readBool();
if (x3c_isLeaf) if (x3c_isLeaf)
x48_leaf.reset(new CLeafData(in)); x48_leaf = std::make_unique<CLeafData>(in);
else { else {
x40_left.reset(new CNode(in)); x40_left = std::make_unique<CNode>(in);
x44_right.reset(new CNode(in)); x44_right = std::make_unique<CNode>(in);
} }
} }

View File

@ -18,9 +18,9 @@ CGuiFrame::CGuiFrame(CAssetId id, CGuiSys& sys, int a, int b, int c, CSimplePool
: x0_id(id), x8_guiSys(sys), x4c_a(a), x50_b(b), x54_c(c), x58_24_loaded(false) { : x0_id(id), x8_guiSys(sys), x4c_a(a), x50_b(b), x54_c(c), x58_24_loaded(false) {
x3c_lights.reserve(8); x3c_lights.reserve(8);
m_indexedLights.reserve(8); m_indexedLights.reserve(8);
x10_rootWidget.reset(new CGuiWidget(CGuiWidget::CGuiWidgetParms( x10_rootWidget = std::make_unique<CGuiWidget>(CGuiWidget::CGuiWidgetParms(
this, false, 0, 0, false, false, false, zeus::skWhite, CGuiWidget::EGuiModelDrawFlags::Alpha, false, this, false, 0, 0, false, false, false, zeus::skWhite, CGuiWidget::EGuiModelDrawFlags::Alpha, false,
x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero, "<root>"s))); x8_guiSys.x8_mode != CGuiSys::EUsageMode::Zero, "<root>"s));
x8_guiSys.m_registeredFrames.insert(this); x8_guiSys.m_registeredFrames.insert(this);
} }

View File

@ -61,8 +61,8 @@ CGuiSys::CGuiSys(IFactory& resFactory, CSimplePool& resStore, EUsageMode mode)
: x0_resFactory(resFactory) : x0_resFactory(resFactory)
, x4_resStore(resStore) , x4_resStore(resStore)
, x8_mode(mode) , x8_mode(mode)
, xc_textExecuteBuf(new CTextExecuteBuffer()) , xc_textExecuteBuf(std::make_unique<CTextExecuteBuffer>())
, x10_textParser(new CTextParser(resStore)) { , x10_textParser(std::make_unique<CTextParser>(resStore)) {
g_TextExecuteBuf = xc_textExecuteBuf.get(); g_TextExecuteBuf = xc_textExecuteBuf.get();
g_TextParser = x10_textParser.get(); g_TextParser = x10_textParser.get();
} }

View File

@ -361,14 +361,17 @@ void CMain::InitializeSubsystems() {
} }
void CMain::MemoryCardInitializePump() { void CMain::MemoryCardInitializePump() {
if (!g_MemoryCardSys) { if (g_MemoryCardSys) {
std::unique_ptr<CMemoryCardSys>& memSys = x128_globalObjects.x0_memoryCardSys; return;
if (!memSys) }
memSys.reset(new CMemoryCardSys());
if (memSys->InitializePump()) { std::unique_ptr<CMemoryCardSys>& memSys = x128_globalObjects.x0_memoryCardSys;
g_MemoryCardSys = memSys.get(); if (!memSys) {
g_GameState->InitializeMemoryStates(); memSys = std::make_unique<CMemoryCardSys>();
} }
if (memSys->InitializePump()) {
g_MemoryCardSys = memSys.get();
g_GameState->InitializeMemoryStates();
} }
} }
@ -728,7 +731,7 @@ void CMain::Init(const hecl::Runtime::FileStoreManager& storeMgr, hecl::CVarMana
} }
FillInAssetIDs(); FillInAssetIDs();
x164_archSupport.reset(new CGameArchitectureSupport(*this, voiceEngine, backend)); x164_archSupport = std::make_unique<CGameArchitectureSupport>(*this, voiceEngine, backend);
g_archSupport = x164_archSupport.get(); g_archSupport = x164_archSupport.get();
x164_archSupport->PreloadAudio(); x164_archSupport->PreloadAudio();
std::srand(static_cast<unsigned int>(std::time(nullptr))); std::srand(static_cast<unsigned int>(std::time(nullptr)));

View File

@ -76,18 +76,18 @@ public:
CGameGlobalObjects(IFactory* resFactory, CSimplePool* objStore) CGameGlobalObjects(IFactory* resFactory, CSimplePool* objStore)
: x4_resFactory(resFactory), xcc_simplePool(objStore) { : x4_resFactory(resFactory), xcc_simplePool(objStore) {
if (!x4_resFactory) { if (!x4_resFactory) {
m_gameResFactory.reset(new CResFactory()); m_gameResFactory = std::make_unique<CResFactory>();
x4_resFactory = m_gameResFactory.get(); x4_resFactory = m_gameResFactory.get();
} }
if (!xcc_simplePool) { if (!xcc_simplePool) {
m_gameSimplePool.reset(new CSimplePool(*x4_resFactory)); m_gameSimplePool = std::make_unique<CSimplePool>(*x4_resFactory);
xcc_simplePool = m_gameSimplePool.get(); xcc_simplePool = m_gameSimplePool.get();
} }
g_ResFactory = x4_resFactory; g_ResFactory = x4_resFactory;
g_SimplePool = xcc_simplePool; g_SimplePool = xcc_simplePool;
g_CharFactoryBuilder = &xec_charFactoryBuilder; g_CharFactoryBuilder = &xec_charFactoryBuilder;
g_AiFuncMap = &x110_aiFuncMap; g_AiFuncMap = &x110_aiFuncMap;
x134_gameState.reset(new CGameState()); x134_gameState = std::make_unique<CGameState>();
g_GameState = x134_gameState.get(); g_GameState = x134_gameState.get();
g_TweakManager = &x150_tweakManager; g_TweakManager = &x150_tweakManager;
} }
@ -104,12 +104,12 @@ public:
} }
void ResetGameState() { void ResetGameState() {
x134_gameState.reset(new CGameState()); x134_gameState = std::make_unique<CGameState>();
g_GameState = x134_gameState.get(); g_GameState = x134_gameState.get();
} }
void StreamInGameState(CBitStreamReader& stream, u32 saveIdx) { void StreamInGameState(CBitStreamReader& stream, u32 saveIdx) {
x134_gameState.reset(new CGameState(stream, saveIdx)); x134_gameState = std::make_unique<CGameState>(stream, saveIdx);
g_GameState = x134_gameState.get(); g_GameState = x134_gameState.get();
} }
}; };

View File

@ -298,7 +298,7 @@ void CBabygoth::AddSphereCollisionList(const SSphereJointInfo* sphereJointInfo,
void CBabygoth::SetupCollisionManager(CStateManager& mgr) { void CBabygoth::SetupCollisionManager(CStateManager& mgr) {
std::vector<CJointCollisionDescription> joints; std::vector<CJointCollisionDescription> joints;
AddSphereCollisionList(skSphereJointList, skSphereJointCount, joints); AddSphereCollisionList(skSphereJointList, skSphereJointCount, joints);
x928_colActMgr.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), joints, false)); x928_colActMgr = std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), joints, false);
x928_colActMgr->SetActive(mgr, GetActive()); x928_colActMgr->SetActive(mgr, GetActive());
for (u32 i = 0; i < x928_colActMgr->GetNumCollisionActors(); ++i) { for (u32 i = 0; i < x928_colActMgr->GetNumCollisionActors(); ++i) {

View File

@ -18,7 +18,7 @@ CBloodFlower::CBloodFlower(TUniqueId uid, std::string_view name, const CEntityIn
: CPatterned(ECharacter::BloodFlower, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo, : CPatterned(ECharacter::BloodFlower, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Ground, EColliderType::One, EBodyType::Restricted, actParms, EKnockBackVariant::Medium) EMovementType::Ground, EColliderType::One, EBodyType::Restricted, actParms, EKnockBackVariant::Medium)
, x568_podEffectDesc(g_SimplePool->GetObj({FOURCC('PART'), partId1})) , x568_podEffectDesc(g_SimplePool->GetObj({FOURCC('PART'), partId1}))
, x574_podEffect(new CElementGen(x568_podEffectDesc)) , x574_podEffect(std::make_unique<CElementGen>(x568_podEffectDesc))
, x578_projectileDesc(g_SimplePool->GetObj({FOURCC('WPSC'), wpscId1})) , x578_projectileDesc(g_SimplePool->GetObj({FOURCC('WPSC'), wpscId1}))
, x590_projectileInfo(wpscId2, dInfo1) , x590_projectileInfo(wpscId2, dInfo1)
, x5d4_visorSfx(CSfxManager::TranslateSFXID(soundId)) , x5d4_visorSfx(CSfxManager::TranslateSFXID(soundId))

View File

@ -345,8 +345,9 @@ void CFlaahgra::ResetModelDataAndBodyController() {
CreateShadow(true); CreateShadow(true);
x94_simpleShadow->SetAlwaysCalculateRadius(false); x94_simpleShadow->SetAlwaysCalculateRadius(false);
BuildBodyController(EBodyType::Restricted); BuildBodyController(EBodyType::Restricted);
x6cc_boneTracking.reset(new CBoneTracking(*GetModelData()->GetAnimationData(), "Head_1"sv, zeus::degToRad(80.f), x6cc_boneTracking =
zeus::degToRad(180.f), EBoneTrackingFlags::None)); std::make_unique<CBoneTracking>(*GetModelData()->GetAnimationData(), "Head_1"sv, zeus::degToRad(80.f),
zeus::degToRad(180.f), EBoneTrackingFlags::None);
} }
void CFlaahgra::GatherAssets(CStateManager& mgr) { void CFlaahgra::GatherAssets(CStateManager& mgr) {
if (x8e4_24_loaded) if (x8e4_24_loaded)
@ -488,19 +489,20 @@ void CFlaahgra::SetupCollisionManagers(CStateManager& mgr) {
zeus::CVector3f oldScale = GetModelData()->GetScale(); zeus::CVector3f oldScale = GetModelData()->GetScale();
leftArmjointList.reserve(3); leftArmjointList.reserve(3);
AddCollisionList(skLeftArmJointList, 3, leftArmjointList); AddCollisionList(skLeftArmJointList, 3, leftArmjointList);
x79c_leftArmCollision.reset( x79c_leftArmCollision =
new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), leftArmjointList, true)); std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), leftArmjointList, true);
SetMaterialProperties(x79c_leftArmCollision, mgr); SetMaterialProperties(x79c_leftArmCollision, mgr);
std::vector<CJointCollisionDescription> rightArmJointList; std::vector<CJointCollisionDescription> rightArmJointList;
rightArmJointList.reserve(3); rightArmJointList.reserve(3);
AddCollisionList(skRightArmJointList, 3, rightArmJointList); AddCollisionList(skRightArmJointList, 3, rightArmJointList);
x7a0_rightArmCollision.reset( x7a0_rightArmCollision =
new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), rightArmJointList, true)); std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), rightArmJointList, true);
SetMaterialProperties(x7a0_rightArmCollision, mgr); SetMaterialProperties(x7a0_rightArmCollision, mgr);
std::vector<CJointCollisionDescription> sphereJointList; std::vector<CJointCollisionDescription> sphereJointList;
sphereJointList.reserve(5); sphereJointList.reserve(5);
AddSphereCollisionList(skSphereJointList, 5, sphereJointList); AddSphereCollisionList(skSphereJointList, 5, sphereJointList);
x7a4_sphereCollision.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), sphereJointList, true)); x7a4_sphereCollision =
std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), sphereJointList, true);
SetMaterialProperties(x7a4_sphereCollision, mgr); SetMaterialProperties(x7a4_sphereCollision, mgr);
SetupHealthInfo(mgr); SetupHealthInfo(mgr);
SetMaterialFilter(CMaterialFilter::MakeIncludeExclude( SetMaterialFilter(CMaterialFilter::MakeIncludeExclude(
@ -1208,7 +1210,7 @@ CFlaahgraPlants::CFlaahgraPlants(const TToken<CGenDescription>& genDesc, const C
const CDamageInfo& dInfo, const zeus::CVector3f& extents) const CDamageInfo& dInfo, const zeus::CVector3f& extents)
: CActor(uid, true, "Flaahgra Plants"sv, CEntityInfo(aId, NullConnectionList), xf, CModelData::CModelDataNull(), : CActor(uid, true, "Flaahgra Plants"sv, CEntityInfo(aId, NullConnectionList), xf, CModelData::CModelDataNull(),
CMaterialList(EMaterialTypes::Projectile), actParms, kInvalidUniqueId) CMaterialList(EMaterialTypes::Projectile), actParms, kInvalidUniqueId)
, xe8_elementGen(new CElementGen(genDesc)) , xe8_elementGen(std::make_unique<CElementGen>(genDesc))
, xf0_ownerId(owner) , xf0_ownerId(owner)
, x130_obbox(xf, extents) { , x130_obbox(xf, extents) {
xe8_elementGen->SetOrientation(xf.getRotation()); xe8_elementGen->SetOrientation(xf.getRotation());

View File

@ -103,7 +103,8 @@ const SSphereJointInfo CFlaahgraTentacle::skJointList[3] = {{"Arm_8", 2.f}, {"Ar
void CFlaahgraTentacle::SetupCollisionManager(CStateManager& mgr) { void CFlaahgraTentacle::SetupCollisionManager(CStateManager& mgr) {
std::vector<CJointCollisionDescription> jointList; std::vector<CJointCollisionDescription> jointList;
AddSphereCollisionList(skJointList, 3, jointList); AddSphereCollisionList(skJointList, 3, jointList);
x56c_collisionManager.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), jointList, true)); x56c_collisionManager =
std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), jointList, true);
for (u32 i = 0; i < x56c_collisionManager->GetNumCollisionActors(); ++i) { for (u32 i = 0; i < x56c_collisionManager->GetNumCollisionActors(); ++i) {
const CJointCollisionDescription& desc = x56c_collisionManager->GetCollisionDescFromIndex(i); const CJointCollisionDescription& desc = x56c_collisionManager->GetCollisionDescFromIndex(i);

View File

@ -51,11 +51,11 @@ CMetroidBeta::CMetroidBeta(TUniqueId uid, std::string_view name, const CEntityIn
, x7fc_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.xfc_})) , x7fc_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.xfc_}))
, x808_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.x100_})) , x808_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.x100_}))
, x814_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.x104_})) , x814_(g_SimplePool->GetObj({FOURCC('PART'), metroidData.x104_}))
, x820_(new CElementGen(x7e4_)) , x820_(std::make_unique<CElementGen>(x7e4_))
, x824_(new CParticleSwoosh(x7f0_, 0)) , x824_(std::make_unique<CParticleSwoosh>(x7f0_, 0))
, x828_(new CElementGen(x7fc_)) , x828_(std::make_unique<CElementGen>(x7fc_))
, x82c_(new CElementGen(x808_)) , x82c_(std::make_unique<CElementGen>(x808_))
, x830_(new CElementGen(x814_)) { , x830_(std::make_unique<CElementGen>(x814_)) {
x820_->SetParticleEmission(false); x820_->SetParticleEmission(false);
x828_->SetParticleEmission(false); x828_->SetParticleEmission(false);
x82c_->SetParticleEmission(false); x82c_->SetParticleEmission(false);
@ -237,7 +237,8 @@ void CMetroidBeta::CreateCollisionActorManager(CStateManager& mgr) {
std::vector<CJointCollisionDescription> joints; std::vector<CJointCollisionDescription> joints;
AddSphereJoints(skPelvisInfo, 1, joints); AddSphereJoints(skPelvisInfo, 1, joints);
x764_collisionManager.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), joints, false)); x764_collisionManager =
std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), joints, false);
x764_collisionManager->SetActive(mgr, GetActive()); x764_collisionManager->SetActive(mgr, GetActive());
for (u32 i = 0; i < x764_collisionManager->GetNumCollisionActors(); ++i) { for (u32 i = 0; i < x764_collisionManager->GetNumCollisionActors(); ++i) {

View File

@ -37,7 +37,7 @@ CPuddleSpore::CPuddleSpore(TUniqueId uid, std::string_view name, EFlavorType fla
, x614_25(false) { , x614_25(false) {
x5dc_elemGens.reserve(kEyeCount); x5dc_elemGens.reserve(kEyeCount);
for (u32 i = 0; i < kEyeCount; ++i) for (u32 i = 0; i < kEyeCount; ++i)
x5dc_elemGens.emplace_back(new CElementGen(x5d0_)); x5dc_elemGens.emplace_back(std::make_unique<CElementGen>(x5d0_));
x5ec_projectileInfo.Token().Lock(); x5ec_projectileInfo.Token().Lock();
x460_knockBackController.SetAutoResetImpulse(false); x460_knockBackController.SetAutoResetImpulse(false);
} }

View File

@ -39,7 +39,7 @@ CPuddleToadGamma::CPuddleToadGamma(TUniqueId uid, std::string_view name, EFlavor
SetMovable(false); SetMovable(false);
if (dcln.IsValid() && g_ResFactory->GetResourceTypeById(dcln) != 0) { if (dcln.IsValid() && g_ResFactory->GetResourceTypeById(dcln) != 0) {
TLockedToken<CCollidableOBBTreeGroupContainer> container = g_SimplePool->GetObj({FOURCC('DCLN'), dcln}); TLockedToken<CCollidableOBBTreeGroupContainer> container = g_SimplePool->GetObj({FOURCC('DCLN'), dcln});
x5e4_collisionTreePrim.reset(new CCollidableOBBTreeGroup(container.GetObj(), GetMaterialList())); x5e4_collisionTreePrim = std::make_unique<CCollidableOBBTreeGroup>(container.GetObj(), GetMaterialList());
} }
} }

View File

@ -17,7 +17,7 @@ CSeedling::CSeedling(TUniqueId uid, std::string_view name, const CEntityInfo& in
EMovementType::Ground, EColliderType::Zero, EBodyType::WallWalker, actParms, f1, f2, EMovementType::Ground, EColliderType::Zero, EBodyType::WallWalker, actParms, f1, f2,
EKnockBackVariant::Small, f3, EWalkerType::Seedling, f4, false) EKnockBackVariant::Small, f3, EWalkerType::Seedling, f4, false)
, x5d8_searchPath(nullptr, 1, pInfo.GetPathfindingIndex(), 1.f, 1.f) , x5d8_searchPath(nullptr, 1, pInfo.GetPathfindingIndex(), 1.f, 1.f)
, x6bc_spikeData(new CModelData(CStaticRes(needleId, GetModelData()->GetScale()))) , x6bc_spikeData(std::make_unique<CModelData>(CStaticRes(needleId, GetModelData()->GetScale())))
, x6c0_projectileInfo(weaponId, dInfo1) , x6c0_projectileInfo(weaponId, dInfo1)
, x6e8_deathDamage(dInfo2) , x6e8_deathDamage(dInfo2)
, x722_24_renderOnlyClusterA(true) , x722_24_renderOnlyClusterA(true)

View File

@ -76,7 +76,8 @@ void CSpankWeed::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CState
joints.push_back(CJointCollisionDescription::SphereCollision(id, joint.radius, joint.name, 0.001f)); joints.push_back(CJointCollisionDescription::SphereCollision(id, joint.radius, joint.name, 0.001f));
} }
x594_collisionMgr.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), joints, GetActive())); x594_collisionMgr =
std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), joints, GetActive());
CMaterialList list; CMaterialList list;
list.Add(EMaterialTypes::CameraPassthrough); list.Add(EMaterialTypes::CameraPassthrough);
list.Add(EMaterialTypes::Immovable); list.Add(EMaterialTypes::Immovable);

View File

@ -567,8 +567,8 @@ void CElementGen::UpdatePSTranslationAndOrientation() {
} }
std::unique_ptr<CParticleGen> CElementGen::ConstructChildParticleSystem(const TToken<CGenDescription>& desc) const { std::unique_ptr<CParticleGen> CElementGen::ConstructChildParticleSystem(const TToken<CGenDescription>& desc) const {
CElementGen* ret = new CElementGen(desc, EModelOrientationType::Normal, auto ret = std::make_unique<CElementGen>(desc, EModelOrientationType::Normal,
x26d_27_enableOPTS ? EOptionalSystemFlags::Two : EOptionalSystemFlags::One); x26d_27_enableOPTS ? EOptionalSystemFlags::Two : EOptionalSystemFlags::One);
ret->x26d_26_modelsUseLights = x26d_26_modelsUseLights; ret->x26d_26_modelsUseLights = x26d_26_modelsUseLights;
ret->SetGlobalTranslation(xe8_globalTranslation); ret->SetGlobalTranslation(xe8_globalTranslation);
ret->SetGlobalOrientation(x22c_globalOrientation); ret->SetGlobalOrientation(x22c_globalOrientation);
@ -578,7 +578,7 @@ std::unique_ptr<CParticleGen> CElementGen::ConstructChildParticleSystem(const TT
ret->SetOrientation(x1d8_orientation); ret->SetOrientation(x1d8_orientation);
ret->SetParticleEmission(x88_particleEmission); ret->SetParticleEmission(x88_particleEmission);
ret->SetModulationColor(x338_moduColor); ret->SetModulationColor(x338_moduColor);
return std::unique_ptr<CParticleGen>(ret); return ret;
} }
void CElementGen::UpdateChildParticleSystems(double dt) { void CElementGen::UpdateChildParticleSystems(double dt) {

View File

@ -761,7 +761,7 @@ bool CParticleDataFactory::CreateGPSM(CGenDescription* fillDesc, CInputStream& i
FourCC cid = GetClassID(in); FourCC cid = GetClassID(in);
if (cid != SBIG('CNST')) if (cid != SBIG('CNST'))
break; break;
fillDesc->xd0_xbc_KSSM.reset(new CSpawnSystemKeyframeData(in)); fillDesc->xd0_xbc_KSSM = std::make_unique<CSpawnSystemKeyframeData>(in);
fillDesc->xd0_xbc_KSSM->LoadAllSpawnedSystemTokens(resPool); fillDesc->xd0_xbc_KSSM->LoadAllSpawnedSystemTokens(resPool);
break; break;
} }

View File

@ -20,10 +20,10 @@ CBomb::CBomb(const TCachedToken<CGenDescription>& particle1, const TCachedToken<
{EMaterialTypes::Projectile, EMaterialTypes::Bomb}, dInfo, EProjectileAttrib::Bombs, {EMaterialTypes::Projectile, EMaterialTypes::Bomb}, dInfo, EProjectileAttrib::Bombs,
CModelData::CModelDataNull()) CModelData::CModelDataNull())
, x17c_fuseTime(f1) , x17c_fuseTime(f1)
, x180_particle1( , x180_particle1(std::make_unique<CElementGen>(particle1, CElementGen::EModelOrientationType::Normal,
new CElementGen(particle1, CElementGen::EModelOrientationType::Normal, CElementGen::EOptionalSystemFlags::One)) CElementGen::EOptionalSystemFlags::One))
, x184_particle2( , x184_particle2(std::make_unique<CElementGen>(particle2, CElementGen::EModelOrientationType::Normal,
new CElementGen(particle2, CElementGen::EModelOrientationType::Normal, CElementGen::EOptionalSystemFlags::One)) CElementGen::EOptionalSystemFlags::One))
, x18c_particle2Obj(particle2.GetObj()) , x18c_particle2Obj(particle2.GetObj())
, x190_24_isNotDetonated(true) , x190_24_isNotDetonated(true)
, x190_25_beingDragged(false) , x190_25_beingDragged(false)

View File

@ -15,9 +15,9 @@ CElectricBeamProjectile::CElectricBeamProjectile(const TToken<CWeaponDescription
TAreaId areaId, TUniqueId owner, EProjectileAttrib attribs) TAreaId areaId, TUniqueId owner, EProjectileAttrib attribs)
: CBeamProjectile(wDesc, "ElectricBeamProjectile"sv, wType, xf, u32(elec.x8_maxLength), elec.xc_radius, : CBeamProjectile(wDesc, "ElectricBeamProjectile"sv, wType, xf, u32(elec.x8_maxLength), elec.xc_radius,
elec.x10_travelSpeed, matTypes, dInfo, uid, areaId, owner, attribs, false) elec.x10_travelSpeed, matTypes, dInfo, uid, areaId, owner, attribs, false)
, x468_electric(new CParticleElectric(elec.x0_electricDescription)) , x468_electric(std::make_unique<CParticleElectric>(elec.x0_electricDescription))
, x46c_genDescription(g_SimplePool->GetObj({SBIG('PART'), elec.x14_particleId})) , x46c_genDescription(g_SimplePool->GetObj({SBIG('PART'), elec.x14_particleId}))
, x478_elementGen(new CElementGen(x46c_genDescription)) , x478_elementGen(std::make_unique<CElementGen>(x46c_genDescription))
, x47c_(elec.x18_) , x47c_(elec.x18_)
, x488_(elec.x1c_) { , x488_(elec.x1c_) {
x478_elementGen->SetParticleEmission(false); x478_elementGen->SetParticleEmission(false);

View File

@ -24,7 +24,7 @@ CFlameThrower::CFlameThrower(const TToken<CWeaponDescription>& wDesc, std::strin
, x2e8_flameXf(xf) , x2e8_flameXf(xf)
, x338_(flameInfo.x10_) , x338_(flameInfo.x10_)
, x33c_flameDesc(g_SimplePool->GetObj({FOURCC('PART'), flameInfo.GetFlameFxId()})) , x33c_flameDesc(g_SimplePool->GetObj({FOURCC('PART'), flameInfo.GetFlameFxId()}))
, x348_flameGen(new CElementGen(x33c_flameDesc)) , x348_flameGen(std::make_unique<CElementGen>(x33c_flameDesc))
, x34c_flameWarp(176.f - float(flameInfo.GetLength()), xf.origin, bool(flameInfo.GetAttributes() & 0x4)) , x34c_flameWarp(176.f - float(flameInfo.GetLength()), xf.origin, bool(flameInfo.GetAttributes() & 0x4))
, x3f4_playerSteamTxtr(playerSteamTxtr) , x3f4_playerSteamTxtr(playerSteamTxtr)
, x3f8_playerHitSfx(playerHitSfx) , x3f8_playerHitSfx(playerHitSfx)
@ -80,7 +80,7 @@ void CFlameThrower::Fire(const zeus::CTransform&, CStateManager& mgr, bool) {
void CFlameThrower::CreateFlameParticles(CStateManager& mgr) { void CFlameThrower::CreateFlameParticles(CStateManager& mgr) {
DeleteProjectileLight(mgr); DeleteProjectileLight(mgr);
x348_flameGen.reset(new CElementGen(x33c_flameDesc)); x348_flameGen = std::make_unique<CElementGen>(x33c_flameDesc);
x348_flameGen->SetParticleEmission(true); x348_flameGen->SetParticleEmission(true);
x348_flameGen->SetZTest(x400_27_coneCollision); x348_flameGen->SetZTest(x400_27_coneCollision);
x348_flameGen->AddModifier(&x34c_flameWarp); x348_flameGen->AddModifier(&x34c_flameWarp);

View File

@ -107,7 +107,7 @@ void CPlayerGun::InitBombData() {
void CPlayerGun::InitMuzzleData() { void CPlayerGun::InitMuzzleData() {
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
x7c0_auxMuzzleEffects.push_back(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xa4_auxMuzzle[i]})); x7c0_auxMuzzleEffects.push_back(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xa4_auxMuzzle[i]}));
x800_auxMuzzleGenerators.emplace_back(new CElementGen(x7c0_auxMuzzleEffects.back())); x800_auxMuzzleGenerators.emplace_back(std::make_unique<CElementGen>(x7c0_auxMuzzleEffects.back()));
x800_auxMuzzleGenerators.back()->SetParticleEmission(false); x800_auxMuzzleGenerators.back()->SetParticleEmission(false);
} }
} }

View File

@ -24,7 +24,7 @@ CPowerBomb::CPowerBomb(const TToken<CGenDescription>& particle, TUniqueId uid, T
, x158_24_canStartFilter(true) , x158_24_canStartFilter(true)
, x158_25_filterEnabled(false) , x158_25_filterEnabled(false)
, x164_radiusIncrement(dInfo.GetRadius() / 2.5f) , x164_radiusIncrement(dInfo.GetRadius() / 2.5f)
, x168_particle(new CElementGen(particle)) , x168_particle(std::make_unique<CElementGen>(particle))
, x16c_radius(dInfo.GetRadius()) { , x16c_radius(dInfo.GetRadius()) {
x168_particle->SetGlobalTranslation(GetTranslation()); x168_particle->SetGlobalTranslation(GetTranslation());
} }

View File

@ -32,7 +32,7 @@ CActor::CActor(TUniqueId uid, bool active, std::string_view name, const CEntityI
, x68_material(MakeActorMaterialList(list, params)) , x68_material(MakeActorMaterialList(list, params))
, x70_materialFilter(CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {0ull})) , x70_materialFilter(CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {0ull}))
, xc6_nextDrawNode(otherUid) { , xc6_nextDrawNode(otherUid) {
x90_actorLights = mData.IsNull() ? std::unique_ptr<CActorLights>() : params.x0_lightParms.MakeActorLights(); x90_actorLights = mData.IsNull() ? nullptr : params.x0_lightParms.MakeActorLights();
if (mData.x10_animData || mData.x1c_normalModel) if (mData.x10_animData || mData.x1c_normalModel)
x64_modelData = std::make_unique<CModelData>(std::move(mData)); x64_modelData = std::make_unique<CModelData>(std::move(mData));
xd0_damageMag = params.x64_thermalMag; xd0_damageMag = params.x64_thermalMag;
@ -431,8 +431,9 @@ void CActor::CreateShadow(bool b) {
} }
void CActor::_CreateShadow() { void CActor::_CreateShadow() {
if (!x94_simpleShadow && x64_modelData && (x64_modelData->HasAnimData() || x64_modelData->HasNormalModel())) if (!x94_simpleShadow && x64_modelData && (x64_modelData->HasAnimData() || x64_modelData->HasNormalModel())) {
x94_simpleShadow.reset(new CSimpleShadow(1.f, 1.f, 20.f, 0.05f)); x94_simpleShadow = std::make_unique<CSimpleShadow>(1.f, 1.f, 20.f, 0.05f);
}
} }
void CActor::_CreateReflectionCube() { void CActor::_CreateReflectionCube() {

View File

@ -14,7 +14,7 @@ CFire::CFire(TToken<CGenDescription> effect, TUniqueId uid, TAreaId aId, bool ac
float f3, float f4) float f3, float f4)
: CActor(uid, active, "Fire"sv, CEntityInfo(aId, NullConnectionList), xf, CModelData::CModelDataNull(), : CActor(uid, active, "Fire"sv, CEntityInfo(aId, NullConnectionList), xf, CModelData::CModelDataNull(),
CMaterialList(EMaterialTypes::Projectile), CActorParameters::None(), owner) CMaterialList(EMaterialTypes::Projectile), CActorParameters::None(), owner)
, xe8_(new CElementGen(effect)) , xe8_(std::make_unique<CElementGen>(effect))
, xec_ownerId(owner) , xec_ownerId(owner)
, xf0_damageInfo(dInfo) , xf0_damageInfo(dInfo)
, x10c_damageInfo(dInfo) , x10c_damageInfo(dInfo)

View File

@ -50,10 +50,10 @@ CFishCloud::CFishCloud(TUniqueId uid, bool active, std::string_view name, const
x108_modifierSources.reserve(10); x108_modifierSources.reserve(10);
x250_25_worldSpace = true; // The result of a close_enough paradox (weird inlined test?) x250_25_worldSpace = true; // The result of a close_enough paradox (weird inlined test?)
if (aRes.GetId().IsValid()) { if (aRes.GetId().IsValid()) {
x1b0_models.emplace_back(new CModelData(aRes)); x1b0_models.emplace_back(std::make_unique<CModelData>(aRes));
x1b0_models.emplace_back(new CModelData(aRes)); x1b0_models.emplace_back(std::make_unique<CModelData>(aRes));
x1b0_models.emplace_back(new CModelData(aRes)); x1b0_models.emplace_back(std::make_unique<CModelData>(aRes));
x1b0_models.emplace_back(new CModelData(aRes)); x1b0_models.emplace_back(std::make_unique<CModelData>(aRes));
x250_27_validModel = true; x250_27_validModel = true;
} }
if (part1.IsValid()) if (part1.IsValid())
@ -65,7 +65,7 @@ CFishCloud::CFishCloud(TUniqueId uid, bool active, std::string_view name, const
if (part4.IsValid()) if (part4.IsValid())
x1c4_particleDescs.push_back(g_SimplePool->GetObj({FOURCC('PART'), part4})); x1c4_particleDescs.push_back(g_SimplePool->GetObj({FOURCC('PART'), part4}));
for (const auto& p : x1c4_particleDescs) { for (const auto& p : x1c4_particleDescs) {
x1f8_particleGens.emplace_back(new CElementGen(p)); x1f8_particleGens.emplace_back(std::make_unique<CElementGen>(p));
x1f8_particleGens.back()->SetParticleEmission(false); x1f8_particleGens.back()->SetParticleEmission(false);
} }
x21c_deathParticleCounts.push_back(partCount1); x21c_deathParticleCounts.push_back(partCount1);

View File

@ -72,18 +72,21 @@ public:
} }
std::unique_ptr<CActorLights> MakeActorLights() const { std::unique_ptr<CActorLights> MakeActorLights() const {
if (!x1c_makeLights) if (!x1c_makeLights) {
return {}; return nullptr;
}
u32 updateFrames = GetFramesBetweenRecalculation(x24_lightRecalcOpts); const u32 updateFrames = GetFramesBetweenRecalculation(x24_lightRecalcOpts);
CActorLights* lights = new CActorLights(updateFrames, x2c_actorPosBias, x38_maxDynamicLights, x3c_maxAreaLights, auto lights = std::make_unique<CActorLights>(updateFrames, x2c_actorPosBias, x38_maxDynamicLights,
x1d_ambientChannelOverflow, x28_layerIdx == 1, x3c_maxAreaLights, x1d_ambientChannelOverflow, x28_layerIdx == 1,
x20_worldLightingOptions == EWorldLightingOptions::DisableWorld, 0.1f); x20_worldLightingOptions == EWorldLightingOptions::DisableWorld, 0.1f);
if (x20_worldLightingOptions == EWorldLightingOptions::NoShadowCast) if (x20_worldLightingOptions == EWorldLightingOptions::NoShadowCast) {
lights->SetCastShadows(false); lights->SetCastShadows(false);
if (x3c_maxAreaLights == 0) }
if (x3c_maxAreaLights == 0) {
lights->SetAmbientColor(x18_noLightsAmbient); lights->SetAmbientColor(x18_noLightsAmbient);
return std::unique_ptr<CActorLights>(lights); }
return lights;
} }
const zeus::CColor& GetNoLightsAmbient() const { return x18_noLightsAmbient; } const zeus::CColor& GetNoLightsAmbient() const { return x18_noLightsAmbient; }
}; };

View File

@ -944,7 +944,7 @@ void CPatterned::BuildBodyController(EBodyType bodyType) {
if (x450_bodyController) if (x450_bodyController)
return; return;
x450_bodyController.reset(new CBodyController(*this, x3b8_turnSpeed, bodyType)); x450_bodyController = std::make_unique<CBodyController>(*this, x3b8_turnSpeed, bodyType);
auto anim = auto anim =
x450_bodyController->GetPASDatabase().FindBestAnimation(CPASAnimParmData(24, CPASAnimParm::FromEnum(0)), -1); x450_bodyController->GetPASDatabase().FindBestAnimation(CPASAnimParmData(24, CPASAnimParm::FromEnum(0)), -1);
x460_knockBackController.x81_26_enableShock = anim.first > 0.f; x460_knockBackController.x81_26_enableShock = anim.first > 0.f;

View File

@ -76,9 +76,9 @@ CPlayer::CPlayer(TUniqueId uid, const zeus::CTransform& xf, const zeus::CAABox&
, x2d8_fpBounds(aabb) , x2d8_fpBounds(aabb)
, x7d0_animRes(resId, 0, playerScale, 0, true) , x7d0_animRes(resId, 0, playerScale, 0, true)
, x7d8_beamScale(playerScale) { , x7d8_beamScale(playerScale) {
x490_gun.reset(new CPlayerGun(uid)); x490_gun = std::make_unique<CPlayerGun>(uid);
x49c_gunHolsterRemTime = g_tweakPlayerGun->GetGunNotFiringTime(); x49c_gunHolsterRemTime = g_tweakPlayerGun->GetGunNotFiringTime();
x4a0_failsafeTest.reset(new CFailsafeTest()); x4a0_failsafeTest = std::make_unique<CFailsafeTest>();
x76c_cameraBob.reset( x76c_cameraBob.reset(
new CPlayerCameraBob(CPlayerCameraBob::ECameraBobType::One, new CPlayerCameraBob(CPlayerCameraBob::ECameraBobType::One,
zeus::CVector2f{CPlayerCameraBob::kCameraBobExtentX, CPlayerCameraBob::kCameraBobExtentY}, zeus::CVector2f{CPlayerCameraBob::kCameraBobExtentX, CPlayerCameraBob::kCameraBobExtentY},
@ -90,7 +90,7 @@ CPlayer::CPlayer(TUniqueId uid, const zeus::CTransform& xf, const zeus::CAABox&
CAssetId beamId = g_tweakPlayerRes->GetBeamBallTransitionModel(x7ec_beam); CAssetId beamId = g_tweakPlayerRes->GetBeamBallTransitionModel(x7ec_beam);
x7f0_ballTransitionBeamModel = std::make_unique<CModelData>(CStaticRes(beamId, playerScale)); x7f0_ballTransitionBeamModel = std::make_unique<CModelData>(CStaticRes(beamId, playerScale));
x730_transitionModels.reserve(3); x730_transitionModels.reserve(3);
x768_morphball.reset(new CMorphBall(*this, ballRadius)); x768_morphball = std::make_unique<CMorphBall>(*this, ballRadius);
SetInertiaTensorScalar(xe8_mass); SetInertiaTensorScalar(xe8_mass);
x1f4_lastNonCollidingState = GetMotionState(); x1f4_lastNonCollidingState = GetMotionState();
@ -476,11 +476,12 @@ void CPlayer::UpdatePlayerSounds(float dt) {
void CPlayer::Update(float dt, CStateManager& mgr) { void CPlayer::Update(float dt, CStateManager& mgr) {
SetCoefficientOfRestitutionModifier(0.f); SetCoefficientOfRestitutionModifier(0.f);
UpdateMorphBallTransition(dt, mgr); UpdateMorphBallTransition(dt, mgr);
CPlayerState::EBeamId newBeam = mgr.GetPlayerState()->GetCurrentBeam();
const CPlayerState::EBeamId newBeam = mgr.GetPlayerState()->GetCurrentBeam();
if (newBeam != x7ec_beam) { if (newBeam != x7ec_beam) {
x7ec_beam = newBeam; x7ec_beam = newBeam;
x7f0_ballTransitionBeamModel.reset( x7f0_ballTransitionBeamModel = std::make_unique<CModelData>(
new CModelData(CStaticRes(g_tweakPlayerRes->GetBeamBallTransitionModel(x7ec_beam), x7d8_beamScale))); CStaticRes(g_tweakPlayerRes->GetBeamBallTransitionModel(x7ec_beam), x7d8_beamScale));
} }
if (!mgr.GetPlayerState()->IsPlayerAlive()) { if (!mgr.GetPlayerState()->IsPlayerAlive()) {
@ -662,9 +663,9 @@ void CPlayer::PostUpdate(float dt, CStateManager& mgr) {
float cameraBobT = 0.f; float cameraBobT = 0.f;
if (mgr.GetCameraManager()->IsInCinematicCamera()) { if (mgr.GetCameraManager()->IsInCinematicCamera()) {
zeus::CVector2f bobExtent(CPlayerCameraBob::kCameraBobExtentX, CPlayerCameraBob::kCameraBobExtentY); const zeus::CVector2f bobExtent(CPlayerCameraBob::kCameraBobExtentX, CPlayerCameraBob::kCameraBobExtentY);
x76c_cameraBob.reset( x76c_cameraBob = std::make_unique<CPlayerCameraBob>(CPlayerCameraBob::ECameraBobType::One, bobExtent,
new CPlayerCameraBob(CPlayerCameraBob::ECameraBobType::One, bobExtent, CPlayerCameraBob::kCameraBobPeriod)); CPlayerCameraBob::kCameraBobPeriod);
} else { } else {
cameraBobT = UpdateCameraBob(dt, mgr); cameraBobT = UpdateCameraBob(dt, mgr);
} }

View File

@ -43,8 +43,8 @@ void CScriptEMPulse::Think(float dt, CStateManager& mgr) {
void CScriptEMPulse::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) { void CScriptEMPulse::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) {
CActor::AcceptScriptMsg(msg, uid, mgr); CActor::AcceptScriptMsg(msg, uid, mgr);
if (msg == EScriptObjectMessage::Activate) { if (msg == EScriptObjectMessage::Activate) {
x114_particleGen.reset(new CElementGen(x108_particleDesc, CElementGen::EModelOrientationType::Normal, x114_particleGen = std::make_unique<CElementGen>(x108_particleDesc, CElementGen::EModelOrientationType::Normal,
CElementGen::EOptionalSystemFlags::One)); CElementGen::EOptionalSystemFlags::One);
x114_particleGen->SetOrientation(GetTransform().getRotation()); x114_particleGen->SetOrientation(GetTransform().getRotation());
x114_particleGen->SetGlobalTranslation(GetTranslation()); x114_particleGen->SetGlobalTranslation(GetTranslation());

View File

@ -54,7 +54,7 @@ CScriptEffect::CScriptEffect(TUniqueId uid, std::string_view name, const CEntity
if (partId.IsValid()) { if (partId.IsValid()) {
xf8_particleSystemToken = g_SimplePool->GetObj({FOURCC('PART'), partId}); xf8_particleSystemToken = g_SimplePool->GetObj({FOURCC('PART'), partId});
x104_particleSystem.reset(new CElementGen(xf8_particleSystemToken)); x104_particleSystem = std::make_unique<CElementGen>(xf8_particleSystemToken);
zeus::CTransform newXf = xf; zeus::CTransform newXf = xf;
newXf.origin = zeus::skZero3f; newXf.origin = zeus::skZero3f;
x104_particleSystem->SetOrientation(newXf); x104_particleSystem->SetOrientation(newXf);
@ -67,7 +67,7 @@ CScriptEffect::CScriptEffect(TUniqueId uid, std::string_view name, const CEntity
if (elscId.IsValid()) { if (elscId.IsValid()) {
xe8_electricToken = g_SimplePool->GetObj({FOURCC('ELSC'), elscId}); xe8_electricToken = g_SimplePool->GetObj({FOURCC('ELSC'), elscId});
xf4_electric.reset(new CParticleElectric(xe8_electricToken)); xf4_electric = std::make_unique<CParticleElectric>(xe8_electricToken);
zeus::CTransform newXf = xf; zeus::CTransform newXf = xf;
newXf.origin = zeus::skZero3f; newXf.origin = zeus::skZero3f;
xf4_electric->SetOrientation(newXf); xf4_electric->SetOrientation(newXf);
@ -87,9 +87,9 @@ void CScriptEffect::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CSt
case EScriptObjectMessage::Activate: case EScriptObjectMessage::Activate:
if (x110_26_rebuildSystemsOnActivate) { if (x110_26_rebuildSystemsOnActivate) {
if (x104_particleSystem) { if (x104_particleSystem) {
zeus::CVector3f scale = x104_particleSystem->GetGlobalScale(); const zeus::CVector3f scale = x104_particleSystem->GetGlobalScale();
zeus::CColor color = x104_particleSystem->GetModulationColor(); const zeus::CColor color = x104_particleSystem->GetModulationColor();
x104_particleSystem.reset(new CElementGen(xf8_particleSystemToken)); x104_particleSystem = std::make_unique<CElementGen>(xf8_particleSystemToken);
zeus::CTransform newXf = GetTransform(); zeus::CTransform newXf = GetTransform();
newXf.origin = zeus::skZero3f; newXf.origin = zeus::skZero3f;
x104_particleSystem->SetOrientation(newXf); x104_particleSystem->SetOrientation(newXf);
@ -101,9 +101,9 @@ void CScriptEffect::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CSt
} }
if (xf4_electric) { if (xf4_electric) {
zeus::CVector3f scale = xf4_electric->GetGlobalScale(); const zeus::CVector3f scale = xf4_electric->GetGlobalScale();
zeus::CColor color = xf4_electric->GetModulationColor(); const zeus::CColor color = xf4_electric->GetModulationColor();
xf4_electric.reset(new CParticleElectric(xe8_electricToken)); xf4_electric = std::make_unique<CParticleElectric>(xe8_electricToken);
zeus::CTransform newXf = GetTransform(); zeus::CTransform newXf = GetTransform();
newXf.origin = zeus::skZero3f; newXf.origin = zeus::skZero3f;
xf4_electric->SetOrientation(newXf); xf4_electric->SetOrientation(newXf);

View File

@ -125,12 +125,12 @@ CScriptGunTurret::CScriptGunTurret(TUniqueId uid, std::string_view name, ETurret
, x44c_panningEffectDesc(g_SimplePool->GetObj({SBIG('PART'), turretData.GetPanningEffectRes()})) { , x44c_panningEffectDesc(g_SimplePool->GetObj({SBIG('PART'), turretData.GetPanningEffectRes()})) {
if (turretData.GetVisorEffectRes().IsValid()) if (turretData.GetVisorEffectRes().IsValid())
x458_visorEffectDesc = g_SimplePool->GetObj({SBIG('PART'), turretData.GetVisorEffectRes()}); x458_visorEffectDesc = g_SimplePool->GetObj({SBIG('PART'), turretData.GetVisorEffectRes()});
x468_idleLight.reset(new CElementGen(x410_idleLightDesc)); x468_idleLight = std::make_unique<CElementGen>(x410_idleLightDesc);
x470_deactivateLight.reset(new CElementGen(x41c_deactivateLightDesc)); x470_deactivateLight = std::make_unique<CElementGen>(x41c_deactivateLightDesc);
x478_targettingLight.reset(new CElementGen(x428_targettingLightDesc)); x478_targettingLight = std::make_unique<CElementGen>(x428_targettingLightDesc);
x480_frozenEffect.reset(new CElementGen(x434_frozenEffectDesc)); x480_frozenEffect = std::make_unique<CElementGen>(x434_frozenEffectDesc);
x488_chargingEffect.reset(new CElementGen(x440_chargingEffectDesc)); x488_chargingEffect = std::make_unique<CElementGen>(x440_chargingEffectDesc);
x490_panningEffect.reset(new CElementGen(x44c_panningEffectDesc)); x490_panningEffect = std::make_unique<CElementGen>(x44c_panningEffectDesc);
x4fc_extensionOffset = xf.origin; x4fc_extensionOffset = xf.origin;
x514_lastFrontVector = xf.frontVector(); x514_lastFrontVector = xf.frontVector();
x544_originalFrontVec = xf.frontVector(); x544_originalFrontVec = xf.frontVector();
@ -330,8 +330,7 @@ void CScriptGunTurret::SetupCollisionManager(CStateManager& mgr) {
x508_gunSDKSeg, blastLCTR, 0.6f, 1.f, CJointCollisionDescription::EOrientationType::One, "Gun_SDK"sv, 1000.f)); x508_gunSDKSeg, blastLCTR, 0.6f, 1.f, CJointCollisionDescription::EOrientationType::One, "Gun_SDK"sv, 1000.f));
jointDescs.push_back(CJointCollisionDescription::SphereCollision(blastLCTR, 0.3f, "Blast_LCTR"sv, 1000.f)); jointDescs.push_back(CJointCollisionDescription::SphereCollision(blastLCTR, 0.3f, "Blast_LCTR"sv, 1000.f));
x49c_collisionManager.reset(new CCollisionActorManager(mgr, GetUniqueId(), GetAreaIdAlways(), jointDescs, true)); x49c_collisionManager = std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), jointDescs, true);
x49c_collisionManager->SetActive(mgr, GetActive()); x49c_collisionManager->SetActive(mgr, GetActive());
for (int i = 0; i < x49c_collisionManager->GetNumCollisionActors(); ++i) { for (int i = 0; i < x49c_collisionManager->GetNumCollisionActors(); ++i) {

View File

@ -78,16 +78,16 @@ CWallCrawlerSwarm::CWallCrawlerSwarm(TUniqueId uid, bool active, std::string_vie
CAnimRes launchAnimRes(animRes); CAnimRes launchAnimRes(animRes);
launchAnimRes.SetCanLoop(true); launchAnimRes.SetCanLoop(true);
launchAnimRes.SetDefaultAnim(launchAnim != -1 ? launchAnim : 0); launchAnimRes.SetDefaultAnim(launchAnim != -1 ? launchAnim : 0);
x4b0_modelDatas.emplace_back(new CModelData(animRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(animRes));
x4b0_modelDatas.emplace_back(new CModelData(animRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(animRes));
x4b0_modelDatas.emplace_back(new CModelData(animRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(animRes));
x4b0_modelDatas.emplace_back(new CModelData(animRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(animRes));
x4b0_modelDatas.emplace_back(new CModelData(attractAnimRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(attractAnimRes));
x4b0_modelDatas.emplace_back(new CModelData(attractAnimRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(attractAnimRes));
x4b0_modelDatas.emplace_back(new CModelData(attractAnimRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(attractAnimRes));
x4b0_modelDatas.emplace_back(new CModelData(attractAnimRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(attractAnimRes));
x4b0_modelDatas.emplace_back(new CModelData(launchAnimRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(launchAnimRes));
x4b0_modelDatas.emplace_back(new CModelData(animRes)); x4b0_modelDatas.emplace_back(std::make_unique<CModelData>(animRes));
if (aParams.GetXRayAssets().first.IsValid()) { if (aParams.GetXRayAssets().first.IsValid()) {
for (int i = 0; i < 9; ++i) for (int i = 0; i < 9; ++i)
x4b0_modelDatas[i]->SetXRayModel(aParams.GetXRayAssets()); x4b0_modelDatas[i]->SetXRayModel(aParams.GetXRayAssets());

View File

@ -384,7 +384,7 @@ void CWorldTransManager::EnableTransition(const CAnimRes& samusRes, CAssetId pla
x44_25_stopSoon = false; x44_25_stopSoon = false;
x44_26_goingUp = goingUp; x44_26_goingUp = goingUp;
x30_type = ETransType::Enabled; x30_type = ETransType::Enabled;
x4_modelData.reset(new SModelDatas(samusRes)); x4_modelData = std::make_unique<SModelDatas>(samusRes);
if (!m_reflectionCube[0] && hecl::com_cubemaps->toBoolean()) if (!m_reflectionCube[0] && hecl::com_cubemaps->toBoolean())
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) { CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
@ -437,11 +437,9 @@ void CWorldTransManager::EnableTransition(CAssetId fontId, CAssetId stringId, u3
x4_modelData.reset(); x4_modelData.reset();
x44_27_fadeWhite = fadeWhite; x44_27_fadeWhite = fadeWhite;
CGuiTextProperties props(false, true, EJustification::Center, EVerticalJustification::Center); const CGuiTextProperties props(false, true, EJustification::Center, EVerticalJustification::Center);
x8_textData.reset(new CGuiTextSupport(fontId, props, zeus::skWhite, zeus::skBlack, x8_textData = std::make_unique<CGuiTextSupport>(fontId, props, zeus::skWhite, zeus::skBlack, zeus::skWhite, 640, 448,
zeus::skWhite, 640, 448, g_SimplePool, g_SimplePool, CGuiWidget::EGuiModelDrawFlags::Additive);
CGuiWidget::EGuiModelDrawFlags::Additive));
x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate); x8_textData->SetTypeWriteEffectOptions(true, chFadeTime, chFadeRate);
xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId}); xc_strTable = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), stringId});
x8_textData->SetText(u""); x8_textData->SetText(u"");