diff --git a/src/openrct2-ui/interface/LandTool.cpp b/src/openrct2-ui/interface/LandTool.cpp
index 9ef4ddfbf1..194fbcdf3a 100644
--- a/src/openrct2-ui/interface/LandTool.cpp
+++ b/src/openrct2-ui/interface/LandTool.cpp
@@ -64,7 +64,7 @@ void LandTool::ShowSurfaceStyleDropdown(rct_window* w, rct_widget* widget, uint8
     auto itemIndex = 0;
     for (size_t i = 0; i < MAX_TERRAIN_SURFACE_OBJECTS; i++)
     {
-        const auto surfaceObj = static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, i));
+        const auto surfaceObj = static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(ObjectType::TerrainSurface, i));
         if (surfaceObj != nullptr)
         {
             gDropdownItemsFormat[itemIndex] = Dropdown::FormatLandPicker;
@@ -97,7 +97,7 @@ void LandTool::ShowEdgeStyleDropdown(rct_window* w, rct_widget* widget, uint8_t
     auto itemIndex = 0;
     for (size_t i = 0; i < MAX_TERRAIN_EDGE_OBJECTS; i++)
     {
-        const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, i));
+        const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, i));
         if (edgeObj != nullptr && edgeObj->NumImagesLoaded > 1)
         {
             gDropdownItemsFormat[itemIndex] = Dropdown::FormatLandPicker;
diff --git a/src/openrct2-ui/windows/EditorInventionsList.cpp b/src/openrct2-ui/windows/EditorInventionsList.cpp
index 63be5a79a3..e174b48eac 100644
--- a/src/openrct2-ui/windows/EditorInventionsList.cpp
+++ b/src/openrct2-ui/windows/EditorInventionsList.cpp
@@ -126,7 +126,7 @@ static void move_research_item(ResearchItem* beforeItem, int32_t scrollIndex);
 static void research_rides_setup()
 {
     // Reset all objects to not required
-    for (uint8_t objectType = OBJECT_TYPE_RIDE; objectType < OBJECT_TYPE_COUNT; objectType++)
+    for (uint8_t objectType = ObjectType::Ride; objectType < ObjectType::Count; objectType++)
     {
         auto maxObjects = object_entry_group_counts[objectType];
         for (int32_t i = 0; i < maxObjects; i++)
@@ -138,7 +138,7 @@ static void research_rides_setup()
     // Set research required for rides in use
     for (const auto& ride : GetRideManager())
     {
-        Editor::SetSelectedObject(OBJECT_TYPE_RIDE, ride.subtype, OBJECT_SELECTION_FLAG_SELECTED);
+        Editor::SetSelectedObject(ObjectType::Ride, ride.subtype, OBJECT_SELECTION_FLAG_SELECTED);
     }
 }
 
@@ -531,9 +531,9 @@ static void window_editor_inventions_list_paint(rct_window* w, rct_drawpixelinfo
         return;
 
     // Preview image
-    int32_t objectEntryType = OBJECT_TYPE_SCENERY_GROUP;
+    int32_t objectEntryType = ObjectType::SceneryGroup;
     if (researchItem->type == Research::EntryType::Ride)
-        objectEntryType = OBJECT_TYPE_RIDE;
+        objectEntryType = ObjectType::Ride;
 
     auto chunk = object_entry_get_chunk(objectEntryType, researchItem->entryIndex);
     if (chunk == nullptr)
diff --git a/src/openrct2-ui/windows/EditorObjectSelection.cpp b/src/openrct2-ui/windows/EditorObjectSelection.cpp
index 05cd8b98f0..8f22e05b0f 100644
--- a/src/openrct2-ui/windows/EditorObjectSelection.cpp
+++ b/src/openrct2-ui/windows/EditorObjectSelection.cpp
@@ -64,7 +64,7 @@ enum
 static constexpr uint8_t _numSourceGameItems = 8;
 
 static uint32_t _filter_flags;
-static uint16_t _filter_object_counts[OBJECT_TYPE_COUNT];
+static uint16_t _filter_object_counts[ObjectType::Count];
 
 static char _filter_string[MAX_PATH];
 
@@ -871,7 +871,7 @@ static void window_editor_object_selection_invalidate(rct_window* w)
     w->widgets[WIDX_PREVIEW].right = w->widgets[WIDX_PREVIEW].left + 113;
     w->widgets[WIDX_FILTER_RIDE_TAB_FRAME].right = w->widgets[WIDX_LIST].right;
 
-    bool ridePage = (get_selected_object_type(w) == OBJECT_TYPE_RIDE);
+    bool ridePage = (get_selected_object_type(w) == ObjectType::Ride);
     w->widgets[WIDX_LIST].top = (ridePage ? 118 : 60);
     w->widgets[WIDX_FILTER_TEXT_BOX].right = w->widgets[WIDX_LIST].right - 77;
     w->widgets[WIDX_FILTER_TEXT_BOX].top = (ridePage ? 79 : 45);
@@ -965,7 +965,7 @@ static void window_editor_object_selection_paint(rct_window* w, rct_drawpixelinf
     const int32_t ThrillRidesTabAnimationSequence[] = { 5, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0 };
 
     // Draw ride tabs
-    if (get_selected_object_type(w) == OBJECT_TYPE_RIDE)
+    if (get_selected_object_type(w) == ObjectType::Ride)
     {
         for (int32_t i = 0; i < 7; i++)
         {
@@ -1078,7 +1078,7 @@ static void window_editor_object_selection_paint(rct_window* w, rct_drawpixelinf
     auto screenPos = w->windowPos + ScreenCoordsXY{ w->width - 5, w->height - (LIST_ROW_HEIGHT * 5) };
 
     // Draw ride type.
-    if (get_selected_object_type(w) == OBJECT_TYPE_RIDE)
+    if (get_selected_object_type(w) == ObjectType::Ride)
     {
         auto stringId = get_ride_type_string_id(listItem->repositoryItem);
         DrawTextBasic(dpi, screenPos, stringId, {}, COLOUR_WHITE, TextAlignment::RIGHT);
@@ -1131,7 +1131,7 @@ static void window_editor_object_selection_scrollpaint(rct_window* w, rct_drawpi
     int32_t colour, colour2;
     ScreenCoordsXY screenCoords;
 
-    bool ridePage = (get_selected_object_type(w) == OBJECT_TYPE_RIDE);
+    bool ridePage = (get_selected_object_type(w) == ObjectType::Ride);
 
     uint8_t paletteIndex = ColourMapA[w->colours[1]].mid_light;
     gfx_clear(dpi, paletteIndex);
@@ -1224,7 +1224,7 @@ static void window_editor_object_set_page(rct_window* w, int32_t page)
     w->scrolls[0].v_top = 0;
     w->frame_no = 0;
 
-    if (page == OBJECT_TYPE_RIDE)
+    if (page == ObjectType::Ride)
     {
         _listSortType = RIDE_SORT_TYPE;
         _listSortDescending = false;
@@ -1277,7 +1277,7 @@ static void window_editor_object_selection_manage_tracks()
     gS6Info.editor_step = EDITOR_STEP_TRACK_DESIGNS_MANAGER;
 
     int32_t entry_index = 0;
-    for (; object_entry_get_chunk(OBJECT_TYPE_RIDE, entry_index) == nullptr; entry_index++)
+    for (; object_entry_get_chunk(ObjectType::Ride, entry_index) == nullptr; entry_index++)
         ;
 
     rct_ride_entry* ride_entry = get_ride_entry(entry_index);
@@ -1316,14 +1316,14 @@ static void editor_load_selected_objects()
                     // Defaults selected items to researched (if in-game)
                     uint8_t objectType = entry->GetType();
                     auto entryIndex = object_manager_get_loaded_object_entry_index(loadedObject);
-                    if (objectType == OBJECT_TYPE_RIDE)
+                    if (objectType == ObjectType::Ride)
                     {
                         rct_ride_entry* rideEntry = get_ride_entry(entryIndex);
                         uint8_t rideType = ride_entry_get_first_non_null_ride_type(rideEntry);
                         ResearchCategory category = static_cast<ResearchCategory>(RideTypeDescriptors[rideType].Category);
                         research_insert_ride_entry(rideType, entryIndex, category, true);
                     }
-                    else if (objectType == OBJECT_TYPE_SCENERY_GROUP)
+                    else if (objectType == ObjectType::SceneryGroup)
                     {
                         research_insert_scenery_group_entry(entryIndex, true);
                     }
@@ -1428,7 +1428,7 @@ static bool filter_string(const ObjectRepositoryItem* item)
 
     // Check if the searched string exists in the name, ride type, or filename
     bool inName = strstr(name_lower, filter_lower) != nullptr;
-    bool inRideType = (item->ObjectEntry.GetType() == OBJECT_TYPE_RIDE) && strstr(type_lower, filter_lower) != nullptr;
+    bool inRideType = (item->ObjectEntry.GetType() == ObjectType::Ride) && strstr(type_lower, filter_lower) != nullptr;
     bool inPath = strstr(object_path, filter_lower) != nullptr;
 
     return inName || inRideType || inPath;
@@ -1473,7 +1473,7 @@ static bool filter_chunks(const ObjectRepositoryItem* item)
 {
     switch (item->ObjectEntry.GetType())
     {
-        case OBJECT_TYPE_RIDE:
+        case ObjectType::Ride:
 
             uint8_t rideType = 0;
             for (int32_t i = 0; i < MAX_RIDE_TYPES_PER_RIDE_ENTRY; i++)
@@ -1529,7 +1529,7 @@ static std::string object_get_description(const Object* object)
 {
     switch (object->GetObjectType())
     {
-        case OBJECT_TYPE_RIDE:
+        case ObjectType::Ride:
         {
             const RideObject* rideObject = static_cast<const RideObject*>(object);
             return rideObject->GetDescription();
@@ -1542,7 +1542,7 @@ static std::string object_get_description(const Object* object)
 static int32_t get_selected_object_type(rct_window* w)
 {
     auto tab = w->selected_tab;
-    if (tab >= OBJECT_TYPE_SCENARIO_TEXT)
+    if (tab >= ObjectType::ScenarioText)
         return tab + 1;
     else
         return tab;
diff --git a/src/openrct2-ui/windows/Footpath.cpp b/src/openrct2-ui/windows/Footpath.cpp
index fb9d5737f0..4bea82a56b 100644
--- a/src/openrct2-ui/windows/Footpath.cpp
+++ b/src/openrct2-ui/windows/Footpath.cpp
@@ -1218,7 +1218,7 @@ static bool footpath_select_default()
 {
     // Select first available footpath
     int32_t footpathId = -1;
-    for (int32_t i = 0; i < object_entry_group_counts[OBJECT_TYPE_PATHS]; i++)
+    for (int32_t i = 0; i < object_entry_group_counts[ObjectType::Paths]; i++)
     {
         PathSurfaceEntry* pathEntry = get_path_surface_entry(i);
         if (pathEntry != nullptr)
diff --git a/src/openrct2-ui/windows/Land.cpp b/src/openrct2-ui/windows/Land.cpp
index 42992f381c..a0360808e2 100644
--- a/src/openrct2-ui/windows/Land.cpp
+++ b/src/openrct2-ui/windows/Land.cpp
@@ -279,7 +279,7 @@ static void window_land_invalidate(rct_window* w)
 
     auto& objManager = GetContext()->GetObjectManager();
     const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
-        objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _selectedFloorTexture));
+        objManager.GetLoadedObject(ObjectType::TerrainSurface, _selectedFloorTexture));
     if (surfaceObj != nullptr)
     {
         surfaceImage = surfaceObj->IconImageId;
@@ -289,7 +289,7 @@ static void window_land_invalidate(rct_window* w)
         }
     }
     const auto edgeObj = static_cast<TerrainEdgeObject*>(
-        objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _selectedWallTexture));
+        objManager.GetLoadedObject(ObjectType::TerrainEdge, _selectedWallTexture));
     if (edgeObj != nullptr)
     {
         edgeImage = edgeObj->IconImageId;
@@ -361,7 +361,7 @@ static void window_land_paint(rct_window* w, rct_drawpixelinfo* dpi)
         {
             auto& objManager = GetContext()->GetObjectManager();
             const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
-                objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, gLandToolTerrainSurface));
+                objManager.GetLoadedObject(ObjectType::TerrainSurface, gLandToolTerrainSurface));
             if (surfaceObj != nullptr)
             {
                 price += numTiles * surfaceObj->Price;
diff --git a/src/openrct2-ui/windows/MapGen.cpp b/src/openrct2-ui/windows/MapGen.cpp
index f28a68c579..1d04d82b72 100644
--- a/src/openrct2-ui/windows/MapGen.cpp
+++ b/src/openrct2-ui/windows/MapGen.cpp
@@ -657,7 +657,7 @@ static void window_mapgen_base_invalidate(rct_window* w)
 
     auto& objManager = GetContext()->GetObjectManager();
     const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
-        objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _floorTexture));
+        objManager.GetLoadedObject(ObjectType::TerrainSurface, _floorTexture));
     if (surfaceObj != nullptr)
     {
         surfaceImage = surfaceObj->IconImageId;
@@ -666,7 +666,7 @@ static void window_mapgen_base_invalidate(rct_window* w)
             surfaceImage |= SPRITE_ID_PALETTE_COLOUR_1(surfaceObj->Colour);
         }
     }
-    const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _wallTexture));
+    const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, _wallTexture));
     if (edgeObj != nullptr)
     {
         edgeImage = edgeObj->IconImageId;
@@ -961,7 +961,7 @@ static void window_mapgen_simplex_invalidate(rct_window* w)
 
     auto& objManager = GetContext()->GetObjectManager();
     const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
-        objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _floorTexture));
+        objManager.GetLoadedObject(ObjectType::TerrainSurface, _floorTexture));
     if (surfaceObj != nullptr)
     {
         surfaceImage = surfaceObj->IconImageId;
@@ -970,7 +970,7 @@ static void window_mapgen_simplex_invalidate(rct_window* w)
             surfaceImage |= SPRITE_ID_PALETTE_COLOUR_1(surfaceObj->Colour);
         }
     }
-    const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _wallTexture));
+    const auto edgeObj = static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, _wallTexture));
     if (edgeObj != nullptr)
     {
         edgeImage = edgeObj->IconImageId;
diff --git a/src/openrct2-ui/windows/ObjectLoadError.cpp b/src/openrct2-ui/windows/ObjectLoadError.cpp
index 6ae70f46a0..353014f37e 100644
--- a/src/openrct2-ui/windows/ObjectLoadError.cpp
+++ b/src/openrct2-ui/windows/ObjectLoadError.cpp
@@ -327,34 +327,34 @@ static rct_string_id get_object_type_string(const rct_object_entry* entry)
     rct_string_id result;
     switch (entry->GetType())
     {
-        case OBJECT_TYPE_RIDE:
+        case ObjectType::Ride:
             result = STR_OBJECT_SELECTION_RIDE_VEHICLES_ATTRACTIONS;
             break;
-        case OBJECT_TYPE_SMALL_SCENERY:
+        case ObjectType::SmallScenery:
             result = STR_OBJECT_SELECTION_SMALL_SCENERY;
             break;
-        case OBJECT_TYPE_LARGE_SCENERY:
+        case ObjectType::LargeScenery:
             result = STR_OBJECT_SELECTION_LARGE_SCENERY;
             break;
-        case OBJECT_TYPE_WALLS:
+        case ObjectType::Walls:
             result = STR_OBJECT_SELECTION_WALLS_FENCES;
             break;
-        case OBJECT_TYPE_BANNERS:
+        case ObjectType::Banners:
             result = STR_OBJECT_SELECTION_PATH_SIGNS;
             break;
-        case OBJECT_TYPE_PATHS:
+        case ObjectType::Paths:
             result = STR_OBJECT_SELECTION_FOOTPATHS;
             break;
-        case OBJECT_TYPE_PATH_BITS:
+        case ObjectType::PathBits:
             result = STR_OBJECT_SELECTION_PATH_EXTRAS;
             break;
-        case OBJECT_TYPE_SCENERY_GROUP:
+        case ObjectType::SceneryGroup:
             result = STR_OBJECT_SELECTION_SCENERY_GROUPS;
             break;
-        case OBJECT_TYPE_PARK_ENTRANCE:
+        case ObjectType::ParkEntrance:
             result = STR_OBJECT_SELECTION_PARK_ENTRANCE;
             break;
-        case OBJECT_TYPE_WATER:
+        case ObjectType::Water:
             result = STR_OBJECT_SELECTION_WATER;
             break;
         default:
diff --git a/src/openrct2-ui/windows/Ride.cpp b/src/openrct2-ui/windows/Ride.cpp
index 3cea839356..a4c6077232 100644
--- a/src/openrct2-ui/windows/Ride.cpp
+++ b/src/openrct2-ui/windows/Ride.cpp
@@ -4344,7 +4344,7 @@ static void window_ride_colour_mousedown(rct_window* w, rct_widgetindex widgetIn
             auto& objManager = GetContext()->GetObjectManager();
             for (i = 0; i < MAX_STATION_OBJECTS; i++)
             {
-                auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, i));
+                auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, i));
                 if (stationObj != nullptr)
                 {
                     gDropdownItemsFormat[ddIndex] = STR_DROPDOWN_MENU_LABEL;
@@ -4463,7 +4463,7 @@ static void window_ride_colour_dropdown(rct_window* w, rct_widgetindex widgetInd
             auto& objManager = GetContext()->GetObjectManager();
             for (auto i = 0; i < MAX_STATION_OBJECTS; i++)
             {
-                auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, i));
+                auto stationObj = static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, i));
                 if (stationObj != nullptr)
                 {
                     if (ddIndex == dropdownIndex)
diff --git a/src/openrct2/CmdlineSprite.cpp b/src/openrct2/CmdlineSprite.cpp
index 533710c13c..361be71491 100644
--- a/src/openrct2/CmdlineSprite.cpp
+++ b/src/openrct2/CmdlineSprite.cpp
@@ -487,17 +487,17 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
         int32_t imagesOffset = 0;
         switch (objectType)
         {
-            case OBJECT_TYPE_RIDE:
+            case ObjectType::Ride:
             {
                 auto rideEntry = get_ride_entry(entryIndex);
                 imagesOffset = rideEntry->images_offset;
                 break;
             }
-            case OBJECT_TYPE_SMALL_SCENERY:
-            case OBJECT_TYPE_LARGE_SCENERY:
-            case OBJECT_TYPE_WALLS:
-            case OBJECT_TYPE_BANNERS:
-            case OBJECT_TYPE_PATH_BITS:
+            case ObjectType::SmallScenery:
+            case ObjectType::LargeScenery:
+            case ObjectType::Walls:
+            case ObjectType::Banners:
+            case ObjectType::PathBits:
             {
                 auto obj = objManager.GetLoadedObject(objectType, entryIndex);
                 if (obj != nullptr)
@@ -507,19 +507,19 @@ int32_t cmdline_for_sprite(const char** argv, int32_t argc)
                 }
                 break;
             }
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
             {
                 auto pathEntry = get_path_surface_entry(entryIndex);
                 imagesOffset = pathEntry->image;
                 break;
             }
-            case OBJECT_TYPE_SCENERY_GROUP:
+            case ObjectType::SceneryGroup:
             {
                 auto sceneryGroupEntry = get_scenery_group_entry(entryIndex);
                 imagesOffset = sceneryGroupEntry->image;
                 break;
             }
-            case OBJECT_TYPE_PARK_ENTRANCE:
+            case ObjectType::ParkEntrance:
             {
                 auto obj = objManager.GetLoadedObject(objectType, entryIndex);
                 if (obj != nullptr)
diff --git a/src/openrct2/Editor.cpp b/src/openrct2/Editor.cpp
index 9d2c4cbe5c..dbdbbe3015 100644
--- a/src/openrct2/Editor.cpp
+++ b/src/openrct2/Editor.cpp
@@ -47,7 +47,7 @@ using namespace OpenRCT2;
 
 namespace Editor
 {
-    static std::array<std::vector<uint8_t>, OBJECT_TYPE_COUNT> _editorSelectedObjectFlags;
+    static std::array<std::vector<uint8_t>, ObjectType::Count> _editorSelectedObjectFlags;
 
     static void ConvertSaveToScenarioCallback(int32_t result, const utf8* path);
     static void SetAllLandOwned();
@@ -451,31 +451,31 @@ namespace Editor
 
         if (!isTrackDesignerManager)
         {
-            if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_PATHS))
+            if (!editor_check_object_group_at_least_one_selected(ObjectType::Paths))
             {
                 gGameCommandErrorText = STR_AT_LEAST_ONE_PATH_OBJECT_MUST_BE_SELECTED;
-                return OBJECT_TYPE_PATHS;
+                return ObjectType::Paths;
             }
         }
 
-        if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_RIDE))
+        if (!editor_check_object_group_at_least_one_selected(ObjectType::Ride))
         {
             gGameCommandErrorText = STR_AT_LEAST_ONE_RIDE_OBJECT_MUST_BE_SELECTED;
-            return OBJECT_TYPE_RIDE;
+            return ObjectType::Ride;
         }
 
         if (!isTrackDesignerManager)
         {
-            if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_PARK_ENTRANCE))
+            if (!editor_check_object_group_at_least_one_selected(ObjectType::ParkEntrance))
             {
                 gGameCommandErrorText = STR_PARK_ENTRANCE_TYPE_MUST_BE_SELECTED;
-                return OBJECT_TYPE_PARK_ENTRANCE;
+                return ObjectType::ParkEntrance;
             }
 
