Skip to content

Commit 6f3bd52

Browse files
moritz-hmoritz-h
committed
use short namespace aliases
1 parent d612e96 commit 6f3bd52

26 files changed

Lines changed: 138 additions & 121 deletions

‎map/src/MapWindow/AboutWindow.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -8,16 +8,16 @@
88
#include "Utils/ResourceUtils.h"
99

1010
namespace {
11-
using namespace Satisfactory3DMap;
11+
namespace m = Satisfactory3DMap;
1212

1313
void parseCopyright(std::map<std::string, std::string>& licenseMap) {
1414
const std::string copyrightDir("copyright");
15-
for (const auto& entry : resourceDirContent(copyrightDir)) {
15+
for (const auto& entry : m::resourceDirContent(copyrightDir)) {
1616
const auto entryDir = copyrightDir + "/" + entry;
1717
const auto nameFile = entryDir + "/name";
1818
const auto licenseFile = entryDir + "/copyright";
19-
std::string name = resourceExists(nameFile) ? getStringResource(nameFile) : "_error_";
20-
std::string license = resourceExists(licenseFile) ? getStringResource(licenseFile) : "_missing_";
19+
std::string name = m::resourceExists(nameFile) ? m::getStringResource(nameFile) : "_error_";
20+
std::string license = m::resourceExists(licenseFile) ? m::getStringResource(licenseFile) : "_missing_";
2121
licenseMap[name] = license;
2222
}
2323
}

‎map/src/MapWindow/Config/SettingsWindow.cpp‎

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -10,34 +10,37 @@
1010
namespace s = SatisfactorySave;
1111

1212
namespace {
13-
class SettingsRenderer : public Satisfactory3DMap::SettingVisitor {
14-
void visit(Satisfactory3DMap::BoolSetting& s) override {
13+
namespace m = Satisfactory3DMap;
14+
15+
class SettingsRenderer : public m::SettingVisitor {
16+
public:
17+
void visit(m::BoolSetting& s) override {
1518
bool v = s.getVal();
1619
ImGui::Checkbox(("##" + s.name()).c_str(), &v);
1720
s.setVal(v);
1821
}
1922

20-
void visit(Satisfactory3DMap::EnumSettingBase& s) override {
23+
void visit(m::EnumSettingBase& s) override {
2124
int item = static_cast<int>(s.getIdx());
2225
ImGui::Combo(("##" + s.name()).c_str(), &item, s.names().data(), static_cast<int>(s.names().size()));
2326
s.setIdx(static_cast<std::size_t>(item));
2427
}
2528

26-
void visit(Satisfactory3DMap::FloatSetting& s) override {
29+
void visit(m::FloatSetting& s) override {
2730
float v = s.getVal();
2831
ImGui::SliderFloat(("##" + s.name()).c_str(), &v, 0.0f, 1.0f);
2932
s.setVal(v);
3033
}
3134

32-
void visit(Satisfactory3DMap::PathSetting& s) override {
35+
void visit(m::PathSetting& s) override {
3336
std::filesystem::path v = s.getVal();
3437

3538
if (ImGui::Button("Select")) {
3639
std::optional<std::filesystem::path> result;
37-
if (s.getType() == Satisfactory3DMap::PathSetting::PathType::Directory) {
38-
result = Satisfactory3DMap::selectFolder("Select directory ...");
40+
if (s.getType() == m::PathSetting::PathType::Directory) {
41+
result = m::selectFolder("Select directory ...");
3942
} else {
40-
result = Satisfactory3DMap::openFile("Select file ...");
43+
result = m::openFile("Select file ...");
4144
}
4245
if (result.has_value()) {
4346
v = result.value();
@@ -55,7 +58,7 @@ namespace {
5558
s.setVal(v);
5659
}
5760

58-
void visit(Satisfactory3DMap::StringSetting& s) override {
61+
void visit(m::StringSetting& s) override {
5962
std::string v = s.getVal();
6063
ImGui::InputText(("##" + s.name()).c_str(), &v);
6164
s.setVal(v);

‎map/src/MapWindow/DataView/DataView.cpp‎

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,9 @@
88
#include "Utils/GLMUtil.h"
99

1010
namespace {
11-
void countAndSortObjects(Satisfactory3DMap::DataView::SaveNode& node) {
11+
namespace m = Satisfactory3DMap;
12+
13+
void countAndSortObjects(m::DataView::SaveNode& node) {
1214
node.numObjects = 0;
1315
node.numActors = 0;
1416
for (auto& child : node.childNodes) {
@@ -25,7 +27,7 @@ namespace {
2527
}
2628
}
2729
std::stable_sort(node.objects.begin(), node.objects.end(), [](const auto& a, const auto& b) {
28-
return SatisfactorySave::natLessCaseInsensitive(a->pathName(), b->pathName());
30+
return s::natLessCaseInsensitive(a->pathName(), b->pathName());
2931
});
3032
}
3133
}
@@ -43,7 +45,7 @@ namespace {
4345
static_assert(sizeof(SplineMeshInstanceGpu) == 4 * sizeof(int32_t) + 8 * sizeof(float),
4446
"SplineMeshInstanceGpu: Alignment issue!");
4547

46-
glm::vec3 deCasteljau(const Satisfactory3DMap::SplineSegmentGpu& segment, float t) {
48+
glm::vec3 deCasteljau(const m::SplineSegmentGpu& segment, float t) {
4749
// Bezier control points
4850
const glm::vec3 b0 = glm::vec3(segment.p0);
4951
const glm::vec3 b3 = glm::vec3(segment.p1);
@@ -63,7 +65,7 @@ namespace {
6365
}
6466

6567
glm::vec3 determineInstanceForward(float t0, float t1,
66-
const std::vector<Satisfactory3DMap::SplineSegmentGpu>& splineSegments, int32_t offset0, int32_t offset1) {
68+
const std::vector<m::SplineSegmentGpu>& splineSegments, int32_t offset0, int32_t offset1) {
6769
// Determine spline segments
6870
int segmentIdx0 = offset0;
6971
int segmentIdx1 = offset0;
@@ -77,8 +79,8 @@ namespace {
7779
t1 -= splineSegments[segmentIdx1].len;
7880
segmentIdx1++;
7981
}
80-
const Satisfactory3DMap::SplineSegmentGpu& segment0 = splineSegments[segmentIdx0];
81-
const Satisfactory3DMap::SplineSegmentGpu& segment1 = splineSegments[segmentIdx1];
82+
const m::SplineSegmentGpu& segment0 = splineSegments[segmentIdx0];
83+
const m::SplineSegmentGpu& segment1 = splineSegments[segmentIdx1];
8284

8385
const float segmentT0 = std::clamp(t0 / segment0.len, 0.0f, 1.0f);
8486
const float segmentT1 = std::clamp(t1 / segment1.len, 0.0f, 1.0f);
@@ -110,7 +112,7 @@ Satisfactory3DMap::DataView::DataView(std::shared_ptr<Configuration> config)
110112
if (usePakSetting_->getVal()) {
111113
if (!gameDirSetting_->getVal().empty()) {
112114
try {
113-
pakManager_ = SatisfactorySave::PakManager::create(gameDirSetting_->getVal());
115+
pakManager_ = s::PakManager::create(gameDirSetting_->getVal());
114116
} catch (const std::exception& ex) {
115117
spdlog::error("Error init PakManager: {}", ex.what());
116118
showErrors_.push_back(std::string("Error reading game dir: ") + ex.what());
@@ -148,7 +150,7 @@ void Satisfactory3DMap::DataView::openSave(const std::filesystem::path& file) {
148150
savegame_.reset();
149151

150152
try {
151-
savegame_ = std::make_unique<SatisfactorySave::SaveGame>(file);
153+
savegame_ = std::make_unique<s::SaveGame>(file);
152154
spdlog::info("Savegame header:\n{}", savegame_->mSaveHeader.toString());
153155

154156
// Generate proxy wrappers
@@ -170,7 +172,7 @@ void Satisfactory3DMap::DataView::openSave(const std::filesystem::path& file) {
170172
throw std::runtime_error("Expected only one object of type LightweightBuildableSubsystem!");
171173
}
172174
lightweight_buildable_subsystem_ =
173-
std::dynamic_pointer_cast<SatisfactorySave::AFGLightweightBuildableSubsystem>(lbs[0]->Object);
175+
std::dynamic_pointer_cast<s::AFGLightweightBuildableSubsystem>(lbs[0]->Object);
174176
}
175177
if (lightweight_buildable_subsystem_ != nullptr) {
176178
int32_t next_id = static_cast<int32_t>(proxy_list_.size());
@@ -343,7 +345,7 @@ void Satisfactory3DMap::DataView::addToNode(const ObjectProxyPtr& proxy, SaveNod
343345
// Store objects into a tree structure for access by class
344346
std::reference_wrapper<SaveNode> n = rootNode;
345347
std::reference_wrapper<SaveNode> a_n = all_root_node_;
346-
for (const auto& s : SatisfactorySave::splitPathName(proxy->className())) {
348+
for (const auto& s : s::splitPathName(proxy->className())) {
347349
n = n.get().childNodes[s];
348350
a_n = a_n.get().childNodes[s];
349351
}

‎map/src/MapWindow/DataView/DataView.h‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@
1818
#include "ModelManager.h"
1919
#include "ObjectProxy.h"
2020

21+
namespace s = SatisfactorySave;
22+
2123
namespace Satisfactory3DMap {
2224

2325
class DataView {
@@ -50,7 +52,7 @@ namespace Satisfactory3DMap {
5052
return savegame_ != nullptr;
5153
}
5254

53-
[[nodiscard]] inline const std::unique_ptr<SatisfactorySave::SaveGame>& saveGame() const {
55+
[[nodiscard]] inline const std::unique_ptr<s::SaveGame>& saveGame() const {
5456
return savegame_;
5557
}
5658

@@ -80,7 +82,7 @@ namespace Satisfactory3DMap {
8082
}
8183
}
8284

83-
void selectObject(const SatisfactorySave::SaveObjectPtr& obj) {
85+
void selectObject(const s::SaveObjectPtr& obj) {
8486
if (object_proxy_map_.contains(obj)) {
8587
selectedObject_ = object_proxy_map_.at(obj);
8688
} else {
@@ -106,7 +108,7 @@ namespace Satisfactory3DMap {
106108

107109
void updateActor(const ObjectProxyPtr& actorProxy);
108110

109-
[[nodiscard]] const std::shared_ptr<SatisfactorySave::PakManager>& pakManager() const {
111+
[[nodiscard]] const std::shared_ptr<s::PakManager>& pakManager() const {
110112
return pakManager_;
111113
}
112114

@@ -146,18 +148,18 @@ namespace Satisfactory3DMap {
146148
std::shared_ptr<BoolSetting> usePakSetting_;
147149
std::shared_ptr<PathSetting> gameDirSetting_;
148150

149-
std::shared_ptr<SatisfactorySave::PakManager> pakManager_;
151+
std::shared_ptr<s::PakManager> pakManager_;
150152
std::unique_ptr<ModelManager> manager_;
151153

152-
std::unique_ptr<SatisfactorySave::SaveGame> savegame_;
154+
std::unique_ptr<s::SaveGame> savegame_;
153155
ObjectProxyList proxy_list_;
154-
std::unordered_map<SatisfactorySave::SaveObjectPtr, ObjectProxyPtr> object_proxy_map_;
156+
std::unordered_map<s::SaveObjectPtr, ObjectProxyPtr> object_proxy_map_;
155157
ObjectProxyList lightweight_buildable_list_;
156158
std::vector<SaveNode> level_root_nodes_;
157159
SaveNode persistent_and_runtime_root_node_;
158160
SaveNode lightweight_buildable_root_node_;
159161
SaveNode all_root_node_;
160-
std::shared_ptr<SatisfactorySave::AFGLightweightBuildableSubsystem> lightweight_buildable_subsystem_;
162+
std::shared_ptr<s::AFGLightweightBuildableSubsystem> lightweight_buildable_subsystem_;
161163

162164
ObjectProxyPtr selectedObject_;
163165

‎map/src/MapWindow/DataView/MeshManager.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55

66
#include "../OpenGL/GlowlFactory.h"
77

8-
Satisfactory3DMap::MeshManager::MeshManager(std::shared_ptr<SatisfactorySave::PakManager> pakManager)
8+
Satisfactory3DMap::MeshManager::MeshManager(std::shared_ptr<s::PakManager> pakManager)
99
: pakManager_(std::move(pakManager)) {}
1010

1111
std::shared_ptr<glowl::Mesh> Satisfactory3DMap::MeshManager::loadMesh(std::string const& packageName,
@@ -31,7 +31,7 @@ std::shared_ptr<glowl::Mesh> Satisfactory3DMap::MeshManager::loadMesh(std::strin
3131
if (meshExport == nullptr) {
3232
throw std::runtime_error("Mesh export not found: " + std::to_string(publicExportHash));
3333
}
34-
auto mesh = dynamic_cast<SatisfactorySave::UStaticMesh*>(meshExport->Object.get());
34+
auto mesh = dynamic_cast<s::UStaticMesh*>(meshExport->Object.get());
3535

3636
auto gpuMesh = makeGlowlMesh(*mesh);
3737

‎map/src/MapWindow/DataView/MeshManager.h‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,16 +9,18 @@
99

1010
#include "SatisfactorySave/Pak/PakManager.h"
1111

12+
namespace s = SatisfactorySave;
13+
1214
namespace Satisfactory3DMap {
1315
class MeshManager {
1416
public:
15-
explicit MeshManager(std::shared_ptr<SatisfactorySave::PakManager> pakManager);
17+
explicit MeshManager(std::shared_ptr<s::PakManager> pakManager);
1618
~MeshManager() = default;
1719

1820
std::shared_ptr<glowl::Mesh> loadMesh(std::string const& packageName, uint64_t publicExportHash);
1921

2022
protected:
21-
std::shared_ptr<SatisfactorySave::PakManager> pakManager_;
23+
std::shared_ptr<s::PakManager> pakManager_;
2224

2325
std::unordered_map<std::string, std::shared_ptr<glowl::Mesh>> meshes_;
2426
};

‎map/src/MapWindow/DataView/ModelManager.cpp‎

Lines changed: 25 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@
1616

1717
#include "Utils/GLMUtil.h"
1818

19-
Satisfactory3DMap::ModelManager::ModelManager(std::shared_ptr<SatisfactorySave::PakManager> pakManager)
19+
Satisfactory3DMap::ModelManager::ModelManager(std::shared_ptr<s::PakManager> pakManager)
2020
: pakManager_(std::move(pakManager)) {
2121
meshManager_ = std::make_shared<MeshManager>(pakManager_);
2222

@@ -249,30 +249,29 @@ std::optional<int32_t> Satisfactory3DMap::ModelManager::findPakModel(const std::
249249
}
250250

251251
std::size_t Satisfactory3DMap::ModelManager::loadAsset(const std::string& className) {
252-
std::string assetName = SatisfactorySave::PakManager::classNameToAssetPath(className);
252+
std::string assetName = s::PakManager::classNameToAssetPath(className);
253253

254254
if (!pakManager_->containsAssetFilename(assetName)) {
255255
throw std::runtime_error("Asset missing: " + assetName);
256256
}
257257

258258
auto asset = pakManager_->readAsset(assetName);
259259

260-
const auto defaultObjectName = "Default__" + SatisfactorySave::PakManager::classNameToObjectName(className);
260+
const auto defaultObjectName = "Default__" + s::PakManager::classNameToObjectName(className);
261261
std::string defaultObjectParsingException;
262262
if (asset.hasExportMapEntry(defaultObjectName)) {
263263
const auto defaultObject = asset.getExportObjectByName(defaultObjectName);
264264

265265
try {
266-
const auto& instanceDataCDO =
267-
defaultObject->Object->Properties.get<SatisfactorySave::ObjectProperty>("mInstanceDataCDO");
266+
const auto& instanceDataCDO = defaultObject->Object->Properties.get<s::ObjectProperty>("mInstanceDataCDO");
268267
if (instanceDataCDO.Value.pakValue() < 1) {
269268
spdlog::error("Instance data pak index < 1!");
270269
throw std::runtime_error("Instance data pak index < 1!");
271270
}
272271

273272
const auto& instanceData = asset.getExportObjectByIdx(instanceDataCDO.Value.pakValue() - 1);
274-
const auto* instances = dynamic_cast<SatisfactorySave::StructArray*>(
275-
instanceData->Object->Properties.get<SatisfactorySave::ArrayProperty>("Instances").Value.get());
273+
const auto* instances = dynamic_cast<s::StructArray*>(
274+
instanceData->Object->Properties.get<s::ArrayProperty>("Instances").Value.get());
276275
if (instances == nullptr || instances->Values.empty()) {
277276
throw std::runtime_error("Instances not found or empty!");
278277
}
@@ -308,27 +307,27 @@ std::size_t Satisfactory3DMap::ModelManager::loadAsset(const std::string& classN
308307
auto buildingMeshProxy = asset.getExportObjectByIdx(buildingMeshProxyExportId);
309308
const auto& properties = buildingMeshProxy->Object->Properties;
310309

311-
SatisfactorySave::FObjectReferenceDisc objectReference;
310+
s::FObjectReferenceDisc objectReference;
312311
try {
313-
objectReference = properties.get<SatisfactorySave::ObjectProperty>("StaticMesh").Value;
312+
objectReference = properties.get<s::ObjectProperty>("StaticMesh").Value;
314313
} catch ([[maybe_unused]] const std::exception& e) {
315314
throw std::runtime_error("Asset does not have StaticMesh property: " + assetName);
316315
}
317316
auto mesh = readStaticMeshFromReference(asset, objectReference);
318317

319318
glm::mat4 translationMx(1.0f);
320319
try {
321-
const auto& locationStructProp = properties.get<SatisfactorySave::StructProperty>("RelativeLocation").Value;
322-
const auto* locationStruct = dynamic_cast<const SatisfactorySave::VectorStruct*>(locationStructProp.get());
320+
const auto& locationStructProp = properties.get<s::StructProperty>("RelativeLocation").Value;
321+
const auto* locationStruct = dynamic_cast<const s::VectorStruct*>(locationStructProp.get());
323322
if (locationStruct != nullptr) {
324323
translationMx = glm::translate(glm::mat4(1.0f), glmCast(locationStruct->Data));
325324
}
326325
} catch ([[maybe_unused]] const std::exception& e) {}
327326

328327
glm::mat4 rotationMx(1.0f);
329328
try {
330-
const auto& rotationStructProp = properties.get<SatisfactorySave::StructProperty>("RelativeRotation").Value;
331-
const auto* rotationStruct = dynamic_cast<const SatisfactorySave::RotatorStruct*>(rotationStructProp.get());
329+
const auto& rotationStructProp = properties.get<s::StructProperty>("RelativeRotation").Value;
330+
const auto* rotationStruct = dynamic_cast<const s::RotatorStruct*>(rotationStructProp.get());
332331
if (rotationStruct != nullptr) {
333332
rotationMx = glm::mat4_cast(glmCast(rotationStruct->Data.Quaternion()));
334333
}
@@ -341,8 +340,8 @@ std::size_t Satisfactory3DMap::ModelManager::loadAsset(const std::string& classN
341340
return num;
342341
}
343342

344-
std::shared_ptr<glowl::Mesh> Satisfactory3DMap::ModelManager::readStaticMeshFromReference(
345-
SatisfactorySave::AssetFile& asset, const SatisfactorySave::FObjectReferenceDisc& objectReference) {
343+
std::shared_ptr<glowl::Mesh> Satisfactory3DMap::ModelManager::readStaticMeshFromReference(s::AssetFile& asset,
344+
const s::FObjectReferenceDisc& objectReference) {
346345

347346
if (objectReference.pakValue() >= 0) {
348347
throw std::runtime_error("StaticMeshReference >= 0 not implemented!");
@@ -360,31 +359,30 @@ std::shared_ptr<glowl::Mesh> Satisfactory3DMap::ModelManager::readStaticMeshFrom
360359
}
361360

362361
Satisfactory3DMap::ModelManager::MeshInfo Satisfactory3DMap::ModelManager::getStaticMeshTransformFromStruct(
363-
SatisfactorySave::AssetFile& asset, const std::shared_ptr<SatisfactorySave::Struct>& instanceDataStruct) {
362+
s::AssetFile& asset, const std::shared_ptr<s::Struct>& instanceDataStruct) {
364363

365-
const auto* instanceData = dynamic_cast<SatisfactorySave::PropertyStruct*>(instanceDataStruct.get());
364+
const auto* instanceData = dynamic_cast<s::PropertyStruct*>(instanceDataStruct.get());
366365
if (instanceData == nullptr) {
367366
throw std::runtime_error("Unexpected type!");
368367
}
369368

370-
const auto& staticMeshRef = instanceData->Data.get<SatisfactorySave::ObjectProperty>("StaticMesh").Value;
369+
const auto& staticMeshRef = instanceData->Data.get<s::ObjectProperty>("StaticMesh").Value;
371370
auto mesh = readStaticMeshFromReference(asset, staticMeshRef);
372371

373372
glm::mat4 modelMx = glm::mat4(1.0f);
374373
try {
375-
const auto& relativeTransform = instanceData->Data.get<SatisfactorySave::StructProperty>("RelativeTransform");
376-
const auto* relativeTransformStruct =
377-
dynamic_cast<SatisfactorySave::PropertyStruct*>(relativeTransform.Value.get());
374+
const auto& relativeTransform = instanceData->Data.get<s::StructProperty>("RelativeTransform");
375+
const auto* relativeTransformStruct = dynamic_cast<s::PropertyStruct*>(relativeTransform.Value.get());
378376
if (relativeTransformStruct == nullptr) {
379377
throw std::runtime_error("Bad struct type!");
380378
}
381379

382-
const auto* Rotation = dynamic_cast<const SatisfactorySave::QuatStruct*>(
383-
relativeTransformStruct->Data.get<SatisfactorySave::StructProperty>("Rotation").Value.get());
384-
const auto* Translation = dynamic_cast<const SatisfactorySave::VectorStruct*>(
385-
relativeTransformStruct->Data.get<SatisfactorySave::StructProperty>("Translation").Value.get());
386-
const auto* Scale3D = dynamic_cast<const SatisfactorySave::VectorStruct*>(
387-
relativeTransformStruct->Data.get<SatisfactorySave::StructProperty>("Scale3D").Value.get());
380+
const auto* Rotation = dynamic_cast<const s::QuatStruct*>(
381+
relativeTransformStruct->Data.get<s::StructProperty>("Rotation").Value.get());
382+
const auto* Translation = dynamic_cast<const s::VectorStruct*>(
383+
relativeTransformStruct->Data.get<s::StructProperty>("Translation").Value.get());
384+
const auto* Scale3D = dynamic_cast<const s::VectorStruct*>(
385+
relativeTransformStruct->Data.get<s::StructProperty>("Scale3D").Value.get());
388386
if (Rotation == nullptr || Translation == nullptr || Scale3D == nullptr) {
389387
throw std::runtime_error("Bad struct types!");
390388
}

0 commit comments

Comments
 (0)