diff --git a/src/openrct2-ui/windows/Ride.cpp b/src/openrct2-ui/windows/Ride.cpp
index ddcebbfc03..f435de4566 100644
--- a/src/openrct2-ui/windows/Ride.cpp
+++ b/src/openrct2-ui/windows/Ride.cpp
@@ -506,12 +506,12 @@ static_assert(std::size(RatingNames) == 6);
 
     // Used in other places as well
     const StringId ColourSchemeNames[4] = {
-        STR_MAIN_COLOUR_SCHEME,          // RIDE_COLOUR_SCHEME_MAIN
-        STR_ALTERNATIVE_COLOUR_SCHEME_1, // RIDE_COLOUR_SCHEME_ADDITIONAL_1
-        STR_ALTERNATIVE_COLOUR_SCHEME_2, // RIDE_COLOUR_SCHEME_ADDITIONAL_2
-        STR_ALTERNATIVE_COLOUR_SCHEME_3, // RIDE_COLOUR_SCHEME_ADDITIONAL_3
+        STR_MAIN_COLOUR_SCHEME,          // RideColourScheme::main
+        STR_ALTERNATIVE_COLOUR_SCHEME_1, // RideColourScheme::additional1
+        STR_ALTERNATIVE_COLOUR_SCHEME_2, // RideColourScheme::additional2
+        STR_ALTERNATIVE_COLOUR_SCHEME_3, // RideColourScheme::additional3
     };