-            if (!editor_check_object_group_at_least_one_selected(OBJECT_TYPE_WATER))
+            if (!editor_check_object_group_at_least_one_selected(ObjectType::Water))
             {
                 gGameCommandErrorText = STR_WATER_TYPE_MUST_BE_SELECTED;
-                return OBJECT_TYPE_WATER;
+                return ObjectType::Water;
             }
         }
 
diff --git a/src/openrct2/EditorObjectSelectionSession.cpp b/src/openrct2/EditorObjectSelectionSession.cpp
index 195c3ed785..882a6e41a5 100644
--- a/src/openrct2/EditorObjectSelectionSession.cpp
+++ b/src/openrct2/EditorObjectSelectionSession.cpp
@@ -30,8 +30,8 @@
 
 bool _maxObjectsWasHit;
 std::vector<uint8_t> _objectSelectionFlags;
-int32_t _numSelectedObjectsForType[OBJECT_TYPE_COUNT];
-static int32_t _numAvailableObjectsForType[OBJECT_TYPE_COUNT];
+int32_t _numSelectedObjectsForType[ObjectType::Count];
+static int32_t _numAvailableObjectsForType[ObjectType::Count];
 
 static void setup_in_use_selection_flags();
 static void setup_track_designer_objects();
@@ -51,7 +51,7 @@ static void setup_track_manager_objects()
         uint8_t* selectionFlags = &_objectSelectionFlags[i];
         const ObjectRepositoryItem* item = &items[i];
         uint8_t object_type = item->ObjectEntry.GetType();
