mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-18 04:23:20 +01:00
Code Issues Releases Wiki Activity

clang-format object

Browse Source
This commit is contained in:
clang-format
2018-06-22 23:03:20 +02:00
committed by Hielke Morsink
parent e32189fd98
commit a6a12af1ec
42 changed files with 1452 additions and 1283 deletions
Download Patch File Download Diff File Expand all files Collapse all files

287
src/openrct2/object/ObjectManager.cpp
View File

@@ -7,33 +7,34 @@
* OpenRCT2 is licensed under the GNU General Public License version 3.
*****************************************************************************/
#include "ObjectManager.h"
#include "../Context.h"
#include "../ParkImporter.h"
#include "../core/Console.hpp"
#include "../core/Memory.hpp"
#include "../localisation/StringIds.h"
#include "FootpathItemObject.h"
#include "LargeSceneryObject.h"
#include "Object.h"
#include "ObjectList.h"
#include "ObjectRepository.h"
#include "SceneryGroupObject.h"
#include "SmallSceneryObject.h"
#include "WallObject.h"
#include <algorithm>
#include <array>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_set>
#include "../Context.h"
#include "../core/Console.hpp"
#include "../core/Memory.hpp"
#include "../localisation/StringIds.h"
#include "../ParkImporter.h"
#include "FootpathItemObject.h"
#include "LargeSceneryObject.h"
#include "Object.h"
#include "ObjectManager.h"
#include "ObjectRepository.h"
#include "SceneryGroupObject.h"
#include "SmallSceneryObject.h"
#include "WallObject.h"
#include "ObjectList.h"
class ObjectManager final : public IObjectManager
{
private:
std::shared_ptr<IObjectRepository> _objectRepository;
std::vector<Object *> _loadedObjects;
std::vector<Object*> _loadedObjects;
public:
explicit ObjectManager(std::shared_ptr<IObjectRepository> objectRepository)
@@ -52,7 +53,7 @@ public:
UnloadAll();
}
Object * GetLoadedObject(size_t index) override
Object* GetLoadedObject(size_t index) override
{
if (index >= _loadedObjects.size())
{
@@ -61,7 +62,7 @@ public:
return _loadedObjects[index];
}
Object * GetLoadedObject(int32_t objectType, size_t index) override
Object* GetLoadedObject(int32_t objectType, size_t index) override
{
if (index >= (size_t)object_entry_group_counts[objectType])
{
@@ -75,10 +76,10 @@ public:
return GetLoadedObject(objectIndex);
}
Object * GetLoadedObject(const rct_object_entry * entry) override
Object* GetLoadedObject(const rct_object_entry* entry) override
{
Object * loadedObject = nullptr;
const ObjectRepositoryItem * ori = _objectRepository->FindObject(entry);
Object* loadedObject = nullptr;
const ObjectRepositoryItem* ori = _objectRepository->FindObject(entry);
if (ori != nullptr)
{
loadedObject = ori->LoadedObject;
@@ -86,7 +87,7 @@ public:
return loadedObject;
}
uint8_t GetLoadedObjectEntryIndex(const Object * object) override
uint8_t GetLoadedObjectEntryIndex(const Object* object) override
{
uint8_t result = UINT8_MAX;
size_t index = GetLoadedObjectIndex(object);
@@ -97,10 +98,10 @@ public:
return result;
}
Object * LoadObject(const rct_object_entry * entry) override
Object* LoadObject(const rct_object_entry* entry) override
{
Object * loadedObject = nullptr;
const ObjectRepositoryItem * ori = _objectRepository->FindObject(entry);
Object* loadedObject = nullptr;
const ObjectRepositoryItem* ori = _objectRepository->FindObject(entry);
if (ori != nullptr)
{
loadedObject = ori->LoadedObject;
@@ -127,7 +128,7 @@ public:
return loadedObject;
}
void LoadObjects(const rct_object_entry * entries, size_t count) override
void LoadObjects(const rct_object_entry* entries, size_t count) override
{
// Find all the required objects
auto requiredObjects = GetRequiredObjects(entries, count);
@@ -143,7 +144,7 @@ public:
log_verbose("%u / %u new objects loaded", numNewLoadedObjects, requiredObjects.size());
}
void UnloadObjects(const rct_object_entry * entries, size_t count) override
void UnloadObjects(const rct_object_entry* entries, size_t count) override
{
// TODO there are two performance issues here:
// - FindObject for every entry which is a dictionary lookup
@@ -152,11 +153,11 @@ public:
size_t numObjectsUnloaded = 0;
for (size_t i = 0; i < count; i++)
{
const rct_object_entry * entry = &entries[i];
const ObjectRepositoryItem * ori = _objectRepository->FindObject(entry);
const rct_object_entry* entry = &entries[i];
const ObjectRepositoryItem* ori = _objectRepository->FindObject(entry);
if (ori != nullptr)
{
Object * loadedObject = ori->LoadedObject;
Object* loadedObject = ori->LoadedObject;
if (loadedObject != nullptr)
{
UnloadObject(loadedObject);
@@ -196,16 +197,14 @@ public:
ResetTypeToRideEntryIndexMap();
}
std::vector<const ObjectRepositoryItem *> GetPackableObjects() override
std::vector<const ObjectRepositoryItem*> GetPackableObjects() override
{
std::vector<const ObjectRepositoryItem *> objects;
std::vector<const ObjectRepositoryItem*> objects;
size_t numObjects = _objectRepository->GetNumObjects();
for (size_t i = 0; i < numObjects; i++)
{
const ObjectRepositoryItem * item = &_objectRepository->GetObjects()[i];
if (item->LoadedObject != nullptr &&
item->LoadedObject->GetLegacyData() != nullptr &&
IsObjectCustom(item))
const ObjectRepositoryItem* item = &_objectRepository->GetObjects()[i];
if (item->LoadedObject != nullptr && item->LoadedObject->GetLegacyData() != nullptr && IsObjectCustom(item))
{
objects.push_back(item);
}
@@ -219,31 +218,31 @@ public:
// loaded RCT1 and RCT2 save files.
}
static rct_string_id GetObjectSourceGameString(const rct_object_entry * entry)
static rct_string_id GetObjectSourceGameString(const rct_object_entry* entry)
{
switch (object_entry_get_source_game(entry))
{
case OBJECT_SOURCE_RCT1:
return STR_SCENARIO_CATEGORY_RCT1;
case OBJECT_SOURCE_ADDED_ATTRACTIONS:
return STR_SCENARIO_CATEGORY_RCT1_AA;
case OBJECT_SOURCE_LOOPY_LANDSCAPES:
return STR_SCENARIO_CATEGORY_RCT1_LL;
case OBJECT_SOURCE_RCT2:
return STR_ROLLERCOASTER_TYCOON_2_DROPDOWN;
case OBJECT_SOURCE_WACKY_WORLDS:
return STR_OBJECT_FILTER_WW;
case OBJECT_SOURCE_TIME_TWISTER:
return STR_OBJECT_FILTER_TT;
case OBJECT_SOURCE_OPENRCT2_OFFICIAL:
return STR_OBJECT_FILTER_OPENRCT2_OFFICIAL;
default:
return STR_OBJECT_FILTER_CUSTOM;
case OBJECT_SOURCE_RCT1:
return STR_SCENARIO_CATEGORY_RCT1;
case OBJECT_SOURCE_ADDED_ATTRACTIONS:
return STR_SCENARIO_CATEGORY_RCT1_AA;
case OBJECT_SOURCE_LOOPY_LANDSCAPES:
return STR_SCENARIO_CATEGORY_RCT1_LL;
case OBJECT_SOURCE_RCT2:
return STR_ROLLERCOASTER_TYCOON_2_DROPDOWN;
case OBJECT_SOURCE_WACKY_WORLDS:
return STR_OBJECT_FILTER_WW;
case OBJECT_SOURCE_TIME_TWISTER:
return STR_OBJECT_FILTER_TT;
case OBJECT_SOURCE_OPENRCT2_OFFICIAL:
return STR_OBJECT_FILTER_OPENRCT2_OFFICIAL;
default:
return STR_OBJECT_FILTER_CUSTOM;
}
}
private:
Object * LoadObject(const std::string &name)
Object* LoadObject(const std::string& name)
{
rct_object_entry entry{};
std::copy_n(name.c_str(), 8, entry.name);
@@ -269,7 +268,7 @@ private:
return -1;
}
size_t GetLoadedObjectIndex(const Object * object)
size_t GetLoadedObjectIndex(const Object* object)
{
Guard::ArgumentNotNull(object, GUARD_LINE);
@@ -282,7 +281,7 @@ private:
return result;
}
void SetNewLoadedObjectList(const std::vector<Object *> &newLoadedObjects)
void SetNewLoadedObjectList(const std::vector<Object*>& newLoadedObjects)
{
if (newLoadedObjects.size() == 0)
{
@@ -295,12 +294,12 @@ private:
_loadedObjects = newLoadedObjects;
}
void UnloadObject(Object * object)
void UnloadObject(Object* object)
{
if (object != nullptr)
{
// TODO try to prevent doing a repository search
const ObjectRepositoryItem * ori = _objectRepository->FindObject(object->GetObjectEntry());
const ObjectRepositoryItem* ori = _objectRepository->FindObject(object->GetObjectEntry());
if (ori != nullptr)
{
_objectRepository->UnregisterLoadedObject(ori, object);
@@ -308,7 +307,7 @@ private:
// Because it's possible to have the same loaded object for multiple
// slots, we have to make sure find and set all of them to nullptr
for (auto &obj : _loadedObjects)
for (auto& obj : _loadedObjects)
{
if (obj == object)
{
@@ -321,10 +320,10 @@ private:
}
}
void UnloadObjectsExcept(const std::vector<Object *> &newLoadedObjects)
void UnloadObjectsExcept(const std::vector<Object*>& newLoadedObjects)
{
// Build a hash set for quick checking
auto exceptSet = std::unordered_set<Object *>();
auto exceptSet = std::unordered_set<Object*>();
for (auto object : newLoadedObjects)
{
if (object != nullptr)
@@ -358,32 +357,33 @@ private:
{
if (loadedObject != nullptr)
{
rct_scenery_entry * sceneryEntry;
switch (loadedObject->GetObjectType()) {
case OBJECT_TYPE_SMALL_SCENERY:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->small_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_LARGE_SCENERY:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->large_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_WALLS:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->wall.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_BANNERS:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->banner.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_PATH_BITS:
sceneryEntry = (rct_scenery_entry *)loadedObject->GetLegacyData();
sceneryEntry->path_bit.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_SCENERY_GROUP:
auto sgObject = dynamic_cast<SceneryGroupObject *>(loadedObject);
sgObject->UpdateEntryIndexes();
break;
rct_scenery_entry* sceneryEntry;
switch (loadedObject->GetObjectType())
{
case OBJECT_TYPE_SMALL_SCENERY:
sceneryEntry = (rct_scenery_entry*)loadedObject->GetLegacyData();
sceneryEntry->small_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_LARGE_SCENERY:
sceneryEntry = (rct_scenery_entry*)loadedObject->GetLegacyData();
sceneryEntry->large_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_WALLS:
sceneryEntry = (rct_scenery_entry*)loadedObject->GetLegacyData();
sceneryEntry->wall.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_BANNERS:
sceneryEntry = (rct_scenery_entry*)loadedObject->GetLegacyData();
sceneryEntry->banner.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_PATH_BITS:
sceneryEntry = (rct_scenery_entry*)loadedObject->GetLegacyData();
sceneryEntry->path_bit.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject);
break;
case OBJECT_TYPE_SCENERY_GROUP:
auto sgObject = dynamic_cast<SceneryGroupObject*>(loadedObject);
sgObject->UpdateEntryIndexes();
break;
}
}
}
@@ -393,11 +393,11 @@ private:
window_close_by_class(WC_SCENERY);
}
uint8_t GetPrimarySceneryGroupEntryIndex(Object * loadedObject)
uint8_t GetPrimarySceneryGroupEntryIndex(Object* loadedObject)
{
auto sceneryObject = dynamic_cast<SceneryObject *>(loadedObject);
const rct_object_entry * primarySGEntry = sceneryObject->GetPrimarySceneryGroup();
Object * sgObject = GetLoadedObject(primarySGEntry);
auto sceneryObject = dynamic_cast<SceneryObject*>(loadedObject);
const rct_object_entry* primarySGEntry = sceneryObject->GetPrimarySceneryGroup();
Object* sgObject = GetLoadedObject(primarySGEntry);
uint8_t entryIndex = 255;
if (sgObject != nullptr)
@@ -409,21 +409,21 @@ private:
rct_object_entry* DuplicateObjectEntry(const rct_object_entry* original)
{
rct_object_entry * duplicate = Memory::Allocate<rct_object_entry>(sizeof(rct_object_entry));
rct_object_entry* duplicate = Memory::Allocate<rct_object_entry>(sizeof(rct_object_entry));
duplicate->checksum = original->checksum;
strncpy(duplicate->name, original->name, 8);
duplicate->flags = original->flags;
return duplicate;
}
std::vector<rct_object_entry> GetInvalidObjects(const rct_object_entry * entries) override
std::vector<rct_object_entry> GetInvalidObjects(const rct_object_entry* entries) override
{
std::vector<rct_object_entry> invalidEntries;
invalidEntries.reserve(OBJECT_ENTRY_COUNT);
for (int32_t i = 0; i < OBJECT_ENTRY_COUNT; i++)
{
auto entry = entries[i];
const ObjectRepositoryItem * ori = nullptr;
const ObjectRepositoryItem* ori = nullptr;
if (object_entry_is_empty(&entry))
{
entry = {};
@@ -447,7 +447,7 @@ private:
}
else
{
Object * loadedObject = nullptr;
Object* loadedObject = nullptr;
loadedObject = ori->LoadedObject;
if (loadedObject == nullptr)
{
@@ -464,15 +464,15 @@ private:
return invalidEntries;
}
std::vector<const ObjectRepositoryItem *> GetRequiredObjects(const rct_object_entry * entries, size_t count)
std::vector<const ObjectRepositoryItem*> GetRequiredObjects(const rct_object_entry* entries, size_t count)
{
std::vector<const ObjectRepositoryItem *> requiredObjects;
std::vector<const ObjectRepositoryItem*> requiredObjects;
std::vector<rct_object_entry> missingObjects;
for (size_t i = 0; i < count; i++)
{
const rct_object_entry * entry = &entries[i];
const ObjectRepositoryItem * ori = nullptr;
const rct_object_entry* entry = &entries[i];
const ObjectRepositoryItem* ori = nullptr;
if (!object_entry_is_empty(entry))
{
ori = _objectRepository->FindObject(entry);
@@ -493,8 +493,7 @@ private:
return requiredObjects;
}
template<typename T, typename TFunc>
static void ParallelFor(const std::vector<T>& items, TFunc func)
template<typename T, typename TFunc> static void ParallelFor(const std::vector<T>& items, TFunc func)
{
auto partitions = std::thread::hardware_concurrency();
auto partitionSize = (items.size() + (partitions - 1)) / partitions;
@@ -504,8 +503,7 @@ private:
auto begin = n * partitionSize;
auto end = std::min(items.size(), begin + partitionSize);
threads.emplace_back(
[func](size_t pbegin, size_t pend)
{
[func](size_t pbegin, size_t pend) {
for (size_t i = pbegin; i < pend; i++)
{
func(i);
@@ -520,45 +518,42 @@ private:
}
}
std::vector<Object *> LoadObjects(std::vector<const ObjectRepositoryItem *> &requiredObjects, size_t * outNewObjectsLoaded)
std::vector<Object*> LoadObjects(std::vector<const ObjectRepositoryItem*>& requiredObjects, size_t* outNewObjectsLoaded)
{
std::vector<Object *> objects;
std::vector<Object *> loadedObjects;
std::vector<Object*> objects;
std::vector<Object*> loadedObjects;
std::vector<rct_object_entry> badObjects;
objects.resize(OBJECT_ENTRY_COUNT);
loadedObjects.reserve(OBJECT_ENTRY_COUNT);
// Read objects
std::mutex commonMutex;
ParallelFor(
requiredObjects,
[this, &commonMutex, requiredObjects, &objects, &badObjects, &loadedObjects](size_t i)
ParallelFor(requiredObjects, [this, &commonMutex, requiredObjects, &objects, &badObjects, &loadedObjects](size_t i) {
auto ori = requiredObjects[i];
Object* loadedObject = nullptr;
if (ori != nullptr)
{
auto ori = requiredObjects[i];
Object * loadedObject = nullptr;
if (ori != nullptr)
loadedObject = ori->LoadedObject;
if (loadedObject == nullptr)
{
loadedObject = ori->LoadedObject;
loadedObject = _objectRepository->LoadObject(ori);
if (loadedObject == nullptr)
{
loadedObject = _objectRepository->LoadObject(ori);
if (loadedObject == nullptr)
{
std::lock_guard<std::mutex> guard(commonMutex);
badObjects.push_back(ori->ObjectEntry);
ReportObjectLoadProblem(&ori->ObjectEntry);
}
else
{
std::lock_guard<std::mutex> guard(commonMutex);
loadedObjects.push_back(loadedObject);
// Connect the ori to the registered object
_objectRepository->RegisterLoadedObject(ori, loadedObject);
}
std::lock_guard<std::mutex> guard(commonMutex);
badObjects.push_back(ori->ObjectEntry);
ReportObjectLoadProblem(&ori->ObjectEntry);
}
else
{
std::lock_guard<std::mutex> guard(commonMutex);
loadedObjects.push_back(loadedObject);
// Connect the ori to the registered object
_objectRepository->RegisterLoadedObject(ori, loadedObject);
}
}
objects[i] = loadedObject;
});
}
objects[i] = loadedObject;
});
// Load objects
for (auto obj : loadedObjects)
@@ -583,9 +578,9 @@ private:
return objects;
}
Object * GetOrLoadObject(const ObjectRepositoryItem * ori)
Object* GetOrLoadObject(const ObjectRepositoryItem* ori)
{
Object * loadedObject = ori->LoadedObject;
Object* loadedObject = ori->LoadedObject;
if (loadedObject == nullptr)
{
// Try to load object
@@ -606,14 +601,14 @@ private:
reset_type_to_ride_entry_index_map(*this);
}
static void ReportMissingObject(const rct_object_entry * entry)
static void ReportMissingObject(const rct_object_entry* entry)
{
utf8 objName[DAT_NAME_LENGTH + 1] = { 0 };
std::copy_n(entry->name, DAT_NAME_LENGTH, objName);
Console::Error::WriteLine("[%s] Object not found.", objName);
}
void ReportObjectLoadProblem(const rct_object_entry * entry)
void ReportObjectLoadProblem(const rct_object_entry* entry)
{
utf8 objName[DAT_NAME_LENGTH + 1] = { 0 };
std::copy_n(entry->name, DAT_NAME_LENGTH, objName);
@@ -637,36 +632,36 @@ std::unique_ptr<IObjectManager> CreateObjectManager(std::shared_ptr<IObjectRepos
return std::make_unique<ObjectManager>(objectRepository);
}
void * object_manager_get_loaded_object_by_index(size_t index)
void* object_manager_get_loaded_object_by_index(size_t index)
{
auto objectManager = OpenRCT2::GetContext()->GetObjectManager();
Object * loadedObject = objectManager->GetLoadedObject(index);
return (void *)loadedObject;
Object* loadedObject = objectManager->GetLoadedObject(index);
return (void*)loadedObject;
}
void * object_manager_get_loaded_object(const rct_object_entry * entry)
void* object_manager_get_loaded_object(const rct_object_entry* entry)
{
auto objectManager = OpenRCT2::GetContext()->GetObjectManager();
Object * loadedObject = objectManager->GetLoadedObject(entry);
return (void *)loadedObject;
Object* loadedObject = objectManager->GetLoadedObject(entry);
return (void*)loadedObject;
}
uint8_t object_manager_get_loaded_object_entry_index(const void * loadedObject)
uint8_t object_manager_get_loaded_object_entry_index(const void* loadedObject)
{
auto objectManager = OpenRCT2::GetContext()->GetObjectManager();
const Object * object = static_cast<const Object *>(loadedObject);
const Object* object = static_cast<const Object*>(loadedObject);
uint8_t entryIndex = objectManager->GetLoadedObjectEntryIndex(object);
return entryIndex;
}
void * object_manager_load_object(const rct_object_entry * entry)
void* object_manager_load_object(const rct_object_entry* entry)
{
auto objectManager = OpenRCT2::GetContext()->GetObjectManager();
Object * loadedObject = objectManager->LoadObject(entry);
return (void *)loadedObject;
Object* loadedObject = objectManager->LoadObject(entry);
return (void*)loadedObject;
}
void object_manager_unload_objects(const rct_object_entry * entries, size_t count)
void object_manager_unload_objects(const rct_object_entry* entries, size_t count)
{
auto objectManager = OpenRCT2::GetContext()->GetObjectManager();
objectManager->UnloadObjects(entries, count);
@@ -681,7 +676,7 @@ void object_manager_unload_all_objects()
}
}
rct_string_id object_manager_get_source_game_string(const rct_object_entry * entry)
rct_string_id object_manager_get_source_game_string(const rct_object_entry* entry)
{
return ObjectManager::GetObjectSourceGameString(entry);
}