-    static_assert(std::size(ColourSchemeNames) == RIDE_COLOUR_SCHEME_COUNT);
+    static_assert(std::size(ColourSchemeNames) == kNumRideColourSchemes);
 
     static constexpr std::array VehicleLoadNames = {
         static_cast<StringId>(STR_QUARTER_LOAD),       //  WAIT_FOR_LOAD_QUARTER
@@ -523,11 +523,11 @@ static_assert(std::size(RatingNames) == 6);
     static_assert(std::size(VehicleLoadNames) == WAIT_FOR_LOAD_COUNT);
 
     static constexpr std::array VehicleColourSchemeNames = {
-        static_cast<StringId>(STR_ALL_VEHICLES_IN_SAME_COLOURS),  // RIDE_COLOUR_SCHEME_MODE_ALL_SAME,
-        static_cast<StringId>(STR_DIFFERENT_COLOURS_PER),         // RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN,
-        static_cast<StringId>(STR_DIFFERENT_COLOURS_PER_VEHICLE), // RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR,
+        static_cast<StringId>(STR_ALL_VEHICLES_IN_SAME_COLOURS),  // VehicleColourSettings::same,
+        static_cast<StringId>(STR_DIFFERENT_COLOURS_PER),         // VehicleColourSettings::perTrain,
+        static_cast<StringId>(STR_DIFFERENT_COLOURS_PER_VEHICLE), // VehicleColourSettings::perCar,
     };
-    static_assert(std::size(VehicleColourSchemeNames) == RIDE_COLOUR_SCHEME_MODE_COUNT);
+    static_assert(std::size(VehicleColourSchemeNames) == kNumVehicleColourSettings);
 
     static constexpr std::array VehicleStatusNames = {
         static_cast<StringId>(STR_MOVING_TO_END_OF),          // Vehicle::Status::MovingToEndOfStation
@@ -1202,7 +1202,7 @@ static_assert(std::size(RatingNames) == 6);
                 const auto vehicle = RideEntryGetVehicleAtPosition(ride->subtype, ride->num_cars_per_train, rideEntry->TabCar);
                 const auto& carEntry = rideEntry->Cars[vehicle];
 
-                auto vehicleId = ((ride->colour_scheme_type & 3) == VEHICLE_COLOUR_SCHEME_PER_VEHICLE) ? rideEntry->TabCar : 0;
+                auto vehicleId = (ride->vehicleColourSettings == VehicleColourSettings::perCar) ? rideEntry->TabCar : 0;
                 VehicleColour vehicleColour = RideGetVehicleColour(*ride, vehicleId);
 
                 // imageIndex represents a precision of 64
@@ -2915,15 +2915,15 @@ static_assert(std::size(RatingNames) == 6);
 
                     // Get colour of vehicle
                     int32_t vehicleColourIndex = 0;
-                    switch (ride->colour_scheme_type & 3)
+                    switch (ride->vehicleColourSettings)
                     {
-                        case VEHICLE_COLOUR_SCHEME_SAME:
+                        case VehicleColourSettings::same:
                             vehicleColourIndex = 0;
                             break;
-                        case VEHICLE_COLOUR_SCHEME_PER_TRAIN:
+                        case VehicleColourSettings::perTrain:
                             vehicleColourIndex = i;
                             break;
-                        case VEHICLE_COLOUR_SCHEME_PER_VEHICLE:
+                        case VehicleColourSettings::perCar:
                             vehicleColourIndex = carIndex;
                             break;
                     }
@@ -4176,7 +4176,7 @@ static_assert(std::size(RatingNames) == 6);
         void ColourOnMouseDown(WidgetIndex widgetIndex)
         {
             VehicleColour vehicleColour;
-            int32_t i, numItems;
+            int32_t numItems;
             StringId stringId;
 
             auto ride = GetRide(rideId);
@@ -4193,7 +4193,8 @@ static_assert(std::size(RatingNames) == 6);
             switch (widgetIndex)
             {
                 case WIDX_TRACK_COLOUR_SCHEME_DROPDOWN:
-                    for (i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
+                {
+                    for (size_t i = 0; i < std::size(ColourSchemeNames); i++)
                     {
                         gDropdownItems[i].Format = STR_DROPDOWN_MENU_LABEL;
                         gDropdownItems[i].Args = ColourSchemeNames[i];
@@ -4205,6 +4206,7 @@ static_assert(std::size(RatingNames) == 6);
 
                     Dropdown::SetChecked(colourSchemeIndex, true);
                     break;
+                }
                 case WIDX_TRACK_MAIN_COLOUR:
                     WindowDropdownShowColour(
                         this, &widgets[widgetIndex], colours[1], ride->track_colour[colourSchemeIndex].main);
@@ -4218,7 +4220,8 @@ static_assert(std::size(RatingNames) == 6);
                         this, &widgets[widgetIndex], colours[1], ride->track_colour[colourSchemeIndex].supports);
                     break;
                 case WIDX_MAZE_STYLE_DROPDOWN:
-                    for (i = 0; i < 4; i++)
+                {
+                    for (auto i = 0; i < 4; i++)
                     {
                         gDropdownItems[i].Format = STR_DROPDOWN_MENU_LABEL;
                         gDropdownItems[i].Args = MazeOptions[i].text;
@@ -4230,11 +4233,13 @@ static_assert(std::size(RatingNames) == 6);
 
                     Dropdown::SetChecked(ride->track_colour[colourSchemeIndex].supports, true);
                     break;
+                }
                 case WIDX_ENTRANCE_STYLE_DROPDOWN:
                     ShowEntranceStyleDropdown();
                     break;
                 case WIDX_VEHICLE_COLOUR_SCHEME_DROPDOWN:
-                    for (i = 0; i < 3; i++)
+                {
+                    for (auto i = 0; i < 3; i++)
                     {
                         gDropdownItems[i].Format = STR_DROPDOWN_MENU_LABEL;
                         gDropdownItems[i].Args = (GetRideComponentName(ride->GetRideTypeDescriptor().NameConvention.vehicle)
@@ -4248,17 +4253,18 @@ static_assert(std::size(RatingNames) == 6);
                         colours[1], 0, Dropdown::Flag::StayOpen, rideEntry->max_cars_in_train > 1 ? 3 : 2,
                         widgets[widgetIndex].right - dropdownWidget->left);
 
-                    Dropdown::SetChecked(ride->colour_scheme_type & 3, true);
+                    Dropdown::SetChecked(EnumValue(ride->vehicleColourSettings), true);
                     break;
+                }
                 case WIDX_VEHICLE_COLOUR_INDEX_DROPDOWN:
+                {
                     numItems = ride->NumTrains;
-                    if ((ride->colour_scheme_type & 3) != VEHICLE_COLOUR_SCHEME_PER_TRAIN)
+                    if (ride->vehicleColourSettings != VehicleColourSettings::perTrain)
                         numItems = ride->num_cars_per_train;
 
-                    stringId = (ride->colour_scheme_type & 3) == VEHICLE_COLOUR_SCHEME_PER_TRAIN
-                        ? STR_RIDE_COLOUR_TRAIN_OPTION
-                        : STR_RIDE_COLOUR_VEHICLE_OPTION;
-                    for (i = 0; i < std::min(numItems, Dropdown::ItemsMaxSize); i++)
+                    stringId = ride->vehicleColourSettings == VehicleColourSettings::perTrain ? STR_RIDE_COLOUR_TRAIN_OPTION
+                                                                                              : STR_RIDE_COLOUR_VEHICLE_OPTION;
+                    for (auto i = 0; i < std::min(numItems, Dropdown::ItemsMaxSize); i++)
                     {
                         gDropdownItems[i].Format = STR_DROPDOWN_MENU_LABEL;
                         gDropdownItems[i].Args = (static_cast<int64_t>(i + 1) << 32)
@@ -4272,6 +4278,7 @@ static_assert(std::size(RatingNames) == 6);
 
                     Dropdown::SetChecked(_vehicleIndex, true);
                     break;
+                }
                 case WIDX_VEHICLE_BODY_COLOUR:
                     vehicleColour = RideGetVehicleColour(*ride, _vehicleIndex);
                     WindowDropdownShowColour(this, &widgets[widgetIndex], colours[1], vehicleColour.Body);
@@ -4549,8 +4556,7 @@ static_assert(std::size(RatingNames) == 6);
             if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES)
                 && ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_VEHICLE_COLOURS))
             {
-                int32_t vehicleColourSchemeType = ride->colour_scheme_type & 3;
-                if (vehicleColourSchemeType == 0)
+                if (ride->vehicleColourSettings == VehicleColourSettings::same)
                     _vehicleIndex = 0;
 
                 vehicleColour = RideGetVehicleColour(*ride, _vehicleIndex);
@@ -4611,18 +4617,19 @@ static_assert(std::size(RatingNames) == 6);
                 }
                 ft.Rewind();
                 ft.Increment(6);
-                ft.Add<StringId>(VehicleColourSchemeNames[vehicleColourSchemeType]);
+                ft.Add<StringId>(VehicleColourSchemeNames[EnumValue(ride->vehicleColourSettings)]);
                 ft.Add<StringId>(GetRideComponentName(ride->GetRideTypeDescriptor().NameConvention.vehicle).singular);
                 ft.Add<StringId>(GetRideComponentName(ride->GetRideTypeDescriptor().NameConvention.vehicle).capitalised);
                 ft.Add<uint16_t>(_vehicleIndex + 1);
 
                 // Vehicle index
-                if (vehicleColourSchemeType != 0)
+                if (ride->vehicleColourSettings != VehicleColourSettings::same)
                 {
                     widgets[WIDX_VEHICLE_COLOUR_INDEX].type = WindowWidgetType::DropdownMenu;
                     widgets[WIDX_VEHICLE_COLOUR_INDEX_DROPDOWN].type = WindowWidgetType::Button;
-                    widgets[WIDX_VEHICLE_COLOUR_INDEX].text = vehicleColourSchemeType == 1 ? STR_RIDE_COLOUR_TRAIN_VALUE
-                                                                                           : STR_RIDE_COLOUR_VEHICLE_VALUE;
+                    widgets[WIDX_VEHICLE_COLOUR_INDEX].text = ride->vehicleColourSettings == VehicleColourSettings::perTrain
+                        ? STR_RIDE_COLOUR_TRAIN_VALUE
+                        : STR_RIDE_COLOUR_VEHICLE_VALUE;
                 }
                 else
                 {
@@ -4788,9 +4795,8 @@ static_assert(std::size(RatingNames) == 6);
             auto screenCoords = ScreenCoordsXY{ vehiclePreviewWidget->width() / 2, vehiclePreviewWidget->height() - 15 };
 
             // ?
-            auto trainCarIndex = (ride->colour_scheme_type & 3) == RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR
-                ? _vehicleIndex
-                : rideEntry->TabCar;
+            auto trainCarIndex = ride->vehicleColourSettings == VehicleColourSettings::perCar ? _vehicleIndex
+                                                                                              : rideEntry->TabCar;
 
             const auto& carEntry = rideEntry->Cars[RideEntryGetVehicleAtPosition(
                 ride->subtype, ride->num_cars_per_train, trainCarIndex)];
diff --git a/src/openrct2-ui/windows/RideConstruction.cpp b/src/openrct2-ui/windows/RideConstruction.cpp
index 746ee3e2f2..15c2cb64c8 100644
--- a/src/openrct2-ui/windows/RideConstruction.cpp
+++ b/src/openrct2-ui/windows/RideConstruction.cpp
@@ -2655,7 +2655,7 @@ static Widget _rideConstructionWidgets[] = {
             tempTrackTileElement.AsTrack()->SetRideType(currentRide->type);
             tempTrackTileElement.AsTrack()->SetHasCableLift(false);
             tempTrackTileElement.AsTrack()->SetInverted((liftHillAndInvertedState & CONSTRUCTION_INVERTED_TRACK_SELECTED) != 0);
-            tempTrackTileElement.AsTrack()->SetColourScheme(RIDE_COLOUR_SCHEME_MAIN);
+            tempTrackTileElement.AsTrack()->SetColourScheme(RideColourScheme::main);
             // Skipping seat rotation, should not be necessary for a temporary piece.
             tempTrackTileElement.AsTrack()->SetRideIndex(rideIndex);
 
diff --git a/src/openrct2/Limits.h b/src/openrct2/Limits.h
index 90d407bce3..10d5a3d6a1 100644
--- a/src/openrct2/Limits.h
+++ b/src/openrct2/Limits.h
@@ -29,7 +29,6 @@ namespace OpenRCT2::Limits
     static_assert(kMaxVehicleColours >= kMaxCarsPerTrain);
     constexpr uint8_t kMaxCircuitsPerRide = 20;
     constexpr uint8_t kMaxAwards = RCT12::Limits::kMaxAwards;
-    constexpr uint8_t kNumColourSchemes = RCT12::Limits::kNumColourSchemes;
     constexpr uint8_t kDowntimeHistorySize = RCT2::Limits::kDowntimeHistorySize;
     constexpr uint16_t kMaxPeepSpawns = 256;
     constexpr uint16_t kMaxParkEntrances = 256;
diff --git a/src/openrct2/actions/RideSetAppearanceAction.cpp b/src/openrct2/actions/RideSetAppearanceAction.cpp
index 3d6582103c..5527c20353 100644
--- a/src/openrct2/actions/RideSetAppearanceAction.cpp
+++ b/src/openrct2/actions/RideSetAppearanceAction.cpp
@@ -128,9 +128,7 @@ GameActions::Result RideSetAppearanceAction::Execute() const
             RideUpdateVehicleColours(*ride);
             break;
         case RideSetAppearanceType::VehicleColourScheme:
-            ride->colour_scheme_type &= ~(
-                RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN | RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR);
-            ride->colour_scheme_type |= _value;
+            ride->vehicleColourSettings = static_cast<VehicleColourSettings>(_value);
             for (uint32_t i = 1; i < std::size(ride->vehicle_colours); i++)
             {
                 ride->vehicle_colours[i] = ride->vehicle_colours[0];
diff --git a/src/openrct2/actions/RideSetColourSchemeAction.cpp b/src/openrct2/actions/RideSetColourSchemeAction.cpp
index 13831b02c2..d0fe301bca 100644
--- a/src/openrct2/actions/RideSetColourSchemeAction.cpp
+++ b/src/openrct2/actions/RideSetColourSchemeAction.cpp
@@ -64,7 +64,7 @@ GameActions::Result RideSetColourSchemeAction::Query() const
                 GameActions::Status::InvalidParameters, STR_CANT_SET_COLOUR_SCHEME, STR_INVALID_TRACK_PARAMETERS);
         }
     }
-    if (_newColourScheme >= OpenRCT2::Limits::kNumColourSchemes)
+    if (_newColourScheme >= kNumRideColourSchemes)
     {
         return GameActions::Result(
             GameActions::Status::InvalidParameters, STR_CANT_SET_COLOUR_SCHEME, STR_INVALID_COLOUR_SCHEME_PARAMETER);
diff --git a/src/openrct2/actions/TrackDesignAction.cpp b/src/openrct2/actions/TrackDesignAction.cpp
index 17bc207a0b..b07a911c82 100644
--- a/src/openrct2/actions/TrackDesignAction.cpp
+++ b/src/openrct2/actions/TrackDesignAction.cpp
@@ -245,24 +245,22 @@ GameActions::Result TrackDesignAction::Execute() const
     SetOperatingSettingNested(ride->id, RideSetSetting::NumCircuits, num_circuits, GAME_COMMAND_FLAG_APPLY);
     ride->SetToDefaultInspectionInterval();
     ride->lifecycle_flags |= RIDE_LIFECYCLE_NOT_CUSTOM_DESIGN;
-    ride->colour_scheme_type = _td.colourScheme;
+    ride->vehicleColourSettings = _td.appearance.vehicleColourSettings;
 
-    ride->entrance_style = objManager.GetLoadedObjectEntryIndex(_td.stationObjectIdentifier);
+    ride->entrance_style = objManager.GetLoadedObjectEntryIndex(_td.appearance.stationObjectIdentifier);
     if (ride->entrance_style == OBJECT_ENTRY_INDEX_NULL)
     {
         ride->entrance_style = gameState.LastEntranceStyle;
     }
 
-    for (int32_t i = 0; i < Limits::kNumColourSchemes; i++)
+    for (size_t i = 0; i < std::min(std::size(ride->track_colour), std::size(_td.appearance.trackColours)); i++)
     {
-        ride->track_colour[i].main = _td.trackSpineColour[i];
-        ride->track_colour[i].additional = _td.trackRailColour[i];
-        ride->track_colour[i].supports = _td.trackSupportColour[i];
+        ride->track_colour[i] = _td.appearance.trackColours[i];
     }
 
     for (size_t i = 0; i < Limits::kMaxVehicleColours; i++)
     {
-        ride->vehicle_colours[i] = _td.vehicleColours[i];
+        ride->vehicle_colours[i] = _td.appearance.vehicleColours[i];
     }
 
     for (int32_t count = 1; count == 1 || r.Error != GameActions::Status::Ok; ++count)
diff --git a/src/openrct2/actions/TrackPlaceAction.cpp b/src/openrct2/actions/TrackPlaceAction.cpp
index e719fc20f1..2c769483fc 100644
--- a/src/openrct2/actions/TrackPlaceAction.cpp
+++ b/src/openrct2/actions/TrackPlaceAction.cpp
@@ -624,7 +624,7 @@ GameActions::Result TrackPlaceAction::Execute() const
         {
             trackElement->SetInverted(true);
         }
-        trackElement->SetColourScheme(_colour);
+        trackElement->SetColourScheme(static_cast<RideColourScheme>(_colour));
 
         entranceDirections = std::get<0>(ted.SequenceProperties);
         if (entranceDirections & TRACK_SEQUENCE_FLAG_CONNECTS_TO_PATH)
diff --git a/src/openrct2/core/DataSerialiserTraits.h b/src/openrct2/core/DataSerialiserTraits.h
index e828ff5b85..ca20fecd16 100644
--- a/src/openrct2/core/DataSerialiserTraits.h
+++ b/src/openrct2/core/DataSerialiserTraits.h
@@ -779,6 +779,29 @@ template<> struct DataSerializerTraitsT<TrackDesignSceneryElement>
     }
 };
 
+template<> struct DataSerializerTraitsT<TrackColour>
+{
+    static void encode(OpenRCT2::IStream* stream, const TrackColour& val)
+    {
+        stream->Write(&val.main);
+        stream->Write(&val.additional);
+        stream->Write(&val.supports);
+    }
+    static void decode(OpenRCT2::IStream* stream, TrackColour& val)
+    {
+        stream->Read(&val.main);
+        stream->Read(&val.additional);
+        stream->Read(&val.supports);
+    }
+    static void log(OpenRCT2::IStream* stream, const TrackColour& val)
+    {
+        char msg[128] = {};
+        snprintf(
+            msg, sizeof(msg), "TrackColour(main = %d, additional = %d, supports = %d)", val.main, val.additional, val.supports);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
 template<> struct DataSerializerTraitsT<VehicleColour>
 {
     static void encode(OpenRCT2::IStream* stream, const VehicleColour& val)
diff --git a/src/openrct2/park/ParkFile.cpp b/src/openrct2/park/ParkFile.cpp
index 7d2a8a69fa..15f44f3a16 100644
--- a/src/openrct2/park/ParkFile.cpp
+++ b/src/openrct2/park/ParkFile.cpp
@@ -1322,7 +1322,7 @@ namespace OpenRCT2
 
                     // Colours
                     cs.ReadWrite(ride.entrance_style);
-                    cs.ReadWrite(ride.colour_scheme_type);
+                    cs.ReadWrite(ride.vehicleColourSettings);
                     cs.ReadWriteArray(ride.track_colour, [&cs](TrackColour& tc) {
                         cs.ReadWrite(tc.main);
                         cs.ReadWrite(tc.additional);
diff --git a/src/openrct2/rct1/RCT1.h b/src/openrct2/rct1/RCT1.h
index 4394cab98f..457b991ad7 100644
--- a/src/openrct2/rct1/RCT1.h
+++ b/src/openrct2/rct1/RCT1.h
@@ -15,6 +15,8 @@
 #include "../world/Park.h"
 #include "Limits.h"
 
+enum class VehicleColourSettings : uint8_t;
+
 namespace RCT1
 {
     constexpr uint8_t RCT1ResearchFlagsSeparator = 0xFF;
@@ -237,11 +239,11 @@ namespace RCT1
      */
     struct Ride
     {
-        RideType Type;                 // 0x000
-        RCT1::VehicleType VehicleType; // 0x001
-        uint16_t LifecycleFlags;       // 0x002
-        uint8_t OperatingMode;         // 0x004
-        uint8_t ColourScheme;          // 0x005
+        RideType Type;                               // 0x000
+        RCT1::VehicleType VehicleType;               // 0x001
+        uint16_t LifecycleFlags;                     // 0x002
+        uint8_t OperatingMode;                       // 0x004
+        VehicleColourSettings vehicleColourSettings; // 0x005
         struct
         {
             colour_t Body;
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index 7bded8c269..14f047e9f7 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -1090,7 +1090,7 @@ namespace RCT1
         void SetRideColourScheme(::Ride* dst, RCT1::Ride* src)
         {
             // Colours
-            dst->colour_scheme_type = src->ColourScheme;
+            dst->vehicleColourSettings = src->vehicleColourSettings;
             if (_gameVersion == FILE_VERSION_RCT1)
             {
                 dst->track_colour[0].main = RCT1::GetColour(src->TrackPrimaryColour);
diff --git a/src/openrct2/rct1/T4Importer.cpp b/src/openrct2/rct1/T4Importer.cpp
index 16f4f48f3a..1b2bb8078e 100644
--- a/src/openrct2/rct1/T4Importer.cpp
+++ b/src/openrct2/rct1/T4Importer.cpp
@@ -89,9 +89,9 @@ namespace RCT1
 
             for (int32_t i = 0; i < Limits::kNumColourSchemes; i++)
             {
-                td->trackSpineColour[i] = RCT1::GetColour(td4aa.TrackSpineColour[i]);
-                td->trackRailColour[i] = RCT1::GetColour(td4aa.TrackRailColour[i]);
-                td->trackSupportColour[i] = RCT1::GetColour(td4aa.TrackSupportColour[i]);
+                td->appearance.trackColours[i].main = RCT1::GetColour(td4aa.TrackSpineColour[i]);
+                td->appearance.trackColours[i].additional = RCT1::GetColour(td4aa.TrackRailColour[i]);
+                td->appearance.trackColours[i].supports = RCT1::GetColour(td4aa.TrackSupportColour[i]);
             }
 
             return ImportTD4Base(std::move(td), td4aa);
@@ -102,21 +102,21 @@ namespace RCT1
             std::unique_ptr<TrackDesign> td = std::make_unique<TrackDesign>();
             TD4 td4{};
             _stream.Read(&td4, sizeof(TD4));
-            for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
+            for (size_t i = 0; i < std::size(td->appearance.trackColours); i++)
             {
-                td->trackSpineColour[i] = RCT1::GetColour(td4.TrackSpineColourV0);
-                td->trackRailColour[i] = RCT1::GetColour(td4.TrackRailColourV0);
-                td->trackSupportColour[i] = RCT1::GetColour(td4.TrackSupportColourV0);
+                td->appearance.trackColours[i].main = RCT1::GetColour(td4.TrackSpineColourV0);
+                td->appearance.trackColours[i].additional = RCT1::GetColour(td4.TrackRailColourV0);
+                td->appearance.trackColours[i].supports = RCT1::GetColour(td4.TrackSupportColourV0);
 
                 // Mazes were only hedges
                 if (td4.Type == RideType::HedgeMaze)
                 {
-                    td->trackSupportColour[i] = MAZE_WALL_TYPE_HEDGE;
+                    td->appearance.trackColours[i].supports = MAZE_WALL_TYPE_HEDGE;
                 }
                 else if (td4.Type == RideType::RiverRapids)
                 {
-                    td->trackSpineColour[i] = COLOUR_WHITE;
-                    td->trackRailColour[i] = COLOUR_WHITE;
+                    td->appearance.trackColours[i].main = COLOUR_WHITE;
+                    td->appearance.trackColours[i].additional = COLOUR_WHITE;
                 }
             }
 
@@ -147,7 +147,7 @@ namespace RCT1
             td->vehicleObject = ObjectEntryDescriptor(vehicleObject);
             td->vehicleType = EnumValue(td4Base.VehicleType);
 
-            td->colourScheme = td4Base.VersionAndColourScheme & 0x3;
+            td->appearance.vehicleColourSettings = static_cast<VehicleColourSettings>(td4Base.VersionAndColourScheme & 0x3);
 
             // Vehicle colours
             for (int32_t i = 0; i < Limits::kMaxTrainsPerRide; i++)
@@ -157,50 +157,50 @@ namespace RCT1
                     td4Base.VehicleType);
                 if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1)
                 {
-                    td->vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
+                    td->appearance.vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
                 }
                 else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2)
                 {
-                    td->vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
+                    td->appearance.vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
                 }
                 else
                 {
-                    td->vehicleColours[i].Body = colourSchemeCopyDescriptor.colour1;
+                    td->appearance.vehicleColours[i].Body = colourSchemeCopyDescriptor.colour1;
                 }
 
                 if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1)
                 {
-                    td->vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
+                    td->appearance.vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
                 }
                 else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2)
                 {
-                    td->vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
+                    td->appearance.vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
                 }
                 else
                 {
-                    td->vehicleColours[i].Trim = colourSchemeCopyDescriptor.colour2;
+                    td->appearance.vehicleColours[i].Trim = colourSchemeCopyDescriptor.colour2;
                 }
 
                 if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1)
                 {
-                    td->vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
+                    td->appearance.vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
                 }
                 else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2)
                 {
-                    td->vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
+                    td->appearance.vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
                 }
                 else
                 {
-                    td->vehicleColours[i].Tertiary = colourSchemeCopyDescriptor.colour3;
+                    td->appearance.vehicleColours[i].Tertiary = colourSchemeCopyDescriptor.colour3;
                 }
             }
             // Set remaining vehicles to same colour as first vehicle
-            for (size_t i = Limits::kMaxTrainsPerRide; i < std::size(td->vehicleColours); i++)
+            for (size_t i = Limits::kMaxTrainsPerRide; i < std::size(td->appearance.vehicleColours); i++)
             {
-                td->vehicleColours[i] = td->vehicleColours[0];
+                td->appearance.vehicleColours[i] = td->appearance.vehicleColours[0];
             }
 
-            td->stationObjectIdentifier = GetStationIdentifierFromStyle(RCT12_STATION_STYLE_PLAIN);
+            td->appearance.stationObjectIdentifier = GetStationIdentifierFromStyle(RCT12_STATION_STYLE_PLAIN);
             td->departFlags = td4Base.DepartFlags;
             td->numberOfTrains = td4Base.NumberOfTrains;
             td->numberOfCarsPerTrain = td4Base.NumberOfCarsPerTrain;
diff --git a/src/openrct2/rct12/RCT12.cpp b/src/openrct2/rct12/RCT12.cpp
index 20157c1c63..9ad80cad38 100644
--- a/src/openrct2/rct12/RCT12.cpp
+++ b/src/openrct2/rct12/RCT12.cpp
@@ -216,9 +216,9 @@ uint8_t RCT12TrackElement::GetRideIndex() const
     return RideIndex;
 }
 
-uint8_t RCT12TrackElement::GetColourScheme() const
+RideColourScheme RCT12TrackElement::GetColourScheme() const
 {
-    return Colour & 0x3;
+    return static_cast<RideColourScheme>(Colour & 0x3);
 }
 
 uint8_t RCT12TrackElement::GetStationIndex() const
diff --git a/src/openrct2/rct12/RCT12.h b/src/openrct2/rct12/RCT12.h
index 0da141cd81..09b8824f70 100644
--- a/src/openrct2/rct12/RCT12.h
+++ b/src/openrct2/rct12/RCT12.h
@@ -76,6 +76,7 @@ constexpr uint8_t RCT12ParkHistoryUndefined = std::numeric_limits<uint8_t>::max(
 
 struct TrackDesign;
 struct TrackDesignTrackElement;
+enum class RideColourScheme : uint8_t;
 
 enum class RCT12TrackDesignVersion : uint8_t
 {
@@ -527,7 +528,7 @@ public:
     uint8_t GetTrackType() const;
     uint8_t GetSequenceIndex() const;
     uint8_t GetRideIndex() const;
-    uint8_t GetColourScheme() const;
+    RideColourScheme GetColourScheme() const;
     uint8_t GetStationIndex() const;
     bool HasChain() const;
     bool HasCableLift() const;
diff --git a/src/openrct2/rct2/RCT2.h b/src/openrct2/rct2/RCT2.h
index 2eba29df55..4e695ffab3 100644
--- a/src/openrct2/rct2/RCT2.h
+++ b/src/openrct2/rct2/RCT2.h
@@ -23,6 +23,7 @@
 struct RideObjectEntry;
 class ObjectList;
 enum class EditorStep : uint8_t;
+enum class VehicleColourSettings : uint8_t;
 
 namespace RCT2
 {
@@ -77,7 +78,7 @@ namespace RCT2
         RCT12ObjectEntryIndex Subtype;                                 // 0x001
         uint16_t Pad002;                                               // 0x002
         uint8_t Mode;                                                  // 0x004
-        uint8_t ColourSchemeType;                                      // 0x005
+        VehicleColourSettings vehicleColourSettings;                   // 0x005
         RCT12VehicleColour VehicleColours[Limits::kMaxVehicleColours]; // 0x006
         uint8_t Pad046[0x03]; // 0x046, Used to be track colours in RCT1 without expansions
         // 0 = closed, 1 = open, 2 = test
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index 43fcd351e0..8beb334379 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -1316,7 +1316,7 @@ namespace RCT2
             dst->subtype = subtype;
             // Pad002;
             dst->mode = static_cast<RideMode>(src->Mode);
-            dst->colour_scheme_type = src->ColourSchemeType;
+            dst->vehicleColourSettings = src->vehicleColourSettings;
 
             for (uint8_t i = 0; i < Limits::kMaxVehicleColours; i++)
             {
diff --git a/src/openrct2/rct2/T6Exporter.cpp b/src/openrct2/rct2/T6Exporter.cpp
index 443ef4bd00..8f5e90b0b4 100644
--- a/src/openrct2/rct2/T6Exporter.cpp
+++ b/src/openrct2/rct2/T6Exporter.cpp
@@ -56,14 +56,14 @@ namespace RCT2
         tempStream.WriteValue<uint8_t>(_trackDesign->vehicleType);
         tempStream.WriteValue<uint32_t>(0);
         tempStream.WriteValue<uint8_t>(static_cast<uint8_t>(_trackDesign->rideMode));
-        tempStream.WriteValue<uint8_t>((_trackDesign->colourScheme & 0x3) | (2 << 2));
+        tempStream.WriteValue<uint8_t>(EnumValue(_trackDesign->appearance.vehicleColourSettings) | (2 << 2));
         for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
         {
-            tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Body);
-            tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Trim);
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.vehicleColours[i].Body);
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.vehicleColours[i].Trim);
         }
         tempStream.WriteValue<uint8_t>(0);
-        auto entranceStyle = GetStationStyleFromIdentifier(_trackDesign->stationObjectIdentifier);
+        auto entranceStyle = GetStationStyleFromIdentifier(_trackDesign->appearance.stationObjectIdentifier);
         tempStream.WriteValue<uint8_t>(entranceStyle);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.totalAirTime);
         tempStream.WriteValue<uint8_t>(_trackDesign->departFlags);
@@ -86,16 +86,25 @@ namespace RCT2
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.intensity);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.nausea);
         tempStream.WriteValue<money16>(ToMoney16(_trackDesign->statistics.upkeepCost));
-        tempStream.WriteArray(_trackDesign->trackSpineColour, Limits::kNumColourSchemes);
-        tempStream.WriteArray(_trackDesign->trackRailColour, Limits::kNumColourSchemes);
-        tempStream.WriteArray(_trackDesign->trackSupportColour, Limits::kNumColourSchemes);
+        for (auto i = 0; i < Limits::kNumColourSchemes; i++)
+        {
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.trackColours[i].main);
+        }
+        for (auto i = 0; i < Limits::kNumColourSchemes; i++)
+        {
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.trackColours[i].additional);
+        }
+        for (auto i = 0; i < Limits::kNumColourSchemes; i++)
+        {
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.trackColours[i].supports);
+        }
         tempStream.WriteValue<uint32_t>(0);
         tempStream.Write(&_trackDesign->vehicleObject.Entry, sizeof(RCTObjectEntry));
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.x);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.y);
         for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
         {
-            tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Tertiary);
+            tempStream.WriteValue<uint8_t>(_trackDesign->appearance.vehicleColours[i].Tertiary);
         }
         tempStream.WriteValue<uint8_t>(_trackDesign->liftHillSpeed | (_trackDesign->numCircuits << 5));
 