-        if (object_type == OBJECT_TYPE_RIDE)
+        if (object_type == ObjectType::Ride)
         {
             *selectionFlags |= OBJECT_SELECTION_FLAG_6;
 
@@ -80,7 +80,7 @@ static void setup_track_designer_objects()
         uint8_t* selectionFlags = &_objectSelectionFlags[i];
         const ObjectRepositoryItem* item = &items[i];
         uint8_t objectType = item->ObjectEntry.GetType();
-        if (objectType == OBJECT_TYPE_RIDE)
+        if (objectType == ObjectType::Ride)
         {
             *selectionFlags |= OBJECT_SELECTION_FLAG_6;
 
@@ -107,7 +107,7 @@ void setup_in_use_selection_flags()
 {
     auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
 
-    for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++)
+    for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
     {
         for (int32_t i = 0; i < object_entry_group_counts[objectType]; i++)
         {
@@ -135,19 +135,19 @@ void setup_in_use_selection_flags()
                 break;
             case TILE_ELEMENT_TYPE_PATH:
                 type = iter.element->AsPath()->GetSurfaceEntryIndex();
-                assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
-                Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                assert(type < object_entry_group_counts[ObjectType::Paths]);
+                Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
 
                 if (iter.element->AsPath()->HasAddition())
                 {
                     uint8_t path_additions = iter.element->AsPath()->GetAdditionEntryIndex();
-                    Editor::SetSelectedObject(OBJECT_TYPE_PATH_BITS, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
+                    Editor::SetSelectedObject(ObjectType::PathBits, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
                 }
                 break;
             case TILE_ELEMENT_TYPE_SMALL_SCENERY:
                 type = iter.element->AsSmallScenery()->GetEntryIndex();
-                assert(type < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]);
-                Editor::SetSelectedObject(OBJECT_TYPE_SMALL_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
+                assert(type < object_entry_group_counts[ObjectType::SmallScenery]);
+                Editor::SetSelectedObject(ObjectType::SmallScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_ENTRANCE:
                 if (iter.element->AsEntrance()->GetEntranceType() != ENTRANCE_TYPE_PARK_ENTRANCE)
@@ -156,21 +156,21 @@ void setup_in_use_selection_flags()
                 if (iter.element->AsEntrance()->GetSequenceIndex() != 0)
                     break;
 
-                Editor::SetSelectedObject(OBJECT_TYPE_PARK_ENTRANCE, 0, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(ObjectType::ParkEntrance, 0, OBJECT_SELECTION_FLAG_SELECTED);
 
                 type = iter.element->AsEntrance()->GetPathType();
-                assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
-                Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                assert(type < object_entry_group_counts[ObjectType::Paths]);
+                Editor::SetSelectedObject(ObjectType::Paths, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_WALL:
                 type = iter.element->AsWall()->GetEntryIndex();
-                assert(type < object_entry_group_counts[OBJECT_TYPE_WALLS]);
-                Editor::SetSelectedObject(OBJECT_TYPE_WALLS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                assert(type < object_entry_group_counts[ObjectType::Walls]);
+                Editor::SetSelectedObject(ObjectType::Walls, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_LARGE_SCENERY:
                 type = iter.element->AsLargeScenery()->GetEntryIndex();
-                assert(type < object_entry_group_counts[OBJECT_TYPE_LARGE_SCENERY]);
-                Editor::SetSelectedObject(OBJECT_TYPE_LARGE_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
+                assert(type < object_entry_group_counts[ObjectType::LargeScenery]);
+                Editor::SetSelectedObject(ObjectType::LargeScenery, type, OBJECT_SELECTION_FLAG_SELECTED);
                 break;
             case TILE_ELEMENT_TYPE_BANNER:
             {
@@ -178,8 +178,8 @@ void setup_in_use_selection_flags()
                 if (banner != nullptr)
                 {
                     type = banner->type;
-                    assert(type < object_entry_group_counts[OBJECT_TYPE_BANNERS]);
-                    Editor::SetSelectedObject(OBJECT_TYPE_BANNERS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                    assert(type < object_entry_group_counts[ObjectType::Banners]);
+                    Editor::SetSelectedObject(ObjectType::Banners, type, OBJECT_SELECTION_FLAG_SELECTED);
                 }
                 break;
             }
@@ -192,7 +192,7 @@ void setup_in_use_selection_flags()
         if (ride != nullptr)
         {
             ObjectEntryIndex type = ride->subtype;
-            Editor::SetSelectedObject(OBJECT_TYPE_RIDE, type, OBJECT_SELECTION_FLAG_SELECTED);
+            Editor::SetSelectedObject(ObjectType::Ride, type, OBJECT_SELECTION_FLAG_SELECTED);
         }
     }
 
@@ -230,7 +230,7 @@ void sub_6AB211()
     int32_t numObjects = static_cast<int32_t>(object_repository_get_items_count());
     _objectSelectionFlags = std::vector<uint8_t>(numObjects);
 
-    for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++)
+    for (uint8_t objectType = 0; objectType < ObjectType::Count; objectType++)
     {
         _numSelectedObjectsForType[objectType] = 0;
         _numAvailableObjectsForType[objectType] = 0;
@@ -289,7 +289,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
     if (!find_object_in_entry_group(installedObject, &entry_type, &entry_index))
         return;
 
-    if (entry_type == OBJECT_TYPE_RIDE)
+    if (entry_type == ObjectType::Ride)
     {
         auto rideEntry = get_ride_entry(entry_index);
 
@@ -302,7 +302,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
             research_remove(&tmp);
         }
     }
-    else if (entry_type == OBJECT_TYPE_SCENERY_GROUP)
+    else if (entry_type == ObjectType::SceneryGroup)
     {
         ResearchItem tmp = {};
         tmp.type = Research::EntryType::Scenery;
@@ -451,7 +451,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
         }
 
         uint8_t objectType = item->ObjectEntry.GetType();
-        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
+        if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
         {
             for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
             {
@@ -490,7 +490,7 @@ bool window_editor_object_selection_select_object(uint8_t isMasterObject, int32_
             return false;
         }
 
-        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
+        if (objectType == ObjectType::SceneryGroup && (flags & INPUT_FLAG_EDITOR_OBJECT_SELECT_OBJECTS_IN_SCENERY_GROUP))
         {
             for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
             {
@@ -572,7 +572,7 @@ int32_t editor_remove_unused_objects()
                 const ObjectRepositoryItem* item = &items[i];
                 uint8_t objectType = item->ObjectEntry.GetType();
 
-                if (objectType >= OBJECT_TYPE_SCENERY_GROUP)
+                if (objectType >= ObjectType::SceneryGroup)
                 {
                     continue;
                 }
diff --git a/src/openrct2/EditorObjectSelectionSession.h b/src/openrct2/EditorObjectSelectionSession.h
index 86b8a2faf6..729c0b94e5 100644
--- a/src/openrct2/EditorObjectSelectionSession.h
+++ b/src/openrct2/EditorObjectSelectionSession.h
@@ -24,7 +24,7 @@ enum EDITOR_INPUT_FLAGS
 
 extern bool _maxObjectsWasHit;
 extern std::vector<uint8_t> _objectSelectionFlags;
-extern int32_t _numSelectedObjectsForType[OBJECT_TYPE_COUNT];
+extern int32_t _numSelectedObjectsForType[ObjectType::Count];
 
 bool editor_check_object_group_at_least_one_selected(int32_t objectType);
 void editor_object_flags_free();
diff --git a/src/openrct2/Game.cpp b/src/openrct2/Game.cpp
index bd8176e3e0..919ecc1a92 100644
--- a/src/openrct2/Game.cpp
+++ b/src/openrct2/Game.cpp
@@ -144,7 +144,7 @@ enum
  */
 void update_palette_effects()
 {
-    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
+    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
 
     if (gClimateLightningFlash == 1)
     {
diff --git a/src/openrct2/actions/SurfaceSetStyleAction.hpp b/src/openrct2/actions/SurfaceSetStyleAction.hpp
index d4e0547a25..7d023d6dc9 100644
--- a/src/openrct2/actions/SurfaceSetStyleAction.hpp
+++ b/src/openrct2/actions/SurfaceSetStyleAction.hpp
@@ -68,7 +68,7 @@ public:
             }
 
             const auto surfaceObj = static_cast<TerrainSurfaceObject*>(
-                objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
+                objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
 
             if (surfaceObj == nullptr)
             {
@@ -86,7 +86,7 @@ public:
             }
 
             const auto edgeObj = static_cast<TerrainEdgeObject*>(
-                objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, _edgeStyle));
+                objManager.GetLoadedObject(ObjectType::TerrainEdge, _edgeStyle));
 
             if (edgeObj == nullptr)
             {
@@ -139,7 +139,7 @@ public:
                     if (_surfaceStyle != curSurfaceStyle)
                     {
                         const auto surfaceObject = static_cast<TerrainSurfaceObject*>(
-                            objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
+                            objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
                         if (surfaceObject != nullptr)
                         {
                             surfaceCost += surfaceObject->Price;
@@ -215,7 +215,7 @@ public:
                     {
                         auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
                         const auto surfaceObject = static_cast<TerrainSurfaceObject*>(
-                            objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, _surfaceStyle));
+                            objManager.GetLoadedObject(ObjectType::TerrainSurface, _surfaceStyle));
                         if (surfaceObject != nullptr)
                         {
                             surfaceCost += surfaceObject->Price;
diff --git a/src/openrct2/drawing/Drawing.cpp b/src/openrct2/drawing/Drawing.cpp
index 9545a2022a..8e92270b00 100644
--- a/src/openrct2/drawing/Drawing.cpp
+++ b/src/openrct2/drawing/Drawing.cpp
@@ -627,7 +627,7 @@ void load_palette()
         return;
     }
 
-    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
+    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
 
     uint32_t palette = 0x5FC;
 
diff --git a/src/openrct2/interface/InteractiveConsole.cpp b/src/openrct2/interface/InteractiveConsole.cpp
index 381c8e6e6b..1c4a5abaa5 100644
--- a/src/openrct2/interface/InteractiveConsole.cpp
+++ b/src/openrct2/interface/InteractiveConsole.cpp
@@ -1074,7 +1074,7 @@ static int32_t cc_load_object(InteractiveConsole& console, const arguments_t& ar
         auto groupIndex = object_manager_get_loaded_object_entry_index(loadedObject);
 
         uint8_t objectType = entry->GetType();
-        if (objectType == OBJECT_TYPE_RIDE)
+        if (objectType == ObjectType::Ride)
         {
             // Automatically research the ride so it's supported by the game.
             rct_ride_entry* rideEntry;
@@ -1096,7 +1096,7 @@ static int32_t cc_load_object(InteractiveConsole& console, const arguments_t& ar
             research_reset_current_item();
             gSilentResearch = false;
         }
-        else if (objectType == OBJECT_TYPE_SCENERY_GROUP)
+        else if (objectType == ObjectType::SceneryGroup)
         {
             research_insert_scenery_group_entry(groupIndex, true);
 
diff --git a/src/openrct2/object/Object.cpp b/src/openrct2/object/Object.cpp
index 67b0133568..cac76cf7d3 100644
--- a/src/openrct2/object/Object.cpp
+++ b/src/openrct2/object/Object.cpp
@@ -145,15 +145,15 @@ std::optional<uint8_t> rct_object_entry::GetSceneryType() const
 {
     switch (GetType())
     {
-        case OBJECT_TYPE_SMALL_SCENERY:
+        case ObjectType::SmallScenery:
             return SCENERY_TYPE_SMALL;
-        case OBJECT_TYPE_LARGE_SCENERY:
+        case ObjectType::LargeScenery:
             return SCENERY_TYPE_LARGE;
-        case OBJECT_TYPE_WALLS:
+        case ObjectType::Walls:
             return SCENERY_TYPE_WALL;
-        case OBJECT_TYPE_BANNERS:
+        case ObjectType::Banners:
             return SCENERY_TYPE_BANNER;
-        case OBJECT_TYPE_PATH_BITS:
+        case ObjectType::PathBits:
             return SCENERY_TYPE_PATH_ITEM;
         default:
             return std::nullopt;
diff --git a/src/openrct2/object/Object.h b/src/openrct2/object/Object.h
index 3595882aee..fb9ef58ffa 100644
--- a/src/openrct2/object/Object.h
+++ b/src/openrct2/object/Object.h
@@ -23,25 +23,25 @@ using ObjectEntryIndex = uint16_t;
 constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_NULL = std::numeric_limits<ObjectEntryIndex>::max();
 
 // First 0xF of rct_object_entry->flags
-enum OBJECT_TYPE
+enum ObjectType : uint8_t
 {
-    OBJECT_TYPE_RIDE,
-    OBJECT_TYPE_SMALL_SCENERY,
-    OBJECT_TYPE_LARGE_SCENERY,
-    OBJECT_TYPE_WALLS,
-    OBJECT_TYPE_BANNERS,
-    OBJECT_TYPE_PATHS,
-    OBJECT_TYPE_PATH_BITS,
-    OBJECT_TYPE_SCENERY_GROUP,
-    OBJECT_TYPE_PARK_ENTRANCE,
-    OBJECT_TYPE_WATER,
-    OBJECT_TYPE_SCENARIO_TEXT,
-    OBJECT_TYPE_TERRAIN_SURFACE,
-    OBJECT_TYPE_TERRAIN_EDGE,
-    OBJECT_TYPE_STATION,
-    OBJECT_TYPE_MUSIC,
+    Ride,
+    SmallScenery,
+    LargeScenery,
+    Walls,
+    Banners,
+    Paths,
+    PathBits,
+    SceneryGroup,
+    ParkEntrance,
+    Water,
+    ScenarioText,
+    TerrainSurface,
+    TerrainEdge,
+    Station,
+    Music,
 
-    OBJECT_TYPE_COUNT
+    Count
 };
 
 enum OBJECT_SELECTION_FLAGS
diff --git a/src/openrct2/object/ObjectFactory.cpp b/src/openrct2/object/ObjectFactory.cpp
index 74261f1770..f0876756fa 100644
--- a/src/openrct2/object/ObjectFactory.cpp
+++ b/src/openrct2/object/ObjectFactory.cpp
@@ -212,7 +212,7 @@ namespace ObjectFactory
 
             rct_object_entry entry = fs.ReadValue<rct_object_entry>();
 
-            if (entry.GetType() != OBJECT_TYPE_SCENARIO_TEXT)
+            if (entry.GetType() != ObjectType::ScenarioText)
             {
                 result = CreateObject(entry);
 
@@ -273,45 +273,45 @@ namespace ObjectFactory
         std::unique_ptr<Object> result;
         switch (entry.GetType())
         {
-            case OBJECT_TYPE_RIDE:
+            case ObjectType::Ride:
                 result = std::make_unique<RideObject>(entry);
                 break;
-            case OBJECT_TYPE_SMALL_SCENERY:
+            case ObjectType::SmallScenery:
                 result = std::make_unique<SmallSceneryObject>(entry);
                 break;
-            case OBJECT_TYPE_LARGE_SCENERY:
+            case ObjectType::LargeScenery:
                 result = std::make_unique<LargeSceneryObject>(entry);
                 break;
-            case OBJECT_TYPE_WALLS:
+            case ObjectType::Walls:
                 result = std::make_unique<WallObject>(entry);
                 break;
-            case OBJECT_TYPE_BANNERS:
+            case ObjectType::Banners:
                 result = std::make_unique<BannerObject>(entry);
                 break;
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
                 result = std::make_unique<FootpathObject>(entry);
                 break;
-            case OBJECT_TYPE_PATH_BITS:
+            case ObjectType::PathBits:
                 result = std::make_unique<FootpathItemObject>(entry);
                 break;
-            case OBJECT_TYPE_SCENERY_GROUP:
+            case ObjectType::SceneryGroup:
                 result = std::make_unique<SceneryGroupObject>(entry);
                 break;
-            case OBJECT_TYPE_PARK_ENTRANCE:
+            case ObjectType::ParkEntrance:
                 result = std::make_unique<EntranceObject>(entry);
                 break;
-            case OBJECT_TYPE_WATER:
+            case ObjectType::Water:
                 result = std::make_unique<WaterObject>(entry);
                 break;
-            case OBJECT_TYPE_SCENARIO_TEXT:
+            case ObjectType::ScenarioText:
                 break;
-            case OBJECT_TYPE_TERRAIN_SURFACE:
+            case ObjectType::TerrainSurface:
                 result = std::make_unique<TerrainSurfaceObject>(entry);
                 break;
-            case OBJECT_TYPE_TERRAIN_EDGE:
+            case ObjectType::TerrainEdge:
                 result = std::make_unique<TerrainEdgeObject>(entry);
                 break;
-            case OBJECT_TYPE_STATION:
+            case ObjectType::Station:
                 result = std::make_unique<StationObject>(entry);
                 break;
             default:
@@ -323,31 +323,31 @@ namespace ObjectFactory
     static uint8_t ParseObjectType(const std::string& s)
     {
         if (s == "ride")
-            return OBJECT_TYPE_RIDE;
+            return ObjectType::Ride;
         if (s == "footpath")
-            return OBJECT_TYPE_PATHS;
+            return ObjectType::Paths;
         if (s == "footpath_banner")
-            return OBJECT_TYPE_BANNERS;
+            return ObjectType::Banners;
         if (s == "footpath_item")
-            return OBJECT_TYPE_PATH_BITS;
+            return ObjectType::PathBits;
         if (s == "scenery_small")
-            return OBJECT_TYPE_SMALL_SCENERY;
+            return ObjectType::SmallScenery;
         if (s == "scenery_large")
-            return OBJECT_TYPE_LARGE_SCENERY;
+            return ObjectType::LargeScenery;
         if (s == "scenery_wall")
-            return OBJECT_TYPE_WALLS;
+            return ObjectType::Walls;
         if (s == "scenery_group")
-            return OBJECT_TYPE_SCENERY_GROUP;
+            return ObjectType::SceneryGroup;
         if (s == "park_entrance")
-            return OBJECT_TYPE_PARK_ENTRANCE;
+            return ObjectType::ParkEntrance;
         if (s == "water")
-            return OBJECT_TYPE_WATER;
+            return ObjectType::Water;
         if (s == "terrain_surface")
-            return OBJECT_TYPE_TERRAIN_SURFACE;
+            return ObjectType::TerrainSurface;
         if (s == "terrain_edge")
-            return OBJECT_TYPE_TERRAIN_EDGE;
+            return ObjectType::TerrainEdge;
         if (s == "station")
-            return OBJECT_TYPE_STATION;
+            return ObjectType::Station;
         return 0xFF;
     }
 
diff --git a/src/openrct2/object/ObjectList.cpp b/src/openrct2/object/ObjectList.cpp
index 7d83c41ad0..2a39285cbf 100644
--- a/src/openrct2/object/ObjectList.cpp
+++ b/src/openrct2/object/ObjectList.cpp
@@ -87,7 +87,7 @@ void object_create_identifier_name(char* string_buffer, size_t size, const rct_o
 bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_type, ObjectEntryIndex* entryIndex)
 {
     int32_t objectType = entry->GetType();
-    if (objectType >= OBJECT_TYPE_COUNT)
+    if (objectType >= ObjectType::Count)
     {
         return false;
     }
@@ -113,7 +113,7 @@ bool find_object_in_entry_group(const rct_object_entry* entry, uint8_t* entry_ty
 
 void get_type_entry_index(size_t index, uint8_t* outObjectType, ObjectEntryIndex* outEntryIndex)
 {
-    uint8_t objectType = OBJECT_TYPE_RIDE;
+    uint8_t objectType = ObjectType::Ride;
     for (size_t groupCount : object_entry_group_counts)
     {
         if (index >= groupCount)
diff --git a/src/openrct2/object/ObjectManager.cpp b/src/openrct2/object/ObjectManager.cpp
index 3763f5a590..629c6ee7a5 100644
--- a/src/openrct2/object/ObjectManager.cpp
+++ b/src/openrct2/object/ObjectManager.cpp
@@ -426,27 +426,27 @@ private:
                 rct_scenery_entry* sceneryEntry;
                 switch (loadedObject->GetObjectType())
                 {
-                    case OBJECT_TYPE_SMALL_SCENERY:
+                    case ObjectType::SmallScenery:
                         sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
                         sceneryEntry->small_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
                         break;
-                    case OBJECT_TYPE_LARGE_SCENERY:
+                    case ObjectType::LargeScenery:
                         sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
                         sceneryEntry->large_scenery.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
                         break;
-                    case OBJECT_TYPE_WALLS:
+                    case ObjectType::Walls:
                         sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
                         sceneryEntry->wall.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
                         break;
-                    case OBJECT_TYPE_BANNERS:
+                    case ObjectType::Banners:
                         sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
                         sceneryEntry->banner.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
                         break;
-                    case OBJECT_TYPE_PATH_BITS:
+                    case ObjectType::PathBits:
                         sceneryEntry = static_cast<rct_scenery_entry*>(loadedObject->GetLegacyData());
                         sceneryEntry->path_bit.scenery_tab_id = GetPrimarySceneryGroupEntryIndex(loadedObject.get());
                         break;
-                    case OBJECT_TYPE_SCENERY_GROUP:
+                    case ObjectType::SceneryGroup:
                         auto sgObject = dynamic_cast<SceneryGroupObject*>(loadedObject.get());
                         sgObject->UpdateEntryIndexes();
                         break;
@@ -499,7 +499,7 @@ private:
             ori = _objectRepository.FindObject(&entry);
             if (ori == nullptr)
             {
-                if (entry.GetType() != OBJECT_TYPE_SCENARIO_TEXT)
+                if (entry.GetType() != ObjectType::ScenarioText)
                 {
                     invalidEntries.push_back(entry);
                     ReportMissingObject(&entry);
@@ -539,7 +539,7 @@ private:
             if (!object_entry_is_empty(entry))
             {
                 ori = _objectRepository.FindObject(entry);
-                if (ori == nullptr && entry->GetType() != OBJECT_TYPE_SCENARIO_TEXT)
+                if (ori == nullptr && entry->GetType() != ObjectType::ScenarioText)
                 {
                     missingObjects.push_back(*entry);
                     ReportMissingObject(entry);
@@ -684,10 +684,10 @@ private:
         }
 
         // Build object lists
-        auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[OBJECT_TYPE_RIDE]);
+        auto maxRideObjects = static_cast<size_t>(object_entry_group_counts[ObjectType::Ride]);
         for (size_t i = 0; i < maxRideObjects; i++)
         {
-            auto rideObject = static_cast<RideObject*>(GetLoadedObject(OBJECT_TYPE_RIDE, i));
+            auto rideObject = static_cast<RideObject*>(GetLoadedObject(ObjectType::Ride, i));
             if (rideObject != nullptr)
             {
                 const auto entry = static_cast<rct_ride_entry*>(rideObject->GetLegacyData());
diff --git a/src/openrct2/object/ObjectRepository.cpp b/src/openrct2/object/ObjectRepository.cpp
index 8795a14b1e..92c358cde9 100644
--- a/src/openrct2/object/ObjectRepository.cpp
+++ b/src/openrct2/object/ObjectRepository.cpp
@@ -148,7 +148,7 @@ protected:
 
         switch (item.ObjectEntry.GetType())
         {
-            case OBJECT_TYPE_RIDE:
+            case ObjectType::Ride:
                 stream->WriteValue<uint8_t>(item.RideInfo.RideFlags);
                 for (int32_t i = 0; i < MAX_CATEGORIES_PER_RIDE; i++)
                 {
@@ -159,7 +159,7 @@ protected:
                     stream->WriteValue<uint8_t>(item.RideInfo.RideType[i]);
                 }
                 break;
-            case OBJECT_TYPE_SCENERY_GROUP:
+            case ObjectType::SceneryGroup:
                 stream->WriteValue<uint16_t>(static_cast<uint16_t>(item.SceneryGroupInfo.Entries.size()));
                 for (const auto& entry : item.SceneryGroupInfo.Entries)
                 {
@@ -194,7 +194,7 @@ protected:
 
         switch (item.ObjectEntry.GetType())
         {
-            case OBJECT_TYPE_RIDE:
+            case ObjectType::Ride:
                 item.RideInfo.RideFlags = stream->ReadValue<uint8_t>();
                 for (int32_t i = 0; i < MAX_CATEGORIES_PER_RIDE; i++)
                 {
@@ -205,7 +205,7 @@ protected:
                     item.RideInfo.RideType[i] = stream->ReadValue<uint8_t>();
                 }
                 break;
-            case OBJECT_TYPE_SCENERY_GROUP:
+            case ObjectType::SceneryGroup:
             {
                 auto numEntries = stream->ReadValue<uint16_t>();
                 item.SceneryGroupInfo.Entries = std::vector<rct_object_entry>(numEntries);
@@ -689,7 +689,7 @@ bool IsObjectCustom(const ObjectRepositoryItem* object)
     // Do not count our new object types as custom yet, otherwise the game
     // will try to pack them into saved games.
     auto type = object->ObjectEntry.GetType();
-    if (type > OBJECT_TYPE_SCENARIO_TEXT)
+    if (type > ObjectType::ScenarioText)
     {
         return false;
     }
diff --git a/src/openrct2/paint/tile_element/Paint.Entrance.cpp b/src/openrct2/paint/tile_element/Paint.Entrance.cpp
index cd18d2d786..84cfda74fc 100644
--- a/src/openrct2/paint/tile_element/Paint.Entrance.cpp
+++ b/src/openrct2/paint/tile_element/Paint.Entrance.cpp
@@ -252,7 +252,7 @@ static void park_entrance_paint(paint_session* session, uint8_t direction, int32
                 PaintAddImageAsParent(session, image_id, 0, 0, 32, 0x1C, 0, height, 0, 2, height);
             }
 
-            entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(OBJECT_TYPE_PARK_ENTRANCE, 0));
+            entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(ObjectType::ParkEntrance, 0));
             if (entrance == nullptr)
             {
                 return;
@@ -307,7 +307,7 @@ static void park_entrance_paint(paint_session* session, uint8_t direction, int32
             break;
         case 1:
         case 2:
-            entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(OBJECT_TYPE_PARK_ENTRANCE, 0));
+            entrance = static_cast<rct_entrance_type*>(object_entry_get_chunk(ObjectType::ParkEntrance, 0));
             if (entrance == nullptr)
             {
                 return;
diff --git a/src/openrct2/paint/tile_element/Paint.Surface.cpp b/src/openrct2/paint/tile_element/Paint.Surface.cpp
index 24ac88ae62..bcb8056f16 100644
--- a/src/openrct2/paint/tile_element/Paint.Surface.cpp
+++ b/src/openrct2/paint/tile_element/Paint.Surface.cpp
@@ -295,7 +295,7 @@ static const TerrainSurfaceObject* get_surface_object(size_t index)
 {
     TerrainSurfaceObject* result{};
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, index);
+    auto obj = objMgr.GetLoadedObject(ObjectType::TerrainSurface, index);
     if (obj != nullptr)
     {
         return static_cast<TerrainSurfaceObject*>(obj);
@@ -360,7 +360,7 @@ static uint32_t get_edge_image_with_offset(uint8_t index, uint32_t offset)
 {
     uint32_t result = 0;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, index);
+    auto obj = objMgr.GetLoadedObject(ObjectType::TerrainEdge, index);
     if (obj != nullptr)
     {
         auto tobj = static_cast<TerrainEdgeObject*>(obj);
@@ -393,7 +393,7 @@ static uint32_t get_tunnel_image(ObjectEntryIndex index, uint8_t type)
 
     bool hasDoors = false;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, index);
+    auto obj = objMgr.GetLoadedObject(ObjectType::TerrainEdge, index);
     if (obj != nullptr)
     {
         auto tobj = static_cast<TerrainEdgeObject*>(obj);
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index 5ab9725c1c..e66cbf6bee 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -532,11 +532,11 @@ private:
                     uint8_t objectType = foundObject->ObjectEntry.GetType();
                     switch (objectType)
                     {
-                        case OBJECT_TYPE_SMALL_SCENERY:
-                        case OBJECT_TYPE_LARGE_SCENERY:
-                        case OBJECT_TYPE_WALLS:
-                        case OBJECT_TYPE_PATHS:
-                        case OBJECT_TYPE_PATH_BITS:
+                        case ObjectType::SmallScenery:
+                        case ObjectType::LargeScenery:
+                        case ObjectType::Walls:
+                        case ObjectType::Paths:
+                        case ObjectType::PathBits:
                             EntryList* entries = GetEntryList(objectType);
 
                             // Check if there are spare entries available
@@ -1868,15 +1868,15 @@ private:
         auto& objectManager = OpenRCT2::GetContext()->GetObjectManager();
         objectManager.LoadDefaultObjects();
 
-        LoadObjects(OBJECT_TYPE_RIDE, _rideEntries);
-        LoadObjects(OBJECT_TYPE_SMALL_SCENERY, _smallSceneryEntries);
-        LoadObjects(OBJECT_TYPE_LARGE_SCENERY, _largeSceneryEntries);
-        LoadObjects(OBJECT_TYPE_WALLS, _wallEntries);
-        LoadObjects(OBJECT_TYPE_PATHS, _pathEntries);
-        LoadObjects(OBJECT_TYPE_PATH_BITS, _pathAdditionEntries);
-        LoadObjects(OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries);
+        LoadObjects(ObjectType::Ride, _rideEntries);
+        LoadObjects(ObjectType::SmallScenery, _smallSceneryEntries);
+        LoadObjects(ObjectType::LargeScenery, _largeSceneryEntries);
+        LoadObjects(ObjectType::Walls, _wallEntries);
+        LoadObjects(ObjectType::Paths, _pathEntries);
+        LoadObjects(ObjectType::PathBits, _pathAdditionEntries);
+        LoadObjects(ObjectType::SceneryGroup, _sceneryGroupEntries);
         LoadObjects(
-            OBJECT_TYPE_BANNERS,
+            ObjectType::Banners,
             std::vector<const char*>({
                 "BN1     ",
                 "BN2     ",
@@ -1888,8 +1888,8 @@ private:
                 "BN8     ",
                 "BN9     ",
             }));
-        LoadObjects(OBJECT_TYPE_PARK_ENTRANCE, std::vector<const char*>({ "PKENT1  " }));
-        LoadObjects(OBJECT_TYPE_WATER, _waterEntry);
+        LoadObjects(ObjectType::ParkEntrance, std::vector<const char*>({ "PKENT1  " }));
+        LoadObjects(ObjectType::Water, _waterEntry);
     }
 
     void LoadObjects(uint8_t objectType, const EntryList& entries)
@@ -1910,7 +1910,7 @@ private:
             entry.checksum = 0;
 
             Object* object = objectManager.LoadObject(&entry);
-            if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
+            if (object == nullptr && objectType != ObjectType::SceneryGroup)
             {
                 log_error("Failed to load %s.", objectName);
                 throw std::runtime_error("Failed to load object.");
@@ -1940,15 +1940,15 @@ private:
     std::vector<rct_object_entry> GetRequiredObjects()
     {
         std::vector<rct_object_entry> result;
-        AppendRequiredObjects(result, OBJECT_TYPE_RIDE, _rideEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_SMALL_SCENERY, _smallSceneryEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_LARGE_SCENERY, _largeSceneryEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_WALLS, _wallEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_PATHS, _pathEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_PATH_BITS, _pathAdditionEntries);
-        AppendRequiredObjects(result, OBJECT_TYPE_SCENERY_GROUP, _sceneryGroupEntries);
+        AppendRequiredObjects(result, ObjectType::Ride, _rideEntries);
+        AppendRequiredObjects(result, ObjectType::SmallScenery, _smallSceneryEntries);
+        AppendRequiredObjects(result, ObjectType::LargeScenery, _largeSceneryEntries);
+        AppendRequiredObjects(result, ObjectType::Walls, _wallEntries);
+        AppendRequiredObjects(result, ObjectType::Paths, _pathEntries);
+        AppendRequiredObjects(result, ObjectType::PathBits, _pathAdditionEntries);
+        AppendRequiredObjects(result, ObjectType::SceneryGroup, _sceneryGroupEntries);
         AppendRequiredObjects(
-            result, OBJECT_TYPE_BANNERS,
+            result, ObjectType::Banners,
             std::vector<const char*>({
                 "BN1     ",
                 "BN2     ",
@@ -1960,8 +1960,8 @@ private:
                 "BN8     ",
                 "BN9     ",
             }));
-        AppendRequiredObjects(result, OBJECT_TYPE_PARK_ENTRANCE, std::vector<const char*>({ "PKENT1  " }));
-        AppendRequiredObjects(result, OBJECT_TYPE_WATER, _waterEntry);
+        AppendRequiredObjects(result, ObjectType::ParkEntrance, std::vector<const char*>({ "PKENT1  " }));
+        AppendRequiredObjects(result, ObjectType::Water, _waterEntry);
         return result;
     }
 
@@ -1985,7 +1985,7 @@ private:
             else
             {
                 auto object = objectRepository.LoadObject(ori);
-                if (object == nullptr && objectType != OBJECT_TYPE_SCENERY_GROUP)
+                if (object == nullptr && objectType != ObjectType::SceneryGroup)
                 {
                     missingObjects.push_back(entry);
                     Console::Error::WriteLine("[%s] Object could not be loaded.", objectName);
@@ -2958,21 +2958,21 @@ private:
     {
         switch (objectType)
         {
-            case OBJECT_TYPE_RIDE:
+            case ObjectType::Ride:
                 return &_rideEntries;
-            case OBJECT_TYPE_SMALL_SCENERY:
+            case ObjectType::SmallScenery:
                 return &_smallSceneryEntries;
-            case OBJECT_TYPE_LARGE_SCENERY:
+            case ObjectType::LargeScenery:
                 return &_largeSceneryEntries;
-            case OBJECT_TYPE_WALLS:
+            case ObjectType::Walls:
                 return &_wallEntries;
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
                 return &_pathEntries;
-            case OBJECT_TYPE_PATH_BITS:
+            case ObjectType::PathBits:
                 return &_pathAdditionEntries;
-            case OBJECT_TYPE_SCENERY_GROUP:
+            case ObjectType::SceneryGroup:
                 return &_sceneryGroupEntries;
-            case OBJECT_TYPE_WATER:
+            case ObjectType::Water:
                 return &_waterEntry;
         }
         return nullptr;
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index 9608ecdb93..f2f3fbb042 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -772,7 +772,7 @@ public:
         // This stall was not colourable in RCT2.
         if (dst->type == RIDE_TYPE_FOOD_STALL)
         {
-            auto entry = object_entry_get_entry(OBJECT_TYPE_RIDE, dst->subtype);
+            auto entry = object_entry_get_entry(ObjectType::Ride, dst->subtype);
             if (entry != nullptr)
             {
                 char name[DAT_NAME_LENGTH + 1];
@@ -1679,7 +1679,7 @@ public:
         std::memset(&nullEntry, 0xFF, sizeof(nullEntry));
 
         int objectIt = 0;
-        for (int16_t objectType = OBJECT_TYPE_RIDE; objectType <= OBJECT_TYPE_WATER; objectType++)
+        for (int16_t objectType = ObjectType::Ride; objectType <= ObjectType::Water; objectType++)
         {
             for (int16_t i = 0; i < rct2_object_entry_group_counts[objectType]; i++, objectIt++)
             {
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index 4d1d8bbbec..bdbd855467 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -216,7 +216,7 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
     rct_ride_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
 
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_RIDE, index);
+    auto obj = objMgr.GetLoadedObject(ObjectType::Ride, index);
     if (obj != nullptr)
     {
         result = static_cast<rct_ride_entry*>(obj->GetLegacyData());
@@ -227,13 +227,13 @@ rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
 
 std::string_view get_ride_entry_name(ObjectEntryIndex index)
 {
-    if (index >= object_entry_group_counts[OBJECT_TYPE_RIDE])
+    if (index >= object_entry_group_counts[ObjectType::Ride])
     {
         log_error("invalid index %d for ride type", index);
         return {};
     }
 
-    auto objectEntry = object_entry_get_entry(OBJECT_TYPE_RIDE, index);
+    auto objectEntry = object_entry_get_entry(ObjectType::Ride, index);
     if (objectEntry != nullptr)
     {
         return objectEntry->GetName();
@@ -7410,7 +7410,7 @@ int32_t ride_get_entry_index(int32_t rideType, int32_t rideSubType)
 StationObject* ride_get_station_object(const Ride* ride)
 {
     auto& objManager = GetContext()->GetObjectManager();
-    return static_cast<StationObject*>(objManager.GetLoadedObject(OBJECT_TYPE_STATION, ride->entrance_style));
+    return static_cast<StationObject*>(objManager.GetLoadedObject(ObjectType::Station, ride->entrance_style));
 }
 
 // Normally, a station has at most one entrance and one exit, which are at the same height
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index 652d2368cc..ea962a3afd 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -103,7 +103,7 @@ static void track_design_preview_clear_map();
 rct_string_id TrackDesign::CreateTrackDesign(const Ride& ride)
 {
     type = ride.type;
-    auto object = object_entry_get_entry(OBJECT_TYPE_RIDE, ride.subtype);
+    auto object = object_entry_get_entry(ObjectType::Ride, ride.subtype);
 
     // Note we are only copying rct_object_entry in size and
     // not the extended as we don't need the chunk size.
@@ -499,7 +499,7 @@ rct_string_id TrackDesign::CreateTrackDesignScenery()
     {
         switch (scenery.scenery_object.GetType())
         {
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
             {
                 uint8_t slope = (scenery.flags & 0x60) >> 5;
                 slope -= _saveDirection;
@@ -516,7 +516,7 @@ rct_string_id TrackDesign::CreateTrackDesignScenery()
                 scenery.flags |= (direction & 0xF) | (direction >> 4);
                 break;
             }
-            case OBJECT_TYPE_WALLS:
+            case ObjectType::Walls:
             {
                 uint8_t direction = scenery.flags & 3;
                 direction -= _saveDirection;
@@ -672,7 +672,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
         if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entryIndex))
         {
             entry_type = scenery.scenery_object.GetType();
-            if (entry_type != OBJECT_TYPE_PATHS)
+            if (entry_type != ObjectType::Paths)
             {
                 continue;
             }
@@ -683,7 +683,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
         rct_scenery_entry* scenery_entry = static_cast<rct_scenery_entry*>(object_entry_get_chunk(entry_type, entryIndex));
         switch (entry_type)
         {
-            case OBJECT_TYPE_LARGE_SCENERY:
+            case ObjectType::LargeScenery:
             {
                 int16_t x1 = 0, x2 = 0, y1 = 0, y2 = 0;
                 for (rct_large_scenery_tile* tile = scenery_entry->large_scenery.tiles; tile->x_offset != -1; tile++)
@@ -727,7 +727,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
                 }
                 break;
             }
-            case OBJECT_TYPE_SMALL_SCENERY:
+            case ObjectType::SmallScenery:
                 scenery.y = -scenery.y;
 
                 if (scenery_small_entry_has_flag(scenery_entry, SMALL_SCENERY_FLAG_DIAGONAL))
@@ -747,7 +747,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
                 scenery.flags ^= (1 << 2);
                 break;
 
-            case OBJECT_TYPE_WALLS:
+            case ObjectType::Walls:
                 scenery.y = -scenery.y;
                 if (scenery.flags & (1 << 0))
                 {
@@ -755,7 +755,7 @@ static void track_design_mirror_scenery(TrackDesign* td6)
                 }
                 break;
 
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
                 scenery.y = -scenery.y;
 
                 if (scenery.flags & (1 << 5))
@@ -867,7 +867,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
     if (!find_object_in_entry_group(&scenery.scenery_object, &entry_type, &entry_index))
     {
         entry_type = scenery.scenery_object.GetType();
-        if (entry_type != OBJECT_TYPE_PATHS)
+        if (entry_type != ObjectType::Paths)
         {
             _trackDesignPlaceStateSceneryUnavailable = true;
             return true;
@@ -880,7 +880,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
         }
 
         entry_index = 0;
-        for (PathSurfaceEntry* path = get_path_surface_entry(0); entry_index < object_entry_group_counts[OBJECT_TYPE_PATHS];
+        for (PathSurfaceEntry* path = get_path_surface_entry(0); entry_index < object_entry_group_counts[ObjectType::Paths];
              path = get_path_surface_entry(entry_index), entry_index++)
         {
             if (path == nullptr)
@@ -893,7 +893,7 @@ static bool TrackDesignPlaceSceneryElementGetEntry(
             }
         }
 
-        if (entry_index == object_entry_group_counts[OBJECT_TYPE_PATHS])
+        if (entry_index == object_entry_group_counts[ObjectType::Paths])
         {
             _trackDesignPlaceStateSceneryUnavailable = true;
             return true;
@@ -924,7 +924,7 @@ static bool TrackDesignPlaceSceneryElementRemoveGhost(
     std::unique_ptr<GameAction> ga;
     switch (entry_type)
     {
-        case OBJECT_TYPE_SMALL_SCENERY:
+        case ObjectType::SmallScenery:
         {
             uint8_t quadrant = (scenery.flags >> 2) + _currentTrackPieceDirection;
             quadrant &= 3;
@@ -942,13 +942,13 @@ static bool TrackDesignPlaceSceneryElementRemoveGhost(
             ga = std::make_unique<SmallSceneryRemoveAction>(CoordsXYZ{ mapCoord.x, mapCoord.y, z }, quadrant, entry_index);
             break;
         }
-        case OBJECT_TYPE_LARGE_SCENERY:
+        case ObjectType::LargeScenery:
             ga = std::make_unique<LargeSceneryRemoveAction>(CoordsXYZD{ mapCoord.x, mapCoord.y, z, sceneryRotation }, 0);
             break;
-        case OBJECT_TYPE_WALLS:
+        case ObjectType::Walls:
             ga = std::make_unique<WallRemoveAction>(CoordsXYZD{ mapCoord.x, mapCoord.y, z, sceneryRotation });
             break;
-        case OBJECT_TYPE_PATHS:
+        case ObjectType::Paths:
             ga = std::make_unique<FootpathRemoveAction>(CoordsXYZ{ mapCoord.x, mapCoord.y, z });
             break;
         default:
@@ -1011,7 +1011,7 @@ static bool TrackDesignPlaceSceneryElement(
 
         switch (entry_type)
         {
-            case OBJECT_TYPE_SMALL_SCENERY:
+            case ObjectType::SmallScenery:
             {
                 if (mode != 0)
                 {
@@ -1059,7 +1059,7 @@ static bool TrackDesignPlaceSceneryElement(
                 cost = res->Error == GameActions::Status::Ok ? res->Cost : 0;
                 break;
             }
-            case OBJECT_TYPE_LARGE_SCENERY:
+            case ObjectType::LargeScenery:
             {
                 if (mode != 0)
                 {
@@ -1103,7 +1103,7 @@ static bool TrackDesignPlaceSceneryElement(
                 cost = res->Cost;
                 break;
             }
-            case OBJECT_TYPE_WALLS:
+            case ObjectType::Walls:
             {
                 if (mode != 0)
                 {
@@ -1147,7 +1147,7 @@ static bool TrackDesignPlaceSceneryElement(
                 cost = res->Cost;
                 break;
             }
-            case OBJECT_TYPE_PATHS:
+            case ObjectType::Paths:
                 if (_trackDesignPlaceOperation == PTD_OPERATION_GET_PLACE_Z)
                 {
                     return true;
diff --git a/src/openrct2/ride/TrackDesignSave.cpp b/src/openrct2/ride/TrackDesignSave.cpp
index 1c67c2cfa6..7cbb4c9cbc 100644
--- a/src/openrct2/ride/TrackDesignSave.cpp
+++ b/src/openrct2/ride/TrackDesignSave.cpp
@@ -208,7 +208,7 @@ static void track_design_save_push_tile_element_desc(
 static void track_design_save_add_scenery(const CoordsXY& loc, SmallSceneryElement* sceneryElement)
 {
     int32_t entryType = sceneryElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, entryType);
+    auto entry = object_entry_get_entry(ObjectType::SmallScenery, entryType);
 
     uint8_t flags = 0;
     flags |= sceneryElement->GetDirection();
@@ -234,7 +234,7 @@ static void track_design_save_add_large_scenery(const CoordsXY& loc, LargeScener
     }
 
     int32_t entryType = tileElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_LARGE_SCENERY, entryType);
+    auto entry = object_entry_get_entry(ObjectType::LargeScenery, entryType);
     sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
 
     int32_t z = tileElement->base_height;
@@ -276,7 +276,7 @@ static void track_design_save_add_large_scenery(const CoordsXY& loc, LargeScener
 static void track_design_save_add_wall(const CoordsXY& loc, WallElement* wallElement)
 {
     int32_t entryType = wallElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_WALLS, entryType);
+    auto entry = object_entry_get_entry(ObjectType::Walls, entryType);
 
     uint8_t flags = 0;
     flags |= wallElement->GetDirection();
@@ -293,7 +293,7 @@ static void track_design_save_add_wall(const CoordsXY& loc, WallElement* wallEle
 static void track_design_save_add_footpath(const CoordsXY& loc, PathElement* pathElement)
 {
     int32_t entryType = pathElement->GetSurfaceEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_PATHS, entryType);
+    auto entry = object_entry_get_entry(ObjectType::Paths, entryType);
 
     uint8_t flags = 0;
     flags |= pathElement->GetEdges();
@@ -395,7 +395,7 @@ static void track_design_save_pop_tile_element_desc(const rct_object_entry* entr
 static void track_design_save_remove_scenery(const CoordsXY& loc, SmallSceneryElement* sceneryElement)
 {
     int32_t entryType = sceneryElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, entryType);
+    auto entry = object_entry_get_entry(ObjectType::SmallScenery, entryType);
 
     uint8_t flags = 0;
     flags |= sceneryElement->GetDirection();
@@ -417,7 +417,7 @@ static void track_design_save_remove_large_scenery(const CoordsXY& loc, LargeSce
     }
 
     int32_t entryType = tileElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_LARGE_SCENERY, entryType);
+    auto entry = object_entry_get_entry(ObjectType::LargeScenery, entryType);
     sceneryTiles = get_large_scenery_entry(entryType)->large_scenery.tiles;
 
     int32_t z = tileElement->base_height;
@@ -456,7 +456,7 @@ static void track_design_save_remove_large_scenery(const CoordsXY& loc, LargeSce
 static void track_design_save_remove_wall(const CoordsXY& loc, WallElement* wallElement)
 {
     int32_t entryType = wallElement->GetEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_WALLS, entryType);
+    auto entry = object_entry_get_entry(ObjectType::Walls, entryType);
 
     uint8_t flags = 0;
     flags |= wallElement->GetDirection();
@@ -469,7 +469,7 @@ static void track_design_save_remove_wall(const CoordsXY& loc, WallElement* wall
 static void track_design_save_remove_footpath(const CoordsXY& loc, PathElement* pathElement)
 {
     int32_t entryType = pathElement->GetSurfaceEntryIndex();
-    auto entry = object_entry_get_entry(OBJECT_TYPE_PATHS, entryType);
+    auto entry = object_entry_get_entry(ObjectType::Paths, entryType);
 
     uint8_t flags = 0;
     flags |= pathElement->GetEdges();
diff --git a/src/openrct2/scenario/Scenario.cpp b/src/openrct2/scenario/Scenario.cpp
index 7ff2e593e8..99759b02e9 100644
--- a/src/openrct2/scenario/Scenario.cpp
+++ b/src/openrct2/scenario/Scenario.cpp
@@ -323,7 +323,7 @@ static void scenario_week_update()
     ride_check_all_reachable();
     ride_update_favourited_stat();
 
-    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(OBJECT_TYPE_WATER, 0));
+    auto water_type = static_cast<rct_water_type*>(object_entry_get_chunk(ObjectType::Water, 0));
 
     if (month <= MONTH_APRIL && water_type != nullptr && water_type->flags & WATER_FLAGS_ALLOW_DUCKS)
     {
diff --git a/src/openrct2/scripting/ScContext.hpp b/src/openrct2/scripting/ScContext.hpp
index 7cd6bdd227..bb68387bc0 100644
--- a/src/openrct2/scripting/ScContext.hpp
+++ b/src/openrct2/scripting/ScContext.hpp
@@ -89,9 +89,9 @@ namespace OpenRCT2::Scripting
         {
             switch (type)
             {
-                case OBJECT_TYPE_RIDE:
+                case ObjectType::Ride:
                     return GetObjectAsDukValue(ctx, std::make_shared<ScRideObject>(type, index));
-                case OBJECT_TYPE_SMALL_SCENERY:
+                case ObjectType::SmallScenery:
                     return GetObjectAsDukValue(ctx, std::make_shared<ScSmallSceneryObject>(type, index));
                 default:
                     return GetObjectAsDukValue(ctx, std::make_shared<ScObject>(type, index));
diff --git a/src/openrct2/scripting/ScObject.hpp b/src/openrct2/scripting/ScObject.hpp
index 24bee9d53a..d9ce0c62e2 100644
--- a/src/openrct2/scripting/ScObject.hpp
+++ b/src/openrct2/scripting/ScObject.hpp
@@ -47,7 +47,7 @@ namespace OpenRCT2::Scripting
 
         static std::optional<uint8_t> StringToObjectType(const std::string_view& type)
         {
-            for (uint8_t i = 0; i < OBJECT_TYPE_COUNT; i++)
+            for (uint8_t i = 0; i < ObjectType::Count; i++)
             {
                 auto s = ObjectTypeToString(i);
                 if (s == type)
@@ -120,12 +120,12 @@ namespace OpenRCT2::Scripting
     class ScRideObjectVehicle
     {
     private:
-        OBJECT_TYPE _objectType{};
+        ObjectType _objectType{};
         ObjectEntryIndex _objectIndex{};
         size_t _vehicleIndex{};
 
     public:
-        ScRideObjectVehicle(OBJECT_TYPE objectType, ObjectEntryIndex objectIndex, size_t vehicleIndex)
+        ScRideObjectVehicle(ObjectType objectType, ObjectEntryIndex objectIndex, size_t vehicleIndex)
             : _objectType(objectType)
             , _objectIndex(objectIndex)
             , _vehicleIndex(vehicleIndex)
@@ -836,7 +836,7 @@ namespace OpenRCT2::Scripting
             {
                 for (size_t i = 0; i < std::size(entry->vehicles); i++)
                 {
-                    result.push_back(std::make_shared<ScRideObjectVehicle>(static_cast<OBJECT_TYPE>(_type), _index, i));
+                    result.push_back(std::make_shared<ScRideObjectVehicle>(static_cast<ObjectType>(_type), _index, i));
                 }
             }
             return result;
diff --git a/src/openrct2/scripting/ScRide.hpp b/src/openrct2/scripting/ScRide.hpp
index 8f0838bb5f..33adccd4da 100644
--- a/src/openrct2/scripting/ScRide.hpp
+++ b/src/openrct2/scripting/ScRide.hpp
@@ -196,10 +196,10 @@ namespace OpenRCT2::Scripting
             auto ride = GetRide();
             if (ride != nullptr)
             {
-                auto rideObject = GetContext()->GetObjectManager().GetLoadedObject(OBJECT_TYPE_RIDE, ride->subtype);
+                auto rideObject = GetContext()->GetObjectManager().GetLoadedObject(ObjectType::Ride, ride->subtype);
                 if (rideObject != nullptr)
                 {
-                    return std::make_shared<ScRideObject>(OBJECT_TYPE_RIDE, ride->subtype);
+                    return std::make_shared<ScRideObject>(ObjectType::Ride, ride->subtype);
                 }
             }
             return nullptr;
diff --git a/src/openrct2/world/Footpath.cpp b/src/openrct2/world/Footpath.cpp
index b1a4db7eae..24ba945fa8 100644
--- a/src/openrct2/world/Footpath.cpp
+++ b/src/openrct2/world/Footpath.cpp
@@ -2177,7 +2177,7 @@ PathSurfaceEntry* get_path_surface_entry(PathSurfaceIndex entryIndex)
     PathSurfaceEntry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
     // TODO: Change when moving to the new save format.
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATHS, entryIndex % MAX_PATH_OBJECTS);
+    auto obj = objMgr.GetLoadedObject(ObjectType::Paths, entryIndex % MAX_PATH_OBJECTS);
     if (obj != nullptr)
     {
         if (entryIndex < MAX_PATH_OBJECTS)
@@ -2192,7 +2192,7 @@ PathRailingsEntry* get_path_railings_entry(PathRailingsIndex entryIndex)
 {
     PathRailingsEntry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATHS, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::Paths, entryIndex);
     if (obj != nullptr)
     {
         result = (static_cast<FootpathObject*>(obj))->GetPathRailingsEntry();
diff --git a/src/openrct2/world/LargeScenery.cpp b/src/openrct2/world/LargeScenery.cpp
index 8dc76b9b69..32e5c510d8 100644
--- a/src/openrct2/world/LargeScenery.cpp
+++ b/src/openrct2/world/LargeScenery.cpp
@@ -98,7 +98,7 @@ rct_scenery_entry* get_large_scenery_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_LARGE_SCENERY, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::LargeScenery, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
diff --git a/src/openrct2/world/MapGen.cpp b/src/openrct2/world/MapGen.cpp
index d9f6dad836..f6731bb1e5 100644
--- a/src/openrct2/world/MapGen.cpp
+++ b/src/openrct2/world/MapGen.cpp
@@ -260,10 +260,10 @@ static void mapgen_place_trees()
     std::vector<int32_t> desertTreeIds(std::size(DesertTrees), 0);
     std::vector<int32_t> snowTreeIds(std::size(SnowTrees), 0);
 
-    for (int32_t i = 0; i < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]; i++)
+    for (int32_t i = 0; i < object_entry_group_counts[ObjectType::SmallScenery]; i++)
     {
         auto sceneryEntry = get_small_scenery_entry(i);
-        auto entry = object_entry_get_entry(OBJECT_TYPE_SMALL_SCENERY, i);
+        auto entry = object_entry_get_entry(ObjectType::SmallScenery, i);
 
         if (sceneryEntry == nullptr)
             continue;
diff --git a/src/openrct2/world/Scenery.cpp b/src/openrct2/world/Scenery.cpp
index 5a928895d7..aae9b07afa 100644
--- a/src/openrct2/world/Scenery.cpp
+++ b/src/openrct2/world/Scenery.cpp
@@ -233,7 +233,7 @@ rct_scenery_entry* get_wall_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_WALLS, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::Walls, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@@ -245,7 +245,7 @@ rct_scenery_entry* get_banner_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_BANNERS, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::Banners, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@@ -257,7 +257,7 @@ rct_scenery_entry* get_footpath_item_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_PATH_BITS, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::PathBits, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
@@ -269,7 +269,7 @@ rct_scenery_group_entry* get_scenery_group_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_group_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_SCENERY_GROUP, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::SceneryGroup, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_group_entry*>(obj->GetLegacyData());
diff --git a/src/openrct2/world/SmallScenery.cpp b/src/openrct2/world/SmallScenery.cpp
index 9cac231ca9..9179d8b882 100644
--- a/src/openrct2/world/SmallScenery.cpp
+++ b/src/openrct2/world/SmallScenery.cpp
@@ -177,7 +177,7 @@ rct_scenery_entry* get_small_scenery_entry(ObjectEntryIndex entryIndex)
 {
     rct_scenery_entry* result = nullptr;
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_SMALL_SCENERY, entryIndex);
+    auto obj = objMgr.GetLoadedObject(ObjectType::SmallScenery, entryIndex);
     if (obj != nullptr)
     {
         result = static_cast<rct_scenery_entry*>(obj->GetLegacyData());
diff --git a/src/openrct2/world/Surface.cpp b/src/openrct2/world/Surface.cpp
index dad84eaf00..b9c5773ca5 100644
--- a/src/openrct2/world/Surface.cpp
+++ b/src/openrct2/world/Surface.cpp
@@ -25,7 +25,7 @@ uint32_t SurfaceElement::GetSurfaceStyle() const
 TerrainSurfaceObject* SurfaceElement::GetSurfaceStyleObject() const
 {
     auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
-    return static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, GetSurfaceStyle()));
+    return static_cast<TerrainSurfaceObject*>(objManager.GetLoadedObject(ObjectType::TerrainSurface, GetSurfaceStyle()));
 }
 
 uint32_t SurfaceElement::GetEdgeStyle() const
@@ -36,7 +36,7 @@ uint32_t SurfaceElement::GetEdgeStyle() const
 TerrainEdgeObject* SurfaceElement::GetEdgeStyleObject() const
 {
     auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
-    return static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(OBJECT_TYPE_TERRAIN_EDGE, GetEdgeStyle()));
+    return static_cast<TerrainEdgeObject*>(objManager.GetLoadedObject(ObjectType::TerrainEdge, GetEdgeStyle()));
 }
 
 void SurfaceElement::SetSurfaceStyle(uint32_t newStyle)
@@ -63,7 +63,7 @@ bool SurfaceElement::CanGrassGrow() const
 {
     auto surfaceStyle = GetSurfaceStyle();
     auto& objMgr = OpenRCT2::GetContext()->GetObjectManager();
-    auto obj = objMgr.GetLoadedObject(OBJECT_TYPE_TERRAIN_SURFACE, surfaceStyle);
+    auto obj = objMgr.GetLoadedObject(ObjectType::TerrainSurface, surfaceStyle);
     if (obj != nullptr)
     {
         auto surfaceObject = static_cast<TerrainSurfaceObject*>(obj);
diff --git a/test/testpaint/Compat.cpp b/test/testpaint/Compat.cpp
index e4c6d4b56f..18935c2b05 100644
--- a/test/testpaint/Compat.cpp
+++ b/test/testpaint/Compat.cpp
@@ -127,7 +127,7 @@ Ride* get_ride(ride_id_t index)
 
 rct_ride_entry* get_ride_entry(ObjectEntryIndex index)
 {
-    if (index >= object_entry_group_counts[OBJECT_TYPE_RIDE])
+    if (index >= object_entry_group_counts[ObjectType::OBJECT_TYPE_RIDE])
     {
         log_error("invalid index %d for ride type", index);
         return nullptr;