diff --git a/src/openrct2/rct2/T6Importer.cpp b/src/openrct2/rct2/T6Importer.cpp
index 2f93902bb2..b9a5e91fdf 100644
--- a/src/openrct2/rct2/T6Importer.cpp
+++ b/src/openrct2/rct2/T6Importer.cpp
@@ -77,14 +77,14 @@ namespace RCT2
             td->cost = 0.00_GBP;
             td->rideMode = static_cast<RideMode>(td6.RideMode);
             td->trackFlags = 0;
-            td->colourScheme = td6.VersionAndColourScheme & 0x3;
+            td->appearance.vehicleColourSettings = static_cast<VehicleColourSettings>(td6.VersionAndColourScheme & 0x3);
             for (auto i = 0; i < Limits::kMaxVehicleColours; ++i)
             {
-                td->vehicleColours[i].Body = td6.VehicleColours[i].BodyColour;
-                td->vehicleColours[i].Trim = td6.VehicleColours[i].TrimColour;
-                td->vehicleColours[i].Tertiary = td6.VehicleAdditionalColour[i];
+                td->appearance.vehicleColours[i].Body = td6.VehicleColours[i].BodyColour;
+                td->appearance.vehicleColours[i].Trim = td6.VehicleColours[i].TrimColour;
+                td->appearance.vehicleColours[i].Tertiary = td6.VehicleAdditionalColour[i];
             }
-            td->stationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
+            td->appearance.stationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
             td->statistics.totalAirTime = td6.TotalAirTime;
             td->departFlags = td6.DepartFlags;
             td->numberOfTrains = td6.NumberOfTrains;
@@ -116,9 +116,9 @@ namespace RCT2
             td->statistics.upkeepCost = ToMoney64(td6.UpkeepCost);
             for (auto i = 0; i < Limits::kNumColourSchemes; ++i)
             {
-                td->trackSpineColour[i] = td6.TrackSpineColour[i];
-                td->trackRailColour[i] = td6.TrackRailColour[i];
-                td->trackSupportColour[i] = td6.TrackSupportColour[i];
+                td->appearance.trackColours[i].main = td6.TrackSpineColour[i];
+                td->appearance.trackColours[i].additional = td6.TrackRailColour[i];
+                td->appearance.trackColours[i].supports = td6.TrackSupportColour[i];
             }
             td->vehicleObject = ObjectEntryDescriptor(td6.VehicleObject);
             td->statistics.spaceRequired = { td6.SpaceRequiredX, td6.SpaceRequiredY };
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index 4bddafdb9d..b8bc04f20b 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -2255,12 +2255,12 @@ void RideSetVehicleColoursToRandomPreset(Ride& ride, uint8_t preset_index)
     {
         assert(preset_index < presetList->count);
 
-        ride.colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_ALL_SAME;
+        ride.vehicleColourSettings = VehicleColourSettings::same;
         ride.vehicle_colours[0] = presetList->list[preset_index];
     }
     else
     {
-        ride.colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN;
+        ride.vehicleColourSettings = VehicleColourSettings::perTrain;
         for (uint32_t i = 0; i < presetList->count; i++)
         {
             const auto index = i % 32U;
@@ -4318,13 +4318,13 @@ void Ride::SetColourPreset(uint8_t index)
     {
         colours = colourPresets->list[index];
     }
-    for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
+    for (size_t i = 0; i < std::size(track_colour); i++)
     {
         track_colour[i].main = colours.main;
         track_colour[i].additional = colours.additional;
         track_colour[i].supports = colours.supports;
     }
-    colour_scheme_type = 0;
+    vehicleColourSettings = VehicleColourSettings::same;
 }
 
 money64 RideGetCommonPrice(const Ride& forRide)
@@ -4706,15 +4706,15 @@ void RideUpdateVehicleColours(const Ride& ride)
         for (Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]); vehicle != nullptr;
              vehicle = GetEntity<Vehicle>(vehicle->next_vehicle_on_train))
         {
-            switch (ride.colour_scheme_type & 3)
+            switch (ride.vehicleColourSettings)
             {
-                case RIDE_COLOUR_SCHEME_MODE_ALL_SAME:
+                case VehicleColourSettings::same:
                     colours = ride.vehicle_colours[0];
                     break;
-                case RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN:
+                case VehicleColourSettings::perTrain:
                     colours = ride.vehicle_colours[i];
                     break;
-                case RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR:
+                case VehicleColourSettings::perCar:
                     if (vehicle->HasFlag(VehicleFlags::CarIsReversed))
                     {
                         colours = ride.vehicle_colours[std::min(
diff --git a/src/openrct2/ride/Ride.h b/src/openrct2/ride/Ride.h
index 9aa4a52b5f..d06b5bf39e 100644
--- a/src/openrct2/ride/Ride.h
+++ b/src/openrct2/ride/Ride.h
@@ -120,7 +120,7 @@ struct Ride
     // 0x4c.
     ObjectEntryIndex subtype{ OBJECT_ENTRY_INDEX_NULL };
     RideMode mode{};
-    uint8_t colour_scheme_type{};
+    VehicleColourSettings vehicleColourSettings{};
     VehicleColour vehicle_colours[OpenRCT2::Limits::kMaxVehicleColours]{};
     // 0 = closed, 1 = open, 2 = test
     RideStatus status{};
@@ -261,7 +261,7 @@ struct Ride
     uint8_t connected_message_throttle{};
     money64 income_per_hour{};
     money64 profit{};
-    TrackColour track_colour[OpenRCT2::Limits::kNumColourSchemes]{};
+    TrackColour track_colour[kNumRideColourSchemes]{};
     ObjectEntryIndex music{ OBJECT_ENTRY_INDEX_NULL };
     ObjectEntryIndex entrance_style{ OBJECT_ENTRY_INDEX_NULL };
     uint16_t vehicle_change_timeout{};
@@ -413,8 +413,6 @@ public:
     bool HasStation() const;
 
     bool FindTrackGap(const CoordsXYE& input, CoordsXYE* output) const;
-
-    uint8_t GetEntranceStyle() const;
 };
 void UpdateSpiralSlide(Ride& ride);
 void UpdateChairlift(Ride& ride);
@@ -672,15 +670,6 @@ enum class RideMode : uint8_t
 
 RideMode& operator++(RideMode& d, int);
 
-enum
-{
-    RIDE_COLOUR_SCHEME_MODE_ALL_SAME,
-    RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN,
-    RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR,
-
-    RIDE_COLOUR_SCHEME_MODE_COUNT,
-};
-
 enum
 {
     RIDE_CATEGORY_TRANSPORT,
@@ -776,23 +765,6 @@ enum
     WAIT_FOR_LOAD_COUNT,
 };
 
-enum
-{
-    RIDE_COLOUR_SCHEME_MAIN,
-    RIDE_COLOUR_SCHEME_ADDITIONAL_1,
-    RIDE_COLOUR_SCHEME_ADDITIONAL_2,
-    RIDE_COLOUR_SCHEME_ADDITIONAL_3,
-
-    RIDE_COLOUR_SCHEME_COUNT,
-};
-
-enum
-{
-    VEHICLE_COLOUR_SCHEME_SAME,
-    VEHICLE_COLOUR_SCHEME_PER_TRAIN,
-    VEHICLE_COLOUR_SCHEME_PER_VEHICLE
-};
-
 enum
 {
     RIDE_INSPECTION_EVERY_10_MINUTES,
diff --git a/src/openrct2/ride/RideColour.h b/src/openrct2/ride/RideColour.h
index 7881beb7bb..4dc6836b39 100644
--- a/src/openrct2/ride/RideColour.h
+++ b/src/openrct2/ride/RideColour.h
@@ -9,11 +9,30 @@
 
 #pragma once
 
+#include "../common.h"
+
 #include <cstdint>
 
 struct TrackColour
 {
-    uint8_t main;
-    uint8_t additional;
-    uint8_t supports;
+    colour_t main;
+    colour_t additional;
+    colour_t supports;
 };
+
+enum class RideColourScheme : uint8_t
+{
+    main,
+    additional1,
+    additional2,
+    additional3,
+};
+constexpr uint8_t kNumRideColourSchemes = 4;
+
+enum class VehicleColourSettings : uint8_t
+{
+    same,
+    perTrain,
+    perCar,
+};
+constexpr uint8_t kNumVehicleColourSettings = 3;
diff --git a/src/openrct2/ride/RideConstruction.cpp b/src/openrct2/ride/RideConstruction.cpp
index bf6374efbd..bebcb1b3ec 100644
--- a/src/openrct2/ride/RideConstruction.cpp
+++ b/src/openrct2/ride/RideConstruction.cpp
@@ -437,7 +437,7 @@ std::optional<CoordsXYZ> GetTrackElementOriginAndApplyChanges(
         }
         if (flags & TRACK_ELEMENT_SET_COLOUR_SCHEME)
         {
-            trackElement->SetColourScheme(static_cast<uint8_t>(extra_params & 0xFF));
+            trackElement->SetColourScheme(static_cast<RideColourScheme>(extra_params & 0xFF));
         }
         if (flags & TRACK_ELEMENT_SET_SEAT_ROTATION)
         {
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index de50813213..d4b6d6df4b 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -20,6 +20,7 @@
 #include "../network/network.h"
 #include "../platform/Platform.h"
 #include "../rct1/RCT1.h"
+#include "../ride/RideColour.h"
 #include "../util/SawyerCoding.h"
 #include "../util/Util.h"
 #include "../world/Footpath.h"
@@ -894,10 +895,10 @@ uint8_t TrackElement::GetColourScheme() const
     return URide.ColourScheme & TRACK_ELEMENT_COLOUR_SCHEME_MASK;
 }
 
-void TrackElement::SetColourScheme(uint8_t newColourScheme)
+void TrackElement::SetColourScheme(RideColourScheme newColourScheme)
 {
     URide.ColourScheme &= ~TRACK_ELEMENT_COLOUR_SCHEME_MASK;
-    URide.ColourScheme |= (newColourScheme & TRACK_ELEMENT_COLOUR_SCHEME_MASK);
+    URide.ColourScheme |= (EnumValue(newColourScheme) & TRACK_ELEMENT_COLOUR_SCHEME_MASK);
 }
 
 bool TrackElement::HasCableLift() const
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index 57093150a7..c1d2877f4c 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -124,18 +124,16 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
     }
 
     rideMode = ride.mode;
-    colourScheme = ride.colour_scheme_type & 3;
+    appearance.vehicleColourSettings = ride.vehicleColourSettings;
 
-    for (size_t i = 0; i < std::size(vehicleColours); i++)
+    for (size_t i = 0; i < std::size(appearance.vehicleColours); i++)
     {
-        vehicleColours[i] = ride.vehicle_colours[i];
+        appearance.vehicleColours[i] = ride.vehicle_colours[i];
     }
 
-    for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
+    for (size_t i = 0; i < std::min(std::size(ride.track_colour), std::size(appearance.trackColours)); i++)
     {
-        trackSpineColour[i] = ride.track_colour[i].main;
-        trackRailColour[i] = ride.track_colour[i].additional;
-        trackSupportColour[i] = ride.track_colour[i].supports;
+        appearance.trackColours[i] = ride.track_colour[i];
     }
 
     departFlags = ride.depart_flags;
@@ -147,7 +145,7 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
     liftHillSpeed = ride.lift_hill_speed;
     numCircuits = ride.num_circuits;
 
-    stationObjectIdentifier = TrackDesignGetStationObjectIdentifier(ride);
+    appearance.stationObjectIdentifier = TrackDesignGetStationObjectIdentifier(ride);
     statistics.maxSpeed = static_cast<int8_t>(ride.max_speed / 65536);
     statistics.averageSpeed = static_cast<int8_t>(ride.average_speed / 65536);
     statistics.rideLength = ride.GetTotalLength() / 65536;
@@ -566,9 +564,9 @@ void TrackDesign::Serialise(DataSerialiser& stream)
     stream << DS_TAG(cost);
     stream << DS_TAG(rideMode);
     stream << DS_TAG(trackFlags);
-    stream << DS_TAG(colourScheme);
-    stream << DS_TAG(vehicleColours);
-    stream << DS_TAG(stationObjectIdentifier);
+    stream << DS_TAG(appearance.vehicleColourSettings);
+    stream << DS_TAG(appearance.vehicleColours);
+    stream << DS_TAG(appearance.stationObjectIdentifier);
     stream << DS_TAG(statistics.totalAirTime);
     stream << DS_TAG(departFlags);
     stream << DS_TAG(numberOfTrains);
@@ -590,9 +588,7 @@ void TrackDesign::Serialise(DataSerialiser& stream)
     stream << DS_TAG(statistics.intensity);
     stream << DS_TAG(statistics.nausea);
     stream << DS_TAG(statistics.upkeepCost);
-    stream << DS_TAG(trackSpineColour);
-    stream << DS_TAG(trackRailColour);
-    stream << DS_TAG(trackSupportColour);
+    stream << DS_TAG(appearance.trackColours);
     stream << DS_TAG(vehicleObject);
     stream << DS_TAG(statistics.spaceRequired.x);
     stream << DS_TAG(statistics.spaceRequired.y);
@@ -1902,17 +1898,15 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
 
     ride->custom_name = {};
 
-    ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td6->stationObjectIdentifier);
+    ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td6->appearance.stationObjectIdentifier);
     if (ride->entrance_style == OBJECT_ENTRY_INDEX_NULL)
     {
         ride->entrance_style = gameState.LastEntranceStyle;
     }
 
-    for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
+    for (size_t i = 0; i < std::min(std::size(ride->track_colour), std::size(td6->appearance.trackColours)); i++)
     {
-        ride->track_colour[i].main = td6->trackSpineColour[i];
-        ride->track_colour[i].additional = td6->trackRailColour[i];
-        ride->track_colour[i].supports = td6->trackSupportColour[i];
+        ride->track_colour[i] = td6->appearance.trackColours[i];
     }
 
     // Flat rides need their vehicle colours loaded for display
@@ -1921,7 +1915,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
     {
         for (size_t i = 0; i < std::size(ride->vehicle_colours); i++)
         {
-            ride->vehicle_colours[i] = td6->vehicleColours[i];
+            ride->vehicle_colours[i] = td6->appearance.vehicleColours[i];
         }
     }
 
diff --git a/src/openrct2/ride/TrackDesign.h b/src/openrct2/ride/TrackDesign.h
index fe1da84be2..5098e1e7c1 100644
--- a/src/openrct2/ride/TrackDesign.h
+++ b/src/openrct2/ride/TrackDesign.h
@@ -13,6 +13,7 @@
 #include "../actions/GameActionResult.h"
 #include "../common.h"
 #include "../object/Object.h"
+#include "../ride/RideColour.h"
 #include "../world/Map.h"
 #include "VehicleColour.h"
 
@@ -129,6 +130,14 @@ struct TrackDesignMazeElement
 class DataSerialiser;
 enum class RideMode : uint8_t;
 
+struct TrackDesignAppearanceSettings
+{
+    std::array<TrackColour, kNumRideColourSchemes> trackColours;
+    u8string stationObjectIdentifier{};
+    VehicleColourSettings vehicleColourSettings{};
+    std::array<VehicleColour, OpenRCT2::Limits::kMaxVehicleColours> vehicleColours;
+};
+
 struct TrackDesignStatistics
 {
     uint8_t excitement{};
@@ -163,9 +172,6 @@ struct TrackDesign
     money64 cost;
     RideMode rideMode;
     uint8_t trackFlags;
-    uint8_t colourScheme;
-    std::array<VehicleColour, OpenRCT2::Limits::kMaxVehicleColours> vehicleColours;
-    u8string stationObjectIdentifier{};
     uint8_t departFlags;
     uint8_t numberOfTrains;
     uint8_t numberOfCarsPerTrain;
@@ -173,15 +179,13 @@ struct TrackDesign
     uint8_t maxWaitingTime;
     uint8_t operationSetting;
 
-    uint8_t trackSpineColour[OpenRCT2::Limits::kNumColourSchemes];
-    uint8_t trackRailColour[OpenRCT2::Limits::kNumColourSchemes];
-    uint8_t trackSupportColour[OpenRCT2::Limits::kNumColourSchemes];
     ObjectEntryDescriptor vehicleObject;
 
     uint8_t liftHillSpeed;
     uint8_t numCircuits;
 
-    TrackDesignStatistics statistics;
+    TrackDesignAppearanceSettings appearance{};
+    TrackDesignStatistics statistics{};
 
     std::vector<TrackDesignMazeElement> mazeElements;
     std::vector<TrackDesignTrackElement> trackElements;
diff --git a/src/openrct2/ride/gentle/SpaceRings.cpp b/src/openrct2/ride/gentle/SpaceRings.cpp
index b61f29786f..dbe01df865 100644
--- a/src/openrct2/ride/gentle/SpaceRings.cpp
+++ b/src/openrct2/ride/gentle/SpaceRings.cpp
@@ -55,7 +55,7 @@ static void PaintSpaceRingsStructure(
             frameNum += static_cast<int8_t>(vehicle->Pitch) * 4;
         }
 
-        if ((ride.colour_scheme_type & 3) != RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN)
+        if (ride.vehicleColourSettings != VehicleColourSettings::perTrain)
         {
             vehicleIndex = 0;
         }
diff --git a/src/openrct2/scripting/bindings/world/ScTileElement.cpp b/src/openrct2/scripting/bindings/world/ScTileElement.cpp
index 8e86cf0805..3166a68c49 100644
--- a/src/openrct2/scripting/bindings/world/ScTileElement.cpp
+++ b/src/openrct2/scripting/bindings/world/ScTileElement.cpp
@@ -919,7 +919,7 @@ namespace OpenRCT2::Scripting
             if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
                 throw DukException() << "Cannot set 'colourScheme' property, TrackElement belongs to a maze.";
 
-            el->SetColourScheme(value.as_uint());
+            el->SetColourScheme(static_cast<RideColourScheme>(value.as_uint()));
             Invalidate();
         }
         catch (const DukException& e)
diff --git a/src/openrct2/world/TileElement.h b/src/openrct2/world/TileElement.h
index 52ce7c4a22..e90a7843f2 100644
--- a/src/openrct2/world/TileElement.h
+++ b/src/openrct2/world/TileElement.h
@@ -31,6 +31,7 @@ class TerrainEdgeObject;
 class FootpathObject;
 class FootpathSurfaceObject;
 class FootpathRailingsObject;
+enum class RideColourScheme : uint8_t;
 using track_type_t = uint16_t;
 
 constexpr uint8_t MAX_ELEMENT_HEIGHT = 255;
@@ -373,7 +374,7 @@ public:
     void SetRideIndex(RideId newRideIndex);
 
     uint8_t GetColourScheme() const;
-    void SetColourScheme(uint8_t newColourScheme);
+    void SetColourScheme(RideColourScheme newColourScheme);
 
     StationIndex GetStationIndex() const;
     void SetStationIndex(StationIndex newStationIndex);