diff --git a/CMakeLists.txt b/CMakeLists.txt index 0d68217280..99360ebf0d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -404,9 +404,6 @@ endif () # Include tests if (WITH_TESTS) enable_testing() - if (UNIX AND (NOT USE_MMAP)) - include("${ROOT_DIR}/test/testpaint/CMakeLists.txt" NO_POLICY_SCOPE) - endif () include("${ROOT_DIR}/test/tests/CMakeLists.txt" NO_POLICY_SCOPE) endif () diff --git a/scripts/build b/scripts/build index c18f4a2d97..dba55386ba 100755 --- a/scripts/build +++ b/scripts/build @@ -38,9 +38,5 @@ else export DESTDIR=install cmake .. -G Ninja -DCMAKE_INSTALL_PREFIX=/usr "$@" - if [[ "$TESTPAINT" == "true" ]]; then - testpaint_target=testpaint - fi - - ninja -k0 $testpaint_target all install + ninja -k0 all install fi diff --git a/scripts/run-testpaint b/scripts/run-testpaint deleted file mode 100755 index 9f5cc22a88..0000000000 --- a/scripts/run-testpaint +++ /dev/null @@ -1,14 +0,0 @@ -#!/usr/bin/env bash - -set -e - -# Ensure we are in root directory -basedir="$(readlink -f `dirname $0`/..)" -cd $basedir/bin - -# Scan objects first so that does not happen within a test -echo -e "\033[0;36mBuilding OpenRCT2 repository indexes...\033[0m" -./openrct2 scan-objects - -echo -e "\033[0;36mRunning OpenRCT2 testpaint tests...\033[0m" -./testpaint || true diff --git a/src/openrct2/paint/Paint.h b/src/openrct2/paint/Paint.h index 269d4ca417..1fe7b571dd 100644 --- a/src/openrct2/paint/Paint.h +++ b/src/openrct2/paint/Paint.h @@ -336,17 +336,3 @@ void PaintSessionGenerate(paint_session& session); void PaintSessionArrange(PaintSessionCore& session); void PaintDrawStructs(paint_session& session); void PaintDrawMoneyStructs(rct_drawpixelinfo* dpi, paint_string_struct* ps); - -// TESTING -#ifdef __TESTPAINT__ -void testpaint_clear_ignore(); -void testpaint_ignore(uint8_t direction, uint8_t trackSequence); -void testpaint_ignore_all(); -bool testpaint_is_ignored(uint8_t direction, uint8_t trackSequence); - -# define TESTPAINT_IGNORE(direction, trackSequence) testpaint_ignore(direction, trackSequence) -# define TESTPAINT_IGNORE_ALL() testpaint_ignore_all() -#else -# define TESTPAINT_IGNORE(direction, trackSequence) -# define TESTPAINT_IGNORE_ALL() -#endif diff --git a/src/openrct2/paint/tile_element/Paint.TileElement.cpp b/src/openrct2/paint/tile_element/Paint.TileElement.cpp index 0470659ec8..32728bda7c 100644 --- a/src/openrct2/paint/tile_element/Paint.TileElement.cpp +++ b/src/openrct2/paint/tile_element/Paint.TileElement.cpp @@ -34,10 +34,6 @@ #include -#ifdef __TESTPAINT__ -uint16_t testPaintVerticalTunnelHeight; -#endif - static void blank_tiles_paint(paint_session& session, int32_t x, int32_t y); static void PaintTileElementBase(paint_session& session, const CoordsXY& origCoords); @@ -146,12 +142,11 @@ static void PaintTileElementBase(paint_session& session, const CoordsXY& origCoo uint8_t rotation = session.CurrentRotation; bool partOfVirtualFloor = false; -#ifndef __TESTPAINT__ + if (gConfigGeneral.virtual_floor_style != VirtualFloorStyles::Off) { partOfVirtualFloor = virtual_floor_tile_is_floor(session.MapPosition); } -#endif // __TESTPAINT__ switch (rotation) { @@ -205,13 +200,11 @@ static void PaintTileElementBase(paint_session& session, const CoordsXY& origCoo max_height = element->AsSurface()->GetWaterHeight(); } -#ifndef __TESTPAINT__ if (partOfVirtualFloor) { // We must pretend this tile is at least as tall as the virtual floor max_height = std::max(max_height, virtual_floor_get_height()); } -#endif // __TESTPAINT__ if (screenMinY - (max_height + 32) >= dpi->y + dpi->height) return; @@ -295,12 +288,10 @@ static void PaintTileElementBase(paint_session& session, const CoordsXY& origCoo session.MapPosition = mapPosition; } while (!(tile_element++)->IsLastForTile()); -#ifndef __TESTPAINT__ if (gConfigGeneral.virtual_floor_style != VirtualFloorStyles::Off && partOfVirtualFloor) { virtual_floor_paint(session); } -#endif // __TESTPAINT__ if (!gShowSupportSegmentHeights) { @@ -370,9 +361,6 @@ void paint_util_push_tunnel_right(paint_session& session, uint16_t height, uint8 void paint_util_set_vertical_tunnel(paint_session& session, uint16_t height) { -#ifdef __TESTPAINT__ - testPaintVerticalTunnelHeight = height; -#endif session.VerticalTunnelHeight = height / 16; } diff --git a/src/openrct2/paint/tile_element/Paint.TileElement.h b/src/openrct2/paint/tile_element/Paint.TileElement.h index 264ace0807..2d1ecc6cdb 100644 --- a/src/openrct2/paint/tile_element/Paint.TileElement.h +++ b/src/openrct2/paint/tile_element/Paint.TileElement.h @@ -77,10 +77,6 @@ namespace PaintSessionFlags constexpr uint8_t IsTrackPiecePreview = 1u << 1; } // namespace PaintSessionFlags -#ifdef __TESTPAINT__ -extern uint16_t testPaintVerticalTunnelHeight; -#endif - extern const int32_t SEGMENTS_ALL; extern const uint16_t segment_offsets[9]; diff --git a/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp b/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp index c25e9d936f..a8849dc200 100644 --- a/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp +++ b/src/openrct2/ride/coaster/ReverseFreefallCoaster.cpp @@ -260,8 +260,6 @@ static void paint_reverse_freefall_rc_slope( paint_session& session, const Ride& ride, uint8_t trackSequence, uint8_t direction, int32_t height, const TrackElement& trackElement) { - TESTPAINT_IGNORE_ALL(); - static constexpr const int8_t bbHeights03[] = { 1, 6, 14, 37, 64 }; static constexpr const int8_t bbHeights12[] = { 1, 6, 14, 27, 59 }; static constexpr const int32_t supportHeights[] = { 48, 64, 128, 176, 208, 240, 240 }; diff --git a/src/openrct2/ride/gentle/ObservationTower.cpp b/src/openrct2/ride/gentle/ObservationTower.cpp index c833ddbb34..a8699cb2af 100644 --- a/src/openrct2/ride/gentle/ObservationTower.cpp +++ b/src/openrct2/ride/gentle/ObservationTower.cpp @@ -116,11 +116,8 @@ static void paint_observation_tower_base( paint_util_set_vertical_tunnel(session, height + 96); paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0); -#ifdef __TESTPAINT__ - paint_util_set_general_support_height(session, height + 32, 0x20); -#else paint_util_set_general_support_height(session, height + 96, 0x20); -#endif + return; } diff --git a/src/openrct2/ride/thrill/RotoDrop.cpp b/src/openrct2/ride/thrill/RotoDrop.cpp index e5d35b9bb7..529471851c 100644 --- a/src/openrct2/ride/thrill/RotoDrop.cpp +++ b/src/openrct2/ride/thrill/RotoDrop.cpp @@ -135,11 +135,7 @@ static void paint_roto_drop_base( paint_util_set_vertical_tunnel(session, height + 96); paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0); -#ifdef __TESTPAINT__ - paint_util_set_general_support_height(session, height + 32, 0x20); -#else paint_util_set_general_support_height(session, height + 96, 0x20); -#endif return; } diff --git a/src/openrct2/ride/transport/Lift.cpp b/src/openrct2/ride/transport/Lift.cpp index fe566b34b7..7ecc893405 100644 --- a/src/openrct2/ride/transport/Lift.cpp +++ b/src/openrct2/ride/transport/Lift.cpp @@ -63,11 +63,7 @@ static void paint_lift_base( paint_util_set_vertical_tunnel(session, height + 96); paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0); -#ifdef __TESTPAINT__ - paint_util_set_general_support_height(session, height + 32, 0x20); -#else paint_util_set_general_support_height(session, height + 96, 0x20); -#endif return; } diff --git a/src/openrct2/ride/water/SplashBoats.cpp b/src/openrct2/ride/water/SplashBoats.cpp index 2fd13962c4..c09e787a8c 100644 --- a/src/openrct2/ride/water/SplashBoats.cpp +++ b/src/openrct2/ride/water/SplashBoats.cpp @@ -710,21 +710,11 @@ static void paint_splash_boats_track_25_deg_down_to_flat( if (direction == 0 || direction == 3) { -#ifdef __TESTPAINT__ - // FIXME: For some reason, Testpaint does not detect this as an error. - paint_util_push_tunnel_rotated(session, direction, height - 8, TUNNEL_SQUARE_7); -#else paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_SQUARE_8); -#endif } else { -#ifdef __TESTPAINT__ - // FIXME: For some reason, Testpaint does not detect this as an error. - paint_util_push_tunnel_rotated(session, direction, height + 24, TUNNEL_SQUARE_8); -#else paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_SQUARE_FLAT); -#endif } paint_util_set_segment_support_height(session, SEGMENTS_ALL, 0xFFFF, 0); paint_util_set_general_support_height(session, height + 48, 0x20); diff --git a/test/testpaint/Addresses.cpp b/test/testpaint/Addresses.cpp deleted file mode 100644 index c147b1f013..0000000000 --- a/test/testpaint/Addresses.cpp +++ /dev/null @@ -1,80 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "Addresses.h" - -#if defined(__GNUC__) -# ifdef __clang__ -# define DISABLE_OPT __attribute__((noinline, optnone)) -# else -# define DISABLE_OPT __attribute__((noinline, optimize("O0"))) -# endif // __clang__ -#else -# define DISABLE_OPT -#endif // defined(__GNUC__) - -// This variable serves a purpose of identifying a crash if it has happened inside original code. -// When switching to original code, stack frame pointer is modified and prevents breakpad from providing stack trace. -volatile int32_t _originalAddress = 0; - -int32_t DISABLE_OPT RCT2_CALLPROC_X( - int32_t address, int32_t _eax, int32_t _ebx, int32_t _ecx, int32_t _edx, int32_t _esi, int32_t _edi, int32_t _ebp) -{ - int32_t result = 0; - _originalAddress = address; -#if defined(PLATFORM_X86) && !defined(NO_RCT2) -# ifdef _MSC_VER - __asm { - push ebp - push address - mov eax, _eax - mov ebx, _ebx - mov ecx, _ecx - mov edx, _edx - mov esi, _esi - mov edi, _edi - mov ebp, _ebp - call [esp] - lahf - pop ebp - pop ebp - /* Load result with flags */ - mov result, eax - } -# else - // clang-format off - __asm__ volatile("\ - \n\ - push %%ebx \n\ - push %%ebp \n\ - push %[address] \n\ - mov %[eax], %%eax \n\ - mov %[ebx], %%ebx \n\ - mov %[ecx], %%ecx \n\ - mov %[edx], %%edx \n\ - mov %[esi], %%esi \n\ - mov %[edi], %%edi \n\ - mov %[ebp], %%ebp \n\ - call *(%%esp) \n\ - lahf \n\ - add $4, %%esp \n\ - pop %%ebp \n\ - pop %%ebx \n\ - /* Load result with flags */ \n\ - mov %%eax, %[result] \n\ - " : [address] "+m" (address), [eax] "+m" (_eax), [ebx] "+m" (_ebx), [ecx] "+m" (_ecx), [edx] "+m" (_edx), [esi] "+m" (_esi), [edi] "+m" (_edi), [ebp] "+m" (_ebp), [result] "+m" (result) - : - : "eax","ecx","edx","esi","edi","memory"); - // clang-format on -# endif // _MSC_VER -#endif // PLATFORM_X86 - _originalAddress = 0; - // lahf only modifies ah, zero out the rest - return result & 0xFF00; -} diff --git a/test/testpaint/Addresses.h b/test/testpaint/Addresses.h deleted file mode 100644 index 8db772bf4c..0000000000 --- a/test/testpaint/Addresses.h +++ /dev/null @@ -1,42 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include - -#ifdef USE_MMAP -# if defined(PLATFORM_64BIT) -# define GOOD_PLACE_FOR_DATA_SEGMENT ((uintptr_t)0x200000000) -# elif defined(PLATFORM_32BIT) -# define GOOD_PLACE_FOR_DATA_SEGMENT ((uintptr_t)0x09000000) -# else -# error "Unknown platform" -# endif -#else -# define GOOD_PLACE_FOR_DATA_SEGMENT ((uintptr_t)0x8a4000) -#endif - -#define RCT2_ADDRESS(address, type) ((type*)(GOOD_PLACE_FOR_DATA_SEGMENT - 0x8a4000 + (address))) -#define RCT2_GLOBAL(address, type) (*((type*)(GOOD_PLACE_FOR_DATA_SEGMENT - 0x8a4000 + (address)))) - -/** - * Returns the flags register - * - * Flags register is as follows: - * 0bSZ0A_0P0C_0000_0000 - * S = Signed flag - * Z = Zero flag - * C = Carry flag - * A = Adjust flag - * P = Parity flag - * All other bits are undefined. - */ -int32_t RCT2_CALLPROC_X( - int32_t address, int32_t _eax, int32_t _ebx, int32_t _ecx, int32_t _edx, int32_t _esi, int32_t _edi, int32_t _ebp); diff --git a/test/testpaint/CMakeLists.txt b/test/testpaint/CMakeLists.txt deleted file mode 100644 index 98d8d39ae6..0000000000 --- a/test/testpaint/CMakeLists.txt +++ /dev/null @@ -1,105 +0,0 @@ -# CMAKE project for testpaint -cmake_minimum_required(VERSION 2.6) -if (CMAKE_BINARY_DIR STREQUAL CMAKE_SOURCE_DIR) - message(FATAL_ERROR "Building in-source is not supported! Create a build dir and remove ${CMAKE_SOURCE_DIR}/CMakeCache.txt") -endif () - -set(OPENRCT2_EXE "${ROOT_DIR}/openrct2.exe") -add_custom_command( - OUTPUT openrct2_text - COMMAND dd if="${OPENRCT2_EXE}" of="${CMAKE_BINARY_DIR}/openrct2_text" bs=4096 skip=1 count=1187 - DEPENDS ${OPENRCT2_EXE} -) -add_custom_command( - OUTPUT openrct2_data - COMMAND dd if="${OPENRCT2_EXE}" of="${CMAKE_BINARY_DIR}/openrct2_data" bs=4096 skip=1188 count=318 - COMMAND dd if=/dev/zero of="${CMAKE_BINARY_DIR}/openrct2_data" bs=4096 seek=318 count=2630 conv=notrunc - COMMAND dd if="${OPENRCT2_EXE}" of="${CMAKE_BINARY_DIR}/openrct2_data" bs=4096 skip=1506 seek=2948 count=1 conv=notrunc - DEPENDS ${OPENRCT2_EXE} -) -add_custom_target(segfiles DEPENDS openrct2_text openrct2_data) -if (NOT USE_MMAP AND FORCE32) - set(OBJ_FORMAT "elf32-i386") - set(LINKER_SCRIPT "ld_script_i386.xc") - if (APPLE) - set(RCT2_SEGMENT_LINKER_FLAGS "-sectcreate rct2_text __text ${CMAKE_BINARY_DIR}/openrct2_text -sectcreate rct2_data __data ${CMAKE_BINARY_DIR}/openrct2_data -segaddr rct2_data 0x8a4000 -segprot rct2_data rwx rwx -segaddr rct2_text 0x401000 -segprot rct2_text rwx rwx -segaddr __TEXT 0x2000000 -read_only_relocs suppress") - else () - # For Linux we have to use objcopy to wrap regular binaries into a linkable - # format. We use specific section names which are then referenced in a - # bespoke linker script so they can be placed at predefined VMAs. - add_custom_command( - OUTPUT openrct2_text_section.o - COMMAND objcopy --input binary --output ${OBJ_FORMAT} --binary-architecture i386 openrct2_text openrct2_text_section.o --rename-section .data=.rct2_text,contents,alloc,load,readonly,code - DEPENDS segfiles - WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - ) - add_custom_command( - OUTPUT openrct2_data_section.o - COMMAND objcopy --input binary --output ${OBJ_FORMAT} --binary-architecture i386 openrct2_data openrct2_data_section.o --rename-section .data=.rct2_data,contents,alloc,load,readonly,data - DEPENDS segfiles - WORKING_DIRECTORY ${CMAKE_BINARY_DIR} - ) - add_custom_target(linkable_sections DEPENDS openrct2_text_section.o openrct2_data_section.o) - set_source_files_properties( - openrct2_text_section.o openrct2_data_section.o - PROPERTIES - EXTERNAL_OBJECT true - GENERATED true - ) - # can't use GLOB here, as the files don't exist yet at cmake-time - set(RCT2_SECTIONS "${CMAKE_BINARY_DIR}/openrct2_data_section.o" "${CMAKE_BINARY_DIR}/openrct2_text_section.o") - set(RCT2_SEGMENT_LINKER_FLAGS "-Wl,-T,\"${ROOT_DIR}/distribution/linux/${LINKER_SCRIPT}\"") - endif () -endif () - -set(OPENRCT2_SRCPATH "${ROOT_DIR}/src/openrct2") -file(GLOB_RECURSE ORCT2_RIDE_SOURCES "${OPENRCT2_SRCPATH}/ride/*/*.cpp") -file(GLOB_RECURSE ORCT2_RIDE_DEP_SOURCES - "${OPENRCT2_SRCPATH}/Diagnostic.cpp" - "${OPENRCT2_SRCPATH}/paint/PaintHelpers.cpp" - "${OPENRCT2_SRCPATH}/paint/tile_element/Paint.TileElement.cpp" - "${OPENRCT2_SRCPATH}/ride/RideData.cpp" - "${OPENRCT2_SRCPATH}/ride/TrackData.cpp" - "${OPENRCT2_SRCPATH}/ride/TrackPaint.cpp" - "${OPENRCT2_SRCPATH}/core/Console.cpp" - "${OPENRCT2_SRCPATH}/core/Diagnostics.cpp" - "${OPENRCT2_SRCPATH}/core/Guard.cpp" - "${OPENRCT2_SRCPATH}/core/String.cpp" - "${OPENRCT2_SRCPATH}/Diagnostic.cpp" - "${OPENRCT2_SRCPATH}/interface/ZoomLevel.cpp" - "${OPENRCT2_SRCPATH}/localisation/ConversionTables.cpp" - "${OPENRCT2_SRCPATH}/localisation/Convert.cpp" - "${OPENRCT2_SRCPATH}/localisation/FormatCodes.cpp" - "${OPENRCT2_SRCPATH}/localisation/UTF8.cpp" - "${OPENRCT2_SRCPATH}/util/Util.cpp" - "${OPENRCT2_SRCPATH}/Version.cpp" -) -file(GLOB_RECURSE ORCT2_TESTPAINT_SOURCES "${CMAKE_CURRENT_LIST_DIR}/*.c" - "${CMAKE_CURRENT_LIST_DIR}/*.cpp" - "${CMAKE_CURRENT_LIST_DIR}/*.h") - -# Disable optimizations for addresses.c for all compilers, to allow optimized -# builds without need for -fno-omit-frame-pointer -set_source_files_properties(${CMAKE_CURRENT_LIST_DIR}/addresses.c PROPERTIES COMPILE_FLAGS -O0) - -add_executable(testpaint EXCLUDE_FROM_ALL ${ORCT2_RIDE_SOURCES} ${ORCT2_RIDE_DEP_SOURCES} ${ORCT2_TESTPAINT_SOURCES} ${RCT2_SECTIONS}) -SET_CHECK_CXX_FLAGS(testpaint) -target_compile_options(testpaint PRIVATE -Wno-old-style-cast) -target_include_directories(testpaint PRIVATE "${ROOT_DIR}/src/") -target_link_libraries(testpaint z) - -if (NOT MINGW AND NOT MSVC) - # For unicode code page conversion - find_package(ICU 59.0 REQUIRED COMPONENTS uc) - target_link_libraries(testpaint ${ICU_LIBRARIES}) - target_include_directories(testpaint SYSTEM PUBLIC ${ICU_INCLUDE_DIRS}) -endif () - -# Only use custom linker script for 32 bit builds. For 64 bit builds, it should still _compile_. -if (FORCE32) - set_target_properties(testpaint PROPERTIES LINK_FLAGS ${RCT2_SEGMENT_LINKER_FLAGS}) -else () - set(TESTPAINT_64BIT_FLAGS "-Wno-int-to-pointer-cast -fpermissive -Wno-error") -endif () -set_target_properties(testpaint PROPERTIES COMPILE_FLAGS "-DNO_VEHICLES -D__TESTPAINT__ -Wno-unused ${TESTPAINT_64BIT_FLAGS} -DDISABLE_HTTP") -add_dependencies(testpaint segfiles) diff --git a/test/testpaint/Compat.cpp b/test/testpaint/Compat.cpp deleted file mode 100644 index 4bd8633928..0000000000 --- a/test/testpaint/Compat.cpp +++ /dev/null @@ -1,903 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "Addresses.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -class StationObject; - -#define gRideEntries RCT2_ADDRESS(0x009ACFA4, rct_ride_entry*) -#define gTileElementTilePointers RCT2_ADDRESS(0x013CE9A4, TileElement*) -rct_sprite* sprite_list = RCT2_ADDRESS(0x010E63BC, rct_sprite); - -bool gCheatsEnableAllDrawableTrackPieces = false; - -Ride gRideList[MAX_RIDES]; -int16_t gMapBaseZ; -bool gTrackDesignSaveMode = false; -ride_id_t gTrackDesignSaveRideIndex = RIDE_ID_NULL; -uint8_t gClipHeight = 255; -CoordsXY gClipSelectionA = { 0, 0 }; -CoordsXY gClipSelectionB = { MAXIMUM_TILE_START_XY, MAXIMUM_TILE_START_XY }; -uint32_t gScenarioTicks; -uint8_t gCurrentRotation; - -// clang-format off -constexpr const std::array CoordsDirectionDelta = { - CoordsXY{ -COORDS_XY_STEP, 0 }, - CoordsXY{ 0, +COORDS_XY_STEP }, - CoordsXY{ +COORDS_XY_STEP, 0 }, - CoordsXY{ 0, -COORDS_XY_STEP }, - CoordsXY{ -COORDS_XY_STEP, +COORDS_XY_STEP }, - CoordsXY{ +COORDS_XY_STEP, +COORDS_XY_STEP }, - CoordsXY{ +COORDS_XY_STEP, -COORDS_XY_STEP }, - CoordsXY{ -COORDS_XY_STEP, -COORDS_XY_STEP }, -}; - -const TileCoordsXY TileDirectionDelta[] = { - { -1, 0 }, - { 0, +1 }, - { +1, 0 }, - { 0, -1 }, - { -1, +1 }, - { +1, +1 }, - { +1, -1 }, - { -1, -1 }, -}; -// clang-format on - -uint8_t get_current_rotation() -{ - return gCurrentRotation & 3; -} - -int object_entry_group_counts[] = { - 128, // ObjectType::Ride - 252, // ObjectType::SmallScenery - 128, // ObjectType::LargeScenery - 128, // ObjectType::Walls - 32, // ObjectType::Banners - 16, // ObjectType::Paths - 15, // ObjectType::PathBits - 19, // ObjectType::SceneryGroup - 1, // ObjectType::ParkEntrance - 1, // ObjectType::Water - 1, // ObjectType::ScenarioText - 0, // ObjectType::TerrainSurface - 0, // ObjectType::TerrainEdge - 0, // ObjectType::Station - 0, // ObjectType::Music - 0, // ObjectType::FootpathSurface - 0, // ObjectType::FootpathRailings -}; -static_assert(std::size(object_entry_group_counts) == EnumValue(ObjectType::Count)); - -GeneralConfiguration gConfigGeneral; -uint16_t gMapSelectFlags; -uint16_t gMapSelectType; -CoordsXY gMapSelectPositionA; -CoordsXY gMapSelectPositionB; -CoordsXYZ gMapSelectArrowPosition; -uint8_t gMapSelectArrowDirection; - -void entrance_paint(paint_session* session, uint8_t direction, int height, const TileElement* tile_element) -{ -} -void banner_paint(paint_session* session, uint8_t direction, int height, const TileElement* tile_element) -{ -} -void surface_paint(paint_session* session, uint8_t direction, uint16_t height, const TileElement* tileElement) -{ -} -void path_paint(paint_session* session, uint16_t height, const TileElement* tileElement) -{ -} -void scenery_paint(paint_session* session, uint8_t direction, int height, const TileElement* tileElement) -{ -} -void fence_paint(paint_session* session, uint8_t direction, int height, const TileElement* tileElement) -{ -} -void large_scenery_paint(paint_session* session, uint8_t direction, uint16_t height, const TileElement* tileElement) -{ -} - -Ride* get_ride(ride_id_t index) -{ - if (index >= RCT12_MAX_RIDES_IN_PARK) - { - log_error("invalid index %d for ride", index); - return nullptr; - } - return &gRideList[index]; -} - -rct_ride_entry* get_ride_entry(ObjectEntryIndex index) -{ - if (index >= object_entry_group_counts[static_cast(ObjectType::Ride)]) - { - log_error("invalid index %d for ride type", index); - return nullptr; - } - - return gRideEntries[index]; -} - -rct_ride_entry* Ride::GetRideEntry() const -{ - rct_ride_entry* rideEntry = get_ride_entry(subtype); - if (rideEntry == nullptr) - { - log_error("Invalid ride subtype for ride"); - } - return rideEntry; -} - -template<> bool SpriteBase::Is() const -{ - return true; -} - -template<> bool SpriteBase::Is() const -{ - return Type == EntityType::Guest || Type == EntityType::Staff; -} - -template<> bool SpriteBase::Is() const -{ - return Type == EntityType::Guest; -} - -template<> bool SpriteBase::Is() const -{ - return Type == EntityType::Vehicle; -} - -SpriteBase* get_sprite(size_t sprite_idx) -{ - assert(sprite_idx < MAX_ENTITIES); - return reinterpret_cast(&sprite_list[sprite_idx]); -} - -bool TileElementBase::IsLastForTile() const -{ - return (this->Flags & TILE_ELEMENT_FLAG_LAST_TILE) != 0; -} - -void TileElementBase::SetLastForTile(bool on) -{ - if (on) - Flags |= TILE_ELEMENT_FLAG_LAST_TILE; - else - Flags &= ~TILE_ELEMENT_FLAG_LAST_TILE; -} - -uint8_t TileElementBase::GetType() const -{ - return this->type & TILE_ELEMENT_TYPE_MASK; -} - -bool TileElementBase::IsGhost() const -{ - return (this->Flags & TILE_ELEMENT_FLAG_GHOST) != 0; -} - -bool TrackElement::BlockBrakeClosed() const -{ - return (Flags2 & TRACK_ELEMENT_FLAGS2_BLOCK_BRAKE_CLOSED) != 0; -} - -TileElement* map_get_first_element_at(const CoordsXY& elementPos) -{ - if (elementPos.x < 0 || elementPos.y < 0 || elementPos.x > 255 || elementPos.y > 255) - { - log_error("Trying to access element outside of range"); - return nullptr; - } - auto tileElementPos = TileCoordsXY{ elementPos }; - return gTileElementTilePointers[tileElementPos.x + tileElementPos.y * 256]; -} - -int32_t get_height_marker_offset() -{ - return 0; -} - -bool is_csg_loaded() -{ - return false; -} - -uint8_t TrackElement::GetSeatRotation() const -{ - const auto* ride = get_ride(GetRideIndex()); - if (ride != nullptr && ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_LANDSCAPE_DOORS)) - return DEFAULT_SEAT_ROTATION; - - return ColourScheme >> 4; -} - -void TrackElement::SetSeatRotation(uint8_t newSeatRotation) -{ - ColourScheme &= ~TRACK_ELEMENT_COLOUR_SEAT_ROTATION_MASK; - ColourScheme |= (newSeatRotation << 4); -} - -bool TrackElement::IsTakingPhoto() const -{ - return OnridePhotoBits != 0; -} - -void TrackElement::SetPhotoTimeout() -{ - OnridePhotoBits = 3; -} - -void TrackElement::SetPhotoTimeout(uint8_t value) -{ - OnridePhotoBits = value; -} - -uint8_t TrackElement::GetPhotoTimeout() const -{ - return OnridePhotoBits; -} - -void TrackElement::DecrementPhotoTimeout() -{ - OnridePhotoBits = std::max(0, OnridePhotoBits - 1); -} - -uint16_t TrackElement::GetMazeEntry() const -{ - return MazeEntry; -} - -void TrackElement::SetMazeEntry(uint16_t newMazeEntry) -{ - MazeEntry = newMazeEntry; -} - -void TrackElement::MazeEntryAdd(uint16_t addVal) -{ - MazeEntry |= addVal; -} - -void TrackElement::MazeEntrySubtract(uint16_t subVal) -{ - MazeEntry &= ~subVal; -} - -track_type_t TrackElement::GetTrackType() const -{ - return TrackType; -} - -void TrackElement::SetTrackType(track_type_t newType) -{ - TrackType = newType; -} - -uint8_t TrackElement::GetSequenceIndex() const -{ - return Sequence; -} - -void TrackElement::SetSequenceIndex(uint8_t newSequenceIndex) -{ - Sequence = newSequenceIndex; -} - -uint8_t TrackElement::GetStationIndex() const -{ - return StationIndex; -} - -void TrackElement::SetStationIndex(uint8_t newStationIndex) -{ - StationIndex = newStationIndex; -} - -uint8_t TrackElement::GetDoorAState() const -{ - return (ColourScheme & TRACK_ELEMENT_COLOUR_DOOR_A_MASK) >> 2; -} - -uint8_t TrackElement::GetDoorBState() const -{ - return (ColourScheme & TRACK_ELEMENT_COLOUR_DOOR_B_MASK) >> 5; -} - -ride_id_t TrackElement::GetRideIndex() const -{ - return RideIndex; -} - -void TrackElement::SetRideIndex(ride_id_t newRideIndex) -{ - RideIndex = newRideIndex; -} - -uint8_t TrackElement::GetColourScheme() const -{ - return ColourScheme & TRACK_ELEMENT_COLOUR_SCHEME_MASK; -} - -void TrackElement::SetColourScheme(uint8_t newColourScheme) -{ - ColourScheme &= ~TRACK_ELEMENT_COLOUR_SCHEME_MASK; - ColourScheme |= (newColourScheme & TRACK_ELEMENT_COLOUR_SCHEME_MASK); -} - -bool TrackElement::HasCableLift() const -{ - return Flags2 & TRACK_ELEMENT_FLAGS2_CABLE_LIFT; -} - -void TrackElement::SetHasCableLift(bool on) -{ - Flags2 &= ~TRACK_ELEMENT_FLAGS2_CABLE_LIFT; - if (on) - Flags2 |= TRACK_ELEMENT_FLAGS2_CABLE_LIFT; -} - -bool TrackElement::IsInverted() const -{ - return Flags2 & TRACK_ELEMENT_FLAGS2_INVERTED; -} - -void TrackElement::SetInverted(bool inverted) -{ - if (inverted) - { - Flags2 |= TRACK_ELEMENT_FLAGS2_INVERTED; - } - else - { - Flags2 &= ~TRACK_ELEMENT_FLAGS2_INVERTED; - } -} - -uint8_t TrackElement::GetBrakeBoosterSpeed() const -{ - return BrakeBoosterSpeed << 1; -} - -void TrackElement::SetBrakeBoosterSpeed(uint8_t speed) -{ - BrakeBoosterSpeed = (speed >> 1); -} - -bool TrackElement::HasGreenLight() const -{ - return (Flags2 & TRACK_ELEMENT_FLAGS2_HAS_GREEN_LIGHT) != 0; -} - -void TrackElement::SetHasGreenLight(bool on) -{ - Flags2 &= ~TRACK_ELEMENT_FLAGS2_HAS_GREEN_LIGHT; - if (on) - { - Flags2 |= TRACK_ELEMENT_FLAGS2_HAS_GREEN_LIGHT; - } -} - -bool TrackElement::HasChain() const -{ - return (Flags2 & TRACK_ELEMENT_FLAGS2_CHAIN_LIFT) != 0; -} - -void TrackElement::SetHasChain(bool on) -{ - if (on) - { - Flags2 |= TRACK_ELEMENT_FLAGS2_CHAIN_LIFT; - } - else - { - Flags2 &= ~TRACK_ELEMENT_FLAGS2_CHAIN_LIFT; - } -} - -TileCoordsXYZD ride_get_entrance_location(const Ride* ride, const StationIndex stationIndex) -{ - return ride->stations[stationIndex].Entrance; -} - -TileCoordsXYZD ride_get_exit_location(const Ride* ride, const StationIndex stationIndex) -{ - return ride->stations[stationIndex].Exit; -} - -void TileElementBase::SetType(uint8_t newType) -{ - this->type &= ~TILE_ELEMENT_TYPE_MASK; - this->type |= (newType & TILE_ELEMENT_TYPE_MASK); -} - -uint8_t TileElementBase::GetDirection() const -{ - return this->type & TILE_ELEMENT_DIRECTION_MASK; -} - -uint8_t TileElementBase::GetDirectionWithOffset(uint8_t offset) const -{ - return ((this->type & TILE_ELEMENT_DIRECTION_MASK) + offset) & TILE_ELEMENT_DIRECTION_MASK; -} - -uint8_t SurfaceElement::GetSlope() const -{ - return Slope; -} - -int32_t SurfaceElement::GetWaterHeight() const -{ - return WaterHeight * 16; -} - -bool TrackElement::IsHighlighted() const -{ - return (Flags2 & TRACK_ELEMENT_FLAGS2_HIGHLIGHT); -} - -uint8_t PathElement::GetEdges() const -{ - return EdgesAndCorners & 0xF; -} - -StationObject* ride_get_station_object(const Ride* ride) -{ - return nullptr; -} - -Ride* Vehicle::GetRide() const -{ - return get_ride(ride); -} - -bool Vehicle::IsGhost() const -{ - auto r = GetRide(); - return r != nullptr && r->status == RideStatus::Simulating; -} - -uint8_t TileElementBase::GetOccupiedQuadrants() const -{ - return Flags & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK; -} - -void TileElementBase::SetOccupiedQuadrants(uint8_t quadrants) -{ - Flags &= ~TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK; - Flags |= (quadrants & TILE_ELEMENT_OCCUPIED_QUADRANTS_MASK); -} - -int32_t TileElementBase::GetBaseZ() const -{ - return base_height * COORDS_Z_STEP; -} - -void TileElementBase::SetBaseZ(int32_t newZ) -{ - base_height = (newZ / COORDS_Z_STEP); -} - -int32_t TileElementBase::GetClearanceZ() const -{ - return clearance_height * COORDS_Z_STEP; -} - -void TileElementBase::SetClearanceZ(int32_t newZ) -{ - clearance_height = (newZ / COORDS_Z_STEP); -} - -int32_t RideStation::GetBaseZ() const -{ - return Height * COORDS_Z_STEP; -} - -void RideStation::SetBaseZ(int32_t newZ) -{ - Height = newZ / COORDS_Z_STEP; -} - -CoordsXYZ RideStation::GetStart() const -{ - TileCoordsXYZ stationTileCoords{ Start.x, Start.y, Height }; - return stationTileCoords.ToCoordsXYZ(); -} - -bool TrackElement::IsStation() const -{ - return track_type_is_station(GetTrackType()); -} - -bool track_type_is_station(track_type_t trackType) -{ - switch (trackType) - { - case TrackElemType::EndStation: - case TrackElemType::BeginStation: - case TrackElemType::MiddleStation: - return true; - default: - return false; - } -} - -void ride_ratings_calculate_spiral_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_stand_up_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_suspended_swinging_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_inverted_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_junior_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_miniature_railway([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_monorail([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mini_suspended_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_boat_hire([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_wooden_wild_mouse([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_steeplechase([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_car_ride([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_launched_freefall([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_bobsleigh_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_observation_tower([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_looping_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_dinghy_slide([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mine_train_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_chairlift([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_corkscrew_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_maze([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_spiral_slide([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_go_karts([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_log_flume([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_river_rapids([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_dodgems([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_swinging_ship([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_inverter_ship([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_food_stall([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_shop([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_merry_go_round([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_information_kiosk([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_toilets([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_ferris_wheel([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_motion_simulator([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_3d_cinema([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_top_spin([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_space_rings([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_reverse_freefall_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_lift([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_vertical_drop_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_cash_machine([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_twist([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_haunted_house([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_first_aid([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_circus([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_ghost_train([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_twister_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_wooden_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_side_friction_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_wild_mouse([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_multi_dimension_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_flying_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_virginia_reel([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_splash_boats([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mini_helicopters([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_lay_down_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_suspended_monorail([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_reverser_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_heartline_twister_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mini_golf([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_giga_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_roto_drop([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_flying_saucers([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_crooked_house([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_monorail_cycles([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_compact_inverted_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_water_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_air_powered_vertical_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_inverted_hairpin_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_magic_carpet([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_submarine_ride([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_river_rafts([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_enterprise([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_inverted_impulse_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mini_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_mine_ride([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_lim_launched_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_drink_stall([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_hybrid_coaster([[maybe_unused]] Ride* ride) -{ -} - -void ride_ratings_calculate_single_rail_roller_coaster([[maybe_unused]] Ride* ride) -{ -} - -const RideTypeDescriptor& Ride::GetRideTypeDescriptor() const -{ - return ::GetRideTypeDescriptor(type); -} - -uint8_t TileElementBase::GetOwner() const -{ - return owner & OWNER_MASK; -} - -void TileElementBase::SetOwner(uint8_t newOwner) -{ - owner &= ~OWNER_MASK; - owner |= (newOwner & OWNER_MASK); -} - -namespace OpenRCT2 -{ - IContext* GetContext() - { - return nullptr; - } -} // namespace OpenRCT2 - -ScreenCoordsXY translate_3d_to_2d_with_z(int32_t rotation, const CoordsXYZ& pos) -{ - auto rotated = pos.Rotate(rotation); - // Use right shift to avoid issues like #9301 - return ScreenCoordsXY{ rotated.y - rotated.x, ((rotated.x + rotated.y) >> 1) - pos.z }; -} diff --git a/test/testpaint/Data.cpp b/test/testpaint/Data.cpp deleted file mode 100644 index fabcfeccca..0000000000 --- a/test/testpaint/Data.cpp +++ /dev/null @@ -1,1237 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include -#include - -const_utf8string RideNames[RCT2_RIDE_TYPE_COUNT] = { - "SpiralRollerCoaster", - "StandUpRollerCoaster", - "SuspendedSwingingCoaster", - "InvertedRollerCoaster", - "JuniorRollerCoaster", - "MiniatureRailway", - "Monorail", - "MiniSuspendedCoaster", - "BoatHire", - "WoodenWildMouse", - "Steeplechase", - "CarRide", - "LaunchedFreefall", - "BobsleighCoaster", - "ObservationTower", - "LoopingRollerCoaster", - "DinghySlide", - "MineTrainCoaster", - "Chairlift", - "CorkscrewRollerCoaster", - "Maze", - "SpiralSlide", - "GoKarts", - "LogFlume", - "RiverRapids", - "Dodgems", - "SwingingShip", - "SwingingInverterShip", - "FoodStall", - "1D", - "DrinkStall", - "1F", - "Shop", - "MerryGoRound", - "22", - "InformationKiosk", - "Toilets", - "FerrisWheel", - "MotionSimulator", - "3DCinema", - "TopSpin", - "SpaceRings", - "ReverseFreefallCoaster", - "Lift", - "VerticalDropRollerCoaster", - "CashMachine", - "Twist", - "HauntedHouse", - "FirstAid", - "Circus", - "GhostTrain", - "TwisterRollerCoaster", - "WoodenRollerCoaster", - "SideFrictionRollerCoaster", - "WildMouse", - "MultiDimensionRollerCoaster", - "MultiDimensionRollerCoasterAlt", - "FlyingRollerCoaster", - "FlyingRollerCoasterAlt", - "VirginiaReel", - "SplashBoats", - "MiniHelicopters", - "LayDownRollerCoaster", - "SuspendedMonorail", - "LayDownRollerCoasterAlt", - "ReverserRollerCoaster", - "HeartlineTwisterCoaster", - "MiniGolf", - "GigaCoaster", - "RoToDrop", - "FlyingSaucers", - "CrookedHouse", - "MonorailCycles", - "CompactInvertedCoaster", - "WaterCoaster", - "AirPoweredVerticalCoaster", - "InvertedHairpinCoaster", - "MagicCarpet", - "SubmarineRide", - "RiverRafts", - "50", - "Enterprise", - "52", - "53", - "54", - "55", - "InvertedImpulseCoaster", - "MiniRollerCoaster", - "MineRide", - "59", - "LimLaunchedRollerCoaster", -}; - -const_utf8string TrackNames[256] = { - "Flat", - "EndStation", - "BeginStation", - "MiddleStation", - "25DegUp", - "60DegUp", - "FlatTo25DegUp", - "25DegUpTo60DegUp", - "60DegUpTo25DegUp", - "25DegUpToFlat", - "25DegDown", - "60DegDown", - "FlatTo25DegDown", - "25DegDownTo60DegDown", - "60DegDownTo25DegDown", - "25DegDownToFlat", - "LeftQuarterTurn5Tiles", - "RightQuarterTurn5Tiles", - "FlatToLeftBank", - "FlatToRightBank", - "LeftBankToFlat", - "RightBankToFlat", - "BankedLeftQuarterTurn5Tiles", - "BankedRightQuarterTurn5Tiles", - "LeftBankTo25DegUp", - "RightBankTo25DegUp", - "25DegUpToLeftBank", - "25DegUpToRightBank", - "LeftBankTo25DegDown", - "RightBankTo25DegDown", - "25DegDownToLeftBank", - "25DegDownToRightBank", - "LeftBank", - "RightBank", - "LeftQuarterTurn5Tiles25DegUp", - "RightQuarterTurn5Tiles25DegUp", - "LeftQuarterTurn5Tiles25DegDown", - "RightQuarterTurn5Tiles25DegDown", - "SBendLeft", - "SBendRight", - "LeftVerticalLoop", - "RightVerticalLoop", - "LeftQuarterTurn3Tiles", - "RightQuarterTurn3Tiles", - "LeftQuarterTurn3TilesBank", - "RightQuarterTurn3TilesBank", - "LeftQuarterTurn3Tiles25DegUp", - "RightQuarterTurn3Tiles25DegUp", - "LeftQuarterTurn3Tiles25DegDown", - "RightQuarterTurn3Tiles25DegDown", - "LeftQuarterTurn1Tile", - "RightQuarterTurn1Tile", - "LeftTwistDownToUp", - "RightTwistDownToUp", - "LeftTwistUpToDown", - "RightTwistUpToDown", - "HalfLoopUp", - "HalfLoopDown", - "LeftCorkscrewUp", - "RightCorkscrewUp", - "LeftCorkscrewDown", - "RightCorkscrewDown", - "FlatTo60DegUp", - "60DegUpToFlat", - "FlatTo60DegDown", - "60DegDownToFlat", - "TowerBase", - "TowerSection", - "FlatCovered", - "25DegUpCovered", - "60DegUpCovered", - "FlatTo25DegUpCovered", - "25DegUpTo60DegUpCovered", - "60DegUpTo25DegUpCovered", - "25DegUpToFlatCovered", - "25DegDownCovered", - "60DegDownCovered", - "FlatTo25DegDownCovered", - "25DegDownTo60DegDownCovered", - "60DegDownTo25DegDownCovered", - "25DegDownToFlatCovered", - "LeftQuarterTurn5TilesCovered", - "RightQuarterTurn5TilesCovered", - "SBendLeftCovered", - "SBendRightCovered", - "LeftQuarterTurn3TilesCovered", - "RightQuarterTurn3TilesCovered", - "LeftHalfBankedHelixUpSmall", - "RightHalfBankedHelixUpSmall", - "LeftHalfBankedHelixDownSmall", - "RightHalfBankedHelixDownSmall", - "LeftHalfBankedHelixUpLarge", - "RightHalfBankedHelixUpLarge", - "LeftHalfBankedHelixDownLarge", - "RightHalfBankedHelixDownLarge", - "LeftQuarterTurn1Tile60DegUp", - "RightQuarterTurn1Tile60DegUp", - "LeftQuarterTurn1Tile60DegDown", - "RightQuarterTurn1Tile60DegDown", - "Brakes", - "RotationControlToggle", - "Inverted90DegUpToFlatQuarterLoop_Maze", - "LeftQuarterBankedHelixLargeUp", - "RightQuarterBankedHelixLargeUp", - "LeftQuarterBankedHelixLargeDown", - "RightQuarterBankedHelixLargeDown", - "LeftQuarterHelixLargeUp", - "RightQuarterHelixLargeUp", - "LeftQuarterHelixLargeDown", - "RightQuarterHelixLargeDown", - "25DegUpLeftBanked", - "25DegUpRightBanked", - "Waterfall", - "Rapids", - "OnRidePhoto", - "25DegDownLeftBanked", - "25DegDownRightBanked", - "WaterSplash", - "FlatTo60DegUpLongBase", - "60DegUpToFlatLongBase", - "Whirlpool", - "Down60ToFlatLongBase", - "FlatToDown60LongBase", - "CableLiftHill", - "ReverseWhoaBellySlope", - "ReverseWhoaBellyVertical", - "90DegUp", - "90DegDown", - "60DegUpTo90DegUp", - "90DegDownTo60DegDown", - "90DegUpTo60DegUp", - "60DegDownTo90DegDown", - "BrakeForDrop", - "LeftEighthToDiag", - "RightEighthToDiag", - "LeftEighthToOrthogonal", - "RightEighthToOrthogonal", - "LeftEighthBankToDiag", - "RightEighthBankToDiag", - "LeftEighthBankToOrthogonal", - "RightEighthBankToOrthogonal", - "DiagFlat", - "Diag25DegUp", - "Diag60DegUp", - "DiagFlatTo25DegUp", - "Diag25DegUpTo60DegUp", - "Diag60DegUpTo25DegUp", - "Diag25DegUpToFlat", - "Diag25DegDown", - "Diag60DegDown", - "DiagFlatTo25DegDown", - "Diag25DegDownTo60DegDown", - "Diag60DegDownTo25DegDown", - "Diag25DegDownToFlat", - "DiagFlatTo60DegUp", - "Diag60DegUpToFlat", - "DiagFlatTo60DegDown", - "Diag60DegDownToFlat", - "DiagFlatToLeftBank", - "DiagFlatToRightBank", - "DiagLeftBankToFlat", - "DiagRightBankToFlat", - "DiagLeftBankTo25DegUp", - "DiagRightBankTo25DegUp", - "Diag25DegUpToLeftBank", - "Diag25DegUpToRightBank", - "DiagLeftBankTo25DegDown", - "DiagRightBankTo25DegDown", - "Diag25DegDownToLeftBank", - "Diag25DegDownToRightBank", - "DiagLeftBank", - "DiagRightBank", - "LogFlumeReverser", - "SpinningTunnel", - "LeftBarrelRollUpToDown", - "RightBarrelRollUpToDown", - "LeftBarrelRollDownToUp", - "RightBarrelRollDownToUp", - "LeftBankToLeftQuarterTurn3Tiles25DegUp", - "RightBankToRightQuarterTurn3Tiles25DegUp", - "LeftQuarterTurn3Tiles25DegDownToLeftBank", - "RightQuarterTurn3Tiles25DegDownToRightBank", - "PoweredLift", - "LeftLargeHalfLoopUp", - "RightLargeHalfLoopUp", - "RightLargeHalfLoopDown", - "LeftLargeHalfLoopDown", - "LeftFlyerTwistUp", - "RightFlyerTwistUp", - "LeftFlyerTwistDown", - "RightFlyerTwistDown", - "FlyerHalfLoopUp", - "FlyerHalfLoopDown", - "LeftFlyerCorkscrewUp", - "RightFlyerCorkscrewUp", - "LeftFlyerCorkscrewDown", - "RightFlyerCorkscrewDown", - "HeartlineTransferUp", - "HeartlineTransferDown", - "LeftHeartlineRoll", - "RightHeartlineRoll", - "MiniGolfHoleA", - "MiniGolfHoleB", - "MiniGolfHoleC", - "MiniGolfHoleD", - "MiniGolfHoleE", - "MultidimInvertedFlatTo90DegQuarterLoopDown", - "90DegToInvertedFlatQuarterLoopUp", - "InvertedFlatTo90DegQuarterLoopDown", - "LeftCurvedLiftHill", - "RightCurvedLiftHill", - "LeftReverser", - "RightReverser", - "AirThrustTopCap", - "AirThrustVerticalDown", - "AirThrustVerticalDownToLevel", - "BlockBrakes", - "LeftBankedQuarterTurn3Tile25DegUp", - "RightBankedQuarterTurn3Tile25DegUp", - "LeftBankedQuarterTurn3Tile25DegDown", - "RightBankedQuarterTurn3Tile25DegDown", - "LeftBankedQuarterTurn5Tile25DegUp", - "RightBankedQuarterTurn5Tile25DegUp", - "LeftBankedQuarterTurn5Tile25DegDown", - "RightBankedQuarterTurn5Tile25DegDown", - "25DegUpToLeftBanked25DegUp", - "25DegUpToRightBanked25DegUp", - "LeftBanked25DegUpTo25DegUp", - "RightBanked25DegUpTo25DegUp", - "25DegDownToLeftBanked25DegDown", - "25DegDownToRightBanked25DegDown", - "LeftBanked25DegDownTo25DegDown", - "RightBanked25DegDownTo25DegDown", - "LeftBankedFlatToLeftBanked25DegUp", - "RightBankedFlatToRightBanked25DegUp", - "LeftBanked25DegUpToLeftBankedFlat", - "RightBanked25DegUpToRightBankedFlat", - "LeftBankedFlatToLeftBanked25DegDown", - "RightBankedFlatToRightBanked25DegDown", - "LeftBanked25DegDownToLeftBankedFlat", - "RightBanked25DegDownToRightBankedFlat", - "FlatToLeftBanked25DegUp", - "FlatToRightBanked25DegUp", - "LeftBanked25DegUpToFlat", - "RightBanked25DegUpToFlat", - "FlatToLeftBanked25DegDown", - "FlatToRightBanked25DegDown", - "LeftBanked25DegDownToFlat", - "RightBanked25DegDownToFlat", - "LeftQuarterTurn1Tile90DegUp", - "RightQuarterTurn1Tile90DegUp", - "LeftQuarterTurn1Tile90DegDown", - "RightQuarterTurn1Tile90DegDown", - "Multidim90DegUpToInvertedFlatQuarterLoop", - "MultidimFlatTo90DegDownQuarterLoop", - "Elem255", -}; - -// clang-format off -const_utf8string FlatTrackNames[256] = { - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "1x4_A", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "2x2", - "4x4", - "", - "", - "", - "", - "1x5", - "", - "1x1_A", - "1x4_B", - "", - "1x1_B", - "1x4_C", - "3x3", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", -}; -// clang-format on - -const_utf8string TrackElemNames[] = { - "TrackElemType::Flat", - "TrackElemType::EndStation", - "TrackElemType::BeginStation", - "TrackElemType::MiddleStation", - "TrackElemType::Up25", - "TrackElemType::Up60", - "TrackElemType::FlatToUp25", - "TrackElemType::Up25ToUp60", - "TrackElemType::Up60ToUp25", - "TrackElemType::Up25ToFlat", - "TrackElemType::Down25", - "TrackElemType::Down60", - "TrackElemType::FlatToDown25", - "TrackElemType::Down25ToDown60", - "TrackElemType::Down60ToDown25", - "TrackElemType::Down25ToFlat", - "TrackElemType::LeftQuarterTurn5Tiles", - "TrackElemType::RightQuarterTurn5Tiles", - "TrackElemType::FlatToLeftBank", - "TrackElemType::FlatToRightBank", - "TrackElemType::LeftBankToFlat", - "TrackElemType::RightBankToFlat", - "TrackElemType::BankedLeftQuarterTurn5Tiles", - "TrackElemType::BankedRightQuarterTurn5Tiles", - "TrackElemType::LeftBankToUp25", - "TrackElemType::RightBankToUp25", - "TrackElemType::Up25ToLeftBank", - "TrackElemType::Up25ToRightBank", - "TrackElemType::LeftBankToDown25", - "TrackElemType::RightBankToDown25", - "TrackElemType::Down25ToLeftBank", - "TrackElemType::Down25ToRightBank", - "TrackElemType::LeftBank", - "TrackElemType::RightBank", - "TrackElemType::LeftQuarterTurn5TilesUp25", - "TrackElemType::RightQuarterTurn5TilesUp25", - "TrackElemType::LeftQuarterTurn5TilesDown25", - "TrackElemType::RightQuarterTurn5TilesDown25", - "TrackElemType::SBendLeft", - "TrackElemType::SBendRight", - "TrackElemType::LeftVerticalLoop", - "TrackElemType::RightVerticalLoop", - "TrackElemType::LeftQuarterTurn3Tiles", - "TrackElemType::RightQuarterTurn3Tiles", - "TrackElemType::LeftBankedQuarterTurn3Tiles", - "TrackElemType::RightBankedQuarterTurn3Tiles", - "TrackElemType::LeftQuarterTurn3TilesUp25", - "TrackElemType::RightQuarterTurn3TilesUp25", - "TrackElemType::LeftQuarterTurn3TilesDown25", - "TrackElemType::RightQuarterTurn3TilesDown25", - "TrackElemType::LeftQuarterTurn1Tile", - "TrackElemType::RightQuarterTurn1Tile", - "TrackElemType::LeftTwistDownToUp", - "TrackElemType::RightTwistDownToUp", - "TrackElemType::LeftTwistUpToDown", - "TrackElemType::RightTwistUpToDown", - "TrackElemType::HalfLoopUp", - "TrackElemType::HalfLoopDown", - "TrackElemType::LeftCorkscrewUp", - "TrackElemType::RightCorkscrewUp", - "TrackElemType::LeftCorkscrewDown", - "TrackElemType::RightCorkscrewDown", - "TrackElemType::FlatToUp60", - "TrackElemType::Up60ToFlat", - "TrackElemType::FlatToDown60", - "TrackElemType::Down60ToFlat", - "TrackElemType::TowerBase", - "TrackElemType::TowerSection", - "TrackElemType::FlatCovered", - "TrackElemType::Up25Covered", - "TrackElemType::Up60Covered", - "TrackElemType::FlatToUp25Covered", - "TrackElemType::Up25ToUp60Covered", - "TrackElemType::Up60ToUp25Covered", - "TrackElemType::Up25ToFlatCovered", - "TrackElemType::Down25Covered", - "TrackElemType::Down60Covered", - "TrackElemType::FlatToDown25Covered", - "TrackElemType::Down25ToDown60Covered", - "TrackElemType::Down60ToDown25Covered", - "TrackElemType::Down25ToFlatCovered", - "TrackElemType::LeftQuarterTurn5TilesCovered", - "TrackElemType::RightQuarterTurn5TilesCovered", - "TrackElemType::SBendLeftCovered", - "TrackElemType::SBendRightCovered", - "TrackElemType::LeftQuarterTurn3TilesCovered", - "TrackElemType::RightQuarterTurn3TilesCovered", - "TrackElemType::LeftHalfBankedHelixUpSmall", - "TrackElemType::RightHalfBankedHelixUpSmall", - "TrackElemType::LeftHalfBankedHelixDownSmall", - "TrackElemType::RightHalfBankedHelixDownSmall", - "TrackElemType::LeftHalfBankedHelixUpLarge", - "TrackElemType::RightHalfBankedHelixUpLarge", - "TrackElemType::LeftHalfBankedHelixDownLarge", - "TrackElemType::RightHalfBankedHelixDownLarge", - "TrackElemType::LeftQuarterTurn1TileUp60", - "TrackElemType::RightQuarterTurn1TileUp60", - "TrackElemType::LeftQuarterTurn1TileDown60", - "TrackElemType::RightQuarterTurn1TileDown60", - "TrackElemType::Brakes", - "TrackElemType::RotationControlToggle", - "TrackElemType::InvertedUp90ToFlatQuarterLoopAlias", - "TrackElemType::LeftQuarterBankedHelixLargeUp", - "TrackElemType::RightQuarterBankedHelixLargeUp", - "TrackElemType::LeftQuarterBankedHelixLargeDown", - "TrackElemType::RightQuarterBankedHelixLargeDown", - "TrackElemType::LeftQuarterHelixLargeUp", - "TrackElemType::RightQuarterHelixLargeUp", - "TrackElemType::LeftQuarterHelixLargeDown", - "TrackElemType::RightQuarterHelixLargeDown", - "TrackElemType::Up25LeftBanked", - "TrackElemType::Up25RightBanked", - "TrackElemType::Waterfall", - "TrackElemType::Rapids", - "TrackElemType::OnRidePhoto", - "TrackElemType::Down25LeftBanked", - "TrackElemType::Down25RightBanked", - "TrackElemType::Watersplash", - "TrackElemType::FlatToUp60LongBase", - "TrackElemType::Up60ToFlatLongBase", - "TrackElemType::Whirlpool", - "TrackElemType::Down60ToFlatLongBase", - "TrackElemType::FlatToDown60LongBase", - "TrackElemType::CableLiftHill", - "TrackElemType::ReverseFreefallSlope", - "TrackElemType::ReverseFreefallVertical", - "TrackElemType::Up90", - "TrackElemType::Down90", - "TrackElemType::Up60ToUp90", - "TrackElemType::Down90ToDown60", - "TrackElemType::Up90ToUp60", - "TrackElemType::Down60ToDown90", - "TrackElemType::BrakeForDrop", - "TrackElemType::LeftEighthToDiag", - "TrackElemType::RightEighthToDiag", - "TrackElemType::LeftEighthToOrthogonal", - "TrackElemType::RightEighthToOrthogonal", - "TrackElemType::LeftEighthBankToDiag", - "TrackElemType::RightEighthBankToDiag", - "TrackElemType::LeftEighthBankToOrthogonal", - "TrackElemType::RightEighthBankToOrthogonal", - "TrackElemType::DiagFlat", - "TrackElemType::DiagUp25", - "TrackElemType::DiagUp60", - "TrackElemType::DiagFlatToUp25", - "TrackElemType::DiagUp25ToUp60", - "TrackElemType::DiagUp60ToUp25", - "TrackElemType::DiagUp25ToFlat", - "TrackElemType::DiagDown25", - "TrackElemType::DiagDown60", - "TrackElemType::DiagFlatToDown25", - "TrackElemType::DiagDown25ToDown60", - "TrackElemType::DiagDown60ToDown25", - "TrackElemType::DiagDown25ToFlat", - "TrackElemType::DiagFlatToUp60", - "TrackElemType::DiagUp60ToFlat", - "TrackElemType::DiagFlatToDown60", - "TrackElemType::DiagDown60ToFlat", - "TrackElemType::DiagFlatToLeftBank", - "TrackElemType::DiagFlatToRightBank", - "TrackElemType::DiagLeftBankToFlat", - "TrackElemType::DiagRightBankToFlat", - "TrackElemType::DiagLeftBankToUp25", - "TrackElemType::DiagRightBankToUp25", - "TrackElemType::DiagUp25ToLeftBank", - "TrackElemType::DiagUp25ToRightBank", - "TrackElemType::DiagLeftBankToDown25", - "TrackElemType::DiagRightBankToDown25", - "TrackElemType::DiagDown25ToLeftBank", - "TrackElemType::DiagDown25ToRightBank", - "TrackElemType::DiagLeftBank", - "TrackElemType::DiagRightBank", - "TrackElemType::LogFlumeReverser", - "TrackElemType::SpinningTunnel", - "TrackElemType::LeftBarrelRollUpToDown", - "TrackElemType::RightBarrelRollUpToDown", - "TrackElemType::LeftBarrelRollDownToUp", - "TrackElemType::RightBarrelRollDownToUp", - "TrackElemType::LeftBankToLeftQuarterTurn3TilesUp25", - "TrackElemType::RightBankToRightQuarterTurn3TilesUp25", - "TrackElemType::LeftQuarterTurn3TilesDown25ToLeftBank", - "TrackElemType::RightQuarterTurn3TilesDown25ToRightBank", - "TrackElemType::PoweredLift", - "TrackElemType::LeftLargeHalfLoopUp", - "TrackElemType::RightLargeHalfLoopUp", - "TrackElemType::RightLargeHalfLoopDown", - "TrackElemType::LeftLargeHalfLoopDown", - "TrackElemType::LeftFlyerTwistUp", - "TrackElemType::RightFlyerTwistUp", - "TrackElemType::LeftFlyerTwistDown", - "TrackElemType::RightFlyerTwistDown", - "TrackElemType::FlyerHalfLoopUp", - "TrackElemType::FlyerHalfLoopDown", - "TrackElemType::LeftFlyerCorkscrewUp", - "TrackElemType::RightFlyerCorkscrewUp", - "TrackElemType::LeftFlyerCorkscrewDown", - "TrackElemType::RightFlyerCorkscrewDown", - "TrackElemType::HeartLineTransferUp", - "TrackElemType::HeartLineTransferDown", - "TrackElemType::LeftHeartLineRoll", - "TrackElemType::RightHeartLineRoll", - "TrackElemType::MinigolfHoleA", - "TrackElemType::MinigolfHoleB", - "TrackElemType::MinigolfHoleC", - "TrackElemType::MinigolfHoleD", - "TrackElemType::MinigolfHoleE", - "TrackElemType::MultiDimInvertedFlatToDown90QuarterLoop", - "TrackElemType::Up90ToInvertedFlatQuarterLoop", - "TrackElemType::InvertedFlatToDown90QuarterLoop", - "TrackElemType::LeftCurvedLiftHill", - "TrackElemType::RightCurvedLiftHill", - "TrackElemType::LeftReverser", - "TrackElemType::RightReverser", - "TrackElemType::AirThrustTopCap", - "TrackElemType::AirThrustVerticalDown", - "TrackElemType::AirThrustVerticalDownToLevel", - "TrackElemType::BlockBrakes", - "TrackElemType::LeftBankedQuarterTurn3TileUp25", - "TrackElemType::RightBankedQuarterTurn3TileUp25", - "TrackElemType::LeftBankedQuarterTurn3TileDown25", - "TrackElemType::RightBankedQuarterTurn3TileDown25", - "TrackElemType::LeftBankedQuarterTurn5TileUp25", - "TrackElemType::RightBankedQuarterTurn5TileUp25", - "TrackElemType::LeftBankedQuarterTurn5TileDown25", - "TrackElemType::RightBankedQuarterTurn5TileDown25", - "TrackElemType::Up25ToLeftBankedUp25", - "TrackElemType::Up25ToRightBankedUp25", - "TrackElemType::LeftBankedUp25ToUp25", - "TrackElemType::RightBankedUp25ToUp25", - "TrackElemType::Down25ToLeftBankedDown25", - "TrackElemType::Down25ToRightBankedDown25", - "TrackElemType::LeftBankedDown25ToDown25", - "TrackElemType::RightBankedDown25ToDown25", - "TrackElemType::LeftBankedFlatToLeftBankedUp25", - "TrackElemType::RightBankedFlatToRightBankedUp25", - "TrackElemType::LeftBankedUp25ToLeftBankedFlat", - "TrackElemType::RightBankedUp25ToRightBankedFlat", - "TrackElemType::LeftBankedFlatToLeftBankedDown25", - "TrackElemType::RightBankedFlatToRightBankedDown25", - "TrackElemType::LeftBankedDown25ToLeftBankedFlat", - "TrackElemType::RightBankedDown25ToRightBankedFlat", - "TrackElemType::FlatToLeftBankedUp25", - "TrackElemType::FlatToRightBankedUp25", - "TrackElemType::LeftBankedUp25ToFlat", - "TrackElemType::RightBankedUp25ToFlat", - "TrackElemType::FlatToLeftBankedDown25", - "TrackElemType::FlatToRightBankedDown25", - "TrackElemType::LeftBankedDown25ToFlat", - "TrackElemType::RightBankedDown25ToFlat", - "TrackElemType::LeftQuarterTurn1TileUp90", - "TrackElemType::RightQuarterTurn1TileUp90", - "TrackElemType::LeftQuarterTurn1TileDown90", - "TrackElemType::RightQuarterTurn1TileDown90", - "TrackElemType::MultiDimUp90ToInvertedFlatQuarterLoop", - "TrackElemType::MultiDimFlatToDown90QuarterLoop", - "TrackElemType::MultiDimInvertedUp90ToFlatQuarterLoop", -}; - -const_utf8string RideCodeNames[RCT2_RIDE_TYPE_COUNT] = { - "spiral_rc", - "stand_up_rc", - "suspended_swinging_rc", - "inverted_rc", - "junior_rc", - "miniature_railway", - "monorail", - "mini_suspended_rc", - "boat_hire", - "wooden_wild_mouse", - "steeplechase", - "car_ride", - "launched_freefall", - "bobsleigh_rc", - "observation_tower", - "looping_rc", - "dinghy_slide", - "mine_train_rc", - "chairlift", - "corkscrew_rc", - "maze", - "spiralslide", - "go_karts", - "log_flume", - "river_rapids", - "dodgems", - "pirate_ship", - "swinging_inverter_ship", - "food_stall", - "1D", - "drink_stall", - "1F", - "shop", - "merry_go_round", - "22", - "information_kiosk", - "toilets", - "ferris_wheel", - "motion_simulator", - "3d_cinema", - "top_spin", - "space_rings", - "reverse_freefall_rc", - "lift", - "vertical_drop_rc", - "cash_machine", - "twist", - "haunted_house", - "first_aid", - "circus_show", - "ghost_train", - "twister_rc", - "wooden_rc", - "side_friction_rc", - "wild_mouse", - "multi_dimension_rc", - "multi_dimension_rc_alt", - "flying_rc", - "flying_rc_alt", - "virginia_reel", - "splash_boats", - "mini_helicopters", - "lay_down_rc", - "suspended_monorail", - "lay_down_rc_alt", - "reverser_rc", - "heartline_twister_rc", - "mini_golf", - "giga_rc", - "roto_drop", - "flying_saucers", - "crooked_house", - "monorail_cycles", - "compact_inverted_rc", - "water_rc", - "air_powered_vertical_rc", - "inverted_hairpin_rc", - "magic_carpet", - "submarine_ride", - "river_rafts", - "50", - "enterprise", - "52", - "53", - "54", - "55", - "inverted_impulse_rc", - "mini_rc", - "mine_ride", - "59", - "lim_launched_rc", -}; - -const_utf8string TrackCodeNames[256] = { - "flat", - "end_station", - "begin_station", - "middle_station", - "25_deg_up", - "60_deg_up", - "flat_to_25_deg_up", - "25_deg_up_to_60_deg_up", - "60_deg_up_to_25_deg_up", - "25_deg_up_to_flat", - "25_deg_down", - "60_deg_down", - "flat_to_25_deg_down", - "25_deg_down_to_60_deg_down", - "60_deg_down_to_25_deg_down", - "25_deg_down_to_flat", - "left_quarter_turn_5", - "right_quarter_turn_5", - "flat_to_left_bank", - "flat_to_right_bank", - "left_bank_to_flat", - "right_bank_to_flat", - "banked_left_quarter_turn_5", - "banked_right_quarter_turn_5", - "left_bank_to_25_deg_up", - "right_bank_to_25_deg_up", - "25_deg_up_to_left_bank", - "25_deg_up_to_right_bank", - "left_bank_to_25_deg_down", - "right_bank_to_25_deg_down", - "25_deg_down_to_left_bank", - "25_deg_down_to_right_bank", - "left_bank", - "right_bank", - "left_quarter_turn_5_25_deg_up", - "right_quarter_turn_5_25_deg_up", - "left_quarter_turn_5_25_deg_down", - "right_quarter_turn_5_25_deg_down", - "s_bend_left", - "s_bend_right", - "left_vertical_loop", - "right_vertical_loop", - "left_quarter_turn_3", - "right_quarter_turn_3", - "left_quarter_turn_3_bank", - "right_quarter_turn_3_bank", - "left_quarter_turn_3_25_deg_up", - "right_quarter_turn_3_25_deg_up", - "left_quarter_turn_3_25_deg_down", - "right_quarter_turn_3_25_deg_down", - "left_quarter_turn_1", - "right_quarter_turn_1", - "left_twist_down_to_up", - "right_twist_down_to_up", - "left_twist_up_to_down", - "right_twist_up_to_down", - "half_loop_up", - "half_loop_down", - "left_corkscrew_up", - "right_corkscrew_up", - "left_corkscrew_down", - "right_corkscrew_down", - "flat_to_60_deg_up", - "60_deg_up_to_flat", - "flat_to_60_deg_down", - "60_deg_down_to_flat", - "tower_base", - "tower_section", - "flat_covered", - "25_deg_up_covered", - "60_deg_up_covered", - "flat_to_25_deg_up_covered", - "25_deg_up_to_60_deg_up_covered", - "60_deg_up_to_25_deg_up_covered", - "25_deg_up_to_flat_covered", - "25_deg_down_covered", - "60_deg_down_covered", - "flat_to_25_deg_down_covered", - "25_deg_down_to_60_deg_down_covered", - "60_deg_down_to_25_deg_down_covered", - "25_deg_down_to_flat_covered", - "left_quarter_turn_5_covered", - "right_quarter_turn_5_covered", - "s_bend_left_covered", - "s_bend_right_covered", - "left_quarter_turn_3_covered", - "right_quarter_turn_3_covered", - "left_half_banked_helix_up_small", - "right_half_banked_helix_up_small", - "left_half_banked_helix_down_small", - "right_half_banked_helix_down_small", - "left_half_banked_helix_up_large", - "right_half_banked_helix_up_large", - "left_half_banked_helix_down_large", - "right_half_banked_helix_down_large", - "left_quarter_turn_1_60_deg_up", - "right_quarter_turn_1_60_deg_up", - "left_quarter_turn_1_60_deg_down", - "right_quarter_turn_1_60_deg_down", - "brakes", - "rotation_control_toggle", - "inverted_90_deg_up_to_flat_quarter_loop_maze", - "left_quarter_banked_helix_large_up", - "right_quarter_banked_helix_large_up", - "left_quarter_banked_helix_large_down", - "right_quarter_banked_helix_large_down", - "left_quarter_helix_large_up", - "right_quarter_helix_large_up", - "left_quarter_helix_large_down", - "right_quarter_helix_large_down", - "25_deg_up_left_banked", - "25_deg_up_right_banked", - "waterfall", - "rapids", - "on_ride_photo", - "25_deg_down_left_banked", - "25_deg_down_right_banked", - "water_splash", - "flat_to_60_deg_up_long_base", - "60_deg_up_to_flat_long_base", - "whirlpool", - "flat_to_60_deg_down_long_base", - "60_deg_up_to_flat_long_base122", - "cable_lift_hill", - "reverse_freefall_slope", - "reverse_freefall_vertical", - "90_deg_up", - "90_deg_down", - "60_deg_up_to_90_deg_up", - "90_deg_down_to_60_deg_down", - "90_deg_up_to_60_deg_up", - "60_deg_down_to_90_deg_down", - "brake_for_drop", - "left_eighth_to_diag", - "right_eighth_to_diag", - "left_eighth_to_orthogonal", - "right_eighth_to_orthogonal", - "left_eighth_bank_to_diag", - "right_eighth_bank_to_diag", - "left_eighth_bank_to_orthogonal", - "right_eighth_bank_to_orthogonal", - "diag_flat", - "diag_25_deg_up", - "diag_60_deg_up", - "diag_flat_to_25_deg_up", - "diag_25_deg_up_to_60_deg_up", - "diag_60_deg_up_to_25_deg_up", - "diag_25_deg_up_to_flat", - "diag_25_deg_down", - "diag_60_deg_down", - "diag_flat_to_25_deg_down", - "diag_25_deg_down_to_60_deg_down", - "diag_60_deg_down_to_25_deg_down", - "diag_25_deg_down_to_flat", - "diag_flat_to_60_deg_up", - "diag_60_deg_up_to_flat", - "diag_flat_to_60_deg_down", - "diag_60_deg_down_to_flat", - "diag_flat_to_left_bank", - "diag_flat_to_right_bank", - "diag_left_bank_to_flat", - "diag_right_bank_to_flat", - "diag_left_bank_to_25_deg_up", - "diag_right_bank_to_25_deg_up", - "diag_25_deg_up_to_left_bank", - "diag_25_deg_up_to_right_bank", - "diag_left_bank_to_25_deg_down", - "diag_right_bank_to_25_deg_down", - "diag_25_deg_down_to_left_bank", - "diag_25_deg_down_to_right_bank", - "diag_left_bank", - "diag_right_bank", - "log_flume_reverser", - "spinning_tunnel", - "left_barrel_roll_up_to_down", - "right_barrel_roll_up_to_down", - "left_barrel_roll_down_to_up", - "right_barrel_roll_down_to_up", - "left_bank_to_left_quarter_turn_3_25_deg_up", - "right_bank_to_right_quarter_turn_3_25_deg_up", - "left_quarter_turn_3_25_deg_down_to_left_bank", - "right_quarter_turn_3_25_deg_down_to_right_bank", - "powered_lift", - "left_large_half_loop_up", - "right_large_half_loop_up", - "right_large_half_loop_down", - "left_large_half_loop_down", - "left_flyer_twist_up", - "right_flyer_twist_up", - "left_flyer_twist_down", - "right_flyer_twist_down", - "flyer_half_loop_up", - "flyer_half_loop_down", - "left_flyer_corkscrew_up", - "right_flyer_corkscrew_up", - "left_flyer_corkscrew_down", - "right_flyer_corkscrew_down", - "heartline_transfer_up", - "heartline_transfer_down", - "left_heartline_roll", - "right_heartline_roll", - "mini_golf_hole_a", - "mini_golf_hole_b", - "mini_golf_hole_c", - "mini_golf_hole_d", - "mini_golf_hole_e", - "multidim_inverted_flat_to_90_deg_quarter_loop_down", - "90_deg_to_inverted_flat_quarter_loop_up", - "inverted_flat_to_90_deg_quarter_loop_down", - "left_curved_lift_hill", - "right_curved_lift_hill", - "left_reverser", - "right_reverser", - "air_thrust_top_cap", - "air_thrust_vertical_down", - "air_thrust_vertical_down_to_level", - "block_brakes", - "left_banked_quarter_turn_3_25_deg_up", - "right_banked_quarter_turn_3_25_deg_up", - "left_banked_quarter_turn_3_25_deg_down", - "right_banked_quarter_turn_3_25_deg_down", - "left_banked_quarter_turn_5_25_deg_up", - "right_banked_quarter_turn_5_25_deg_up", - "left_banked_quarter_turn_5_25_deg_down", - "right_banked_quarter_turn_5_25_deg_down", - "25_deg_up_to_left_banked_25_deg_up", - "25_deg_up_to_right_banked_25_deg_up", - "left_banked_25_deg_up_to_25_deg_up", - "right_banked_25_deg_up_to_25_deg_up", - "25_deg_down_to_left_banked_25_deg_down", - "25_deg_down_to_right_banked_25_deg_down", - "left_banked_25_deg_down_to_25_deg_down", - "right_banked_25_deg_down_to_25_deg_down", - "left_banked_flat_to_left_banked_25_deg_up", - "right_banked_flat_to_right_banked_25_deg_up", - "left_banked_25_deg_up_to_left_banked_flat", - "right_banked_25_deg_up_to_right_banked_flat", - "left_banked_flat_to_left_banked_25_deg_down", - "right_banked_flat_to_right_banked_25_deg_down", - "left_banked_25_deg_down_to_left_banked_flat", - "right_banked_25_deg_down_to_right_banked_flat", - "flat_to_left_banked_25_deg_up", - "flat_to_right_banked_25_deg_up", - "left_banked_25_deg_up_to_flat", - "right_banked_25_deg_up_to_flat", - "flat_to_left_banked_25_deg_down", - "flat_to_right_banked_25_deg_down", - "left_banked_25_deg_down_to_flat", - "right_banked_25_deg_down_to_flat", - "left_quarter_turn_1_90_deg_up", - "right_quarter_turn_1_90_deg_up", - "left_quarter_turn_1_90_deg_down", - "right_quarter_turn_1_90_deg_down", - "multidim_90_deg_up_to_inverted_flat_quarter_loop", - "multidim_flat_to_90_deg_down_quarter_loop", - "elem_255", -}; diff --git a/test/testpaint/Data.h b/test/testpaint/Data.h deleted file mode 100644 index 74717d403d..0000000000 --- a/test/testpaint/Data.h +++ /dev/null @@ -1,21 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include -#include - -extern const utf8string RideNames[RCT2_RIDE_TYPE_COUNT]; -extern const utf8string TrackNames[256]; -extern const utf8string FlatTrackNames[256]; -extern const utf8string TrackElemNames[256]; -extern const utf8string RideCodeNames[RCT2_RIDE_TYPE_COUNT]; -extern const utf8string TrackCodeNames[256]; -extern const uint32_t* RideTypeTrackPaintFunctionsOld[RCT2_RIDE_TYPE_COUNT]; diff --git a/test/testpaint/FunctionCall.cpp b/test/testpaint/FunctionCall.cpp deleted file mode 100644 index f387b9e015..0000000000 --- a/test/testpaint/FunctionCall.cpp +++ /dev/null @@ -1,186 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "FunctionCall.hpp" - -#include - -enum SpriteGroup -{ - SPRITEGROUP_NONE, - - SPRITEGROUP_FENCE_METAL_A, // 14568 - SPRITEGROUP_FENCE_METAL_B, // 14990 - SPRITEGROUP_FENCE_SPIRAL_SLIDE, // 20564 - SPRITEGROUP_FLOOR_CORK, // 22134 - SPRITEGROUP_FENCE_ROPE, // 22138 -}; - -static void canonicalizeFunctionCall(function_call* call); -static SpriteGroup getSpriteGroup(uint16_t spriteIndex); - -bool FunctionCall::AssertsEquals(std::vector expected, std::vector actual) -{ - if (expected.size() != actual.size()) - { - return false; - } - - for (size_t i = 0; i < expected.size(); i++) - { - function_call expectedCall = expected[i]; - function_call actualCall = actual[i]; - - if (!AssertsEquals(expectedCall, actualCall)) - { - return false; - } - } - - return true; -} - -bool FunctionCall::AssertsEquals(function_call expected, function_call actual) -{ - canonicalizeFunctionCall(&actual); - canonicalizeFunctionCall(&expected); - - if (expected.function != actual.function) - { - return false; - } - - uint8_t function = expected.function; - - if (function == SUPPORTS_WOOD_A || function == SUPPORTS_WOOD_B) - { - if (expected.supports.type != actual.supports.type) - return false; - if (expected.supports.special != actual.supports.special) - return false; - if (expected.supports.height != actual.supports.height) - return false; - if (expected.supports.colour_flags != actual.supports.colour_flags) - return false; - - if (expected.supports.special == 14 || expected.supports.special == 15 || expected.supports.special == 18 - || expected.supports.special == 19 || expected.supports.special == 22 || expected.supports.special == 23) - { - if (expected.supports.prepend_to != actual.supports.prepend_to) - return false; - } - - return true; - } - - if (function == SUPPORTS_METAL_A || function == SUPPORTS_METAL_B) - { - if (expected.supports.type != actual.supports.type) - return false; - if (expected.supports.segment != actual.supports.segment) - return false; - if (expected.supports.special != actual.supports.special) - return false; - if (expected.supports.height != actual.supports.height) - return false; - if (expected.supports.colour_flags != actual.supports.colour_flags) - return false; - - return true; - } - - if (function == SET_SEGMENT_HEIGHT) - { - return true; - } - - if (expected.paint.image_id != actual.paint.image_id) - { - SpriteGroup expectedSpriteGroup = getSpriteGroup(expected.paint.image_id & 0x7FFFF); - SpriteGroup actualSpriteGroup = getSpriteGroup(actual.paint.image_id & 0x7FFFF); - - if (expectedSpriteGroup != actualSpriteGroup) - return false; - - if (expectedSpriteGroup == SPRITEGROUP_NONE) - return false; - - return true; - } - - if (expected.paint.offset.x != actual.paint.offset.x) - return false; - if (expected.paint.offset.y != actual.paint.offset.y) - return false; - if (expected.paint.bound_box_length.x != actual.paint.bound_box_length.x) - return false; - if (expected.paint.bound_box_length.y != actual.paint.bound_box_length.y) - return false; - if (expected.paint.bound_box_length.z != actual.paint.bound_box_length.z) - return false; - if (function != PAINT_98196C) - { - if (expected.paint.bound_box_offset.x != actual.paint.bound_box_offset.x) - return false; - if (expected.paint.bound_box_offset.y != actual.paint.bound_box_offset.y) - return false; - if (expected.paint.bound_box_offset.z != actual.paint.bound_box_offset.z) - return false; - } - if (expected.paint.z_offset != actual.paint.z_offset) - return false; - if (expected.paint.rotation != actual.paint.rotation) - return false; - - return true; -} - -static void canonicalizeFunctionCall(function_call* call) -{ - if (call->function != PAINT_98197C) - return; - if (call->paint.offset.x != call->paint.bound_box_offset.x) - return; - if (call->paint.offset.y != call->paint.bound_box_offset.y) - return; - if (call->paint.z_offset != call->paint.bound_box_offset.z) - return; - - call->function = PAINT_98196C; -} - -static SpriteGroup getSpriteGroup(uint16_t spriteIndex) -{ - if (spriteIndex >= 14568 && spriteIndex <= 14571) - { - return SPRITEGROUP_FENCE_METAL_A; - } - - if (spriteIndex >= 14990 && spriteIndex <= 14993) - { - return SPRITEGROUP_FENCE_METAL_B; - } - - if (spriteIndex >= 20564 && spriteIndex <= 20567) - { - return SPRITEGROUP_FENCE_SPIRAL_SLIDE; - } - - if (spriteIndex >= 22134 && spriteIndex <= 22137) - { - return SPRITEGROUP_FLOOR_CORK; - } - - if (spriteIndex >= 22138 && spriteIndex <= 22141) - { - return SPRITEGROUP_FENCE_ROPE; - } - - return SPRITEGROUP_NONE; -} diff --git a/test/testpaint/FunctionCall.hpp b/test/testpaint/FunctionCall.hpp deleted file mode 100644 index e2448e3dec..0000000000 --- a/test/testpaint/FunctionCall.hpp +++ /dev/null @@ -1,61 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include "TestPaint.hpp" - -#include - -enum -{ - PAINT_98196C, - PAINT_98197C, - PAINT_98198C, - PAINT_98199C, - - SUPPORTS_METAL_A, - SUPPORTS_METAL_B, - SUPPORTS_WOOD_A, - SUPPORTS_WOOD_B, - - SET_SEGMENT_HEIGHT, - PAINT_98198C_COORDS -}; - -struct function_call -{ - uint8_t function; - struct paint - { - uint32_t image_id; - LocationXY16 offset; - LocationXYZ16 bound_box_length; - int16_t z_offset; - LocationXYZ16 bound_box_offset; - uint32_t rotation; - paint_struct output_struct; - } paint; - struct supports - { - int type; - uint8_t segment; - int special; - int height; - uint32_t colour_flags; - int32_t prepend_to; - } supports; -}; - -class FunctionCall -{ -public: - static bool AssertsEquals(function_call expected, function_call actual); - static bool AssertsEquals(std::vector expected, std::vector actual); -}; diff --git a/test/testpaint/GeneralSupportHeightCall.cpp b/test/testpaint/GeneralSupportHeightCall.cpp deleted file mode 100644 index d1e9e7ffa0..0000000000 --- a/test/testpaint/GeneralSupportHeightCall.cpp +++ /dev/null @@ -1,78 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "GeneralSupportHeightCall.hpp" - -#include - -bool GeneralSupportHeightCall::CallsMatch(SupportCall tileSupportCalls[4]) -{ - SupportCall baseCall = tileSupportCalls[0]; - for (int i = 1; i < 4; i++) - { - if (tileSupportCalls[i] != baseCall) - return false; - } - - return true; -} - -bool GeneralSupportHeightCall::FindMostCommonSupportCall(SupportCall calls[4], SupportCall* out) -{ - std::map map; - - for (int i = 0; i < 4; ++i) - { - if (map.count(calls[i]) == 0) - { - map[calls[i]] = 1; - } - else - { - map[calls[i]] += 1; - } - } - - if (map.size() == 1) - { - (*out) = calls[0]; - return true; - } - - if (map.size() == 2) - { - for (auto&& item : map) - { - if (item.second == 3) - { - (*out) = item.first; - return true; - } - } - - return false; - } - - return false; -} - -bool GeneralSupportHeightCall::AssertEquals(const SupportCall* lhs, const SupportCall* rhs) -{ - if (lhs == nullptr && rhs == nullptr) - return true; - if (lhs == nullptr || rhs == nullptr) - return false; - - if (lhs->height != rhs->height) - return false; - if (lhs->slope != rhs->slope) - return false; - - return true; -} diff --git a/test/testpaint/GeneralSupportHeightCall.hpp b/test/testpaint/GeneralSupportHeightCall.hpp deleted file mode 100644 index 3c90f2a662..0000000000 --- a/test/testpaint/GeneralSupportHeightCall.hpp +++ /dev/null @@ -1,52 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include - -struct SupportCall -{ - int32_t height; - int16_t slope; - - friend bool operator==(const SupportCall& lhs, const SupportCall& rhs) - { - if (lhs.height != rhs.height) - return false; - if (lhs.slope != rhs.slope) - return false; - - return true; - } - - bool operator!=(const SupportCall& other) const - { - return !(*this == other); - } - - bool operator<(const SupportCall& other) const - { - if (height != other.height) - { - return height < other.height; - } - - return slope < other.slope; - } -}; - -namespace GeneralSupportHeightCall -{ - bool CallsMatch(SupportCall tileSupportCalls[4]); - - bool FindMostCommonSupportCall(SupportCall calls[4], SupportCall* out); - - bool AssertEquals(const SupportCall* lhs, const SupportCall* rhs); -}; // namespace GeneralSupportHeightCall diff --git a/test/testpaint/Hook.cpp b/test/testpaint/Hook.cpp deleted file mode 100644 index a0f0ce5566..0000000000 --- a/test/testpaint/Hook.cpp +++ /dev/null @@ -1,210 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include -#include -#include -#include - -#ifndef NO_RCT2 - -# ifdef _WIN32 -# include -# else -# include -# endif // _WIN32 - -# include "Hook.h" - -void* _hookTableAddress = 0; -int32_t _hookTableOffset = 0; -int32_t _maxHooks = 1000; -# define HOOK_BYTE_COUNT (140) - -registers gHookRegisters = {}; - -// This macro writes a little-endian 4-byte long value into *data -// It is used to avoid type punning. -# define write_address_strictalias(data, addr) \ - *(data + 0) = ((addr)&0x000000ff) >> 0; \ - *(data + 1) = ((addr)&0x0000ff00) >> 8; \ - *(data + 2) = ((addr)&0x00ff0000) >> 16; \ - *(data + 3) = ((addr)&0xff000000) >> 24; - -static void hookfunc(uintptr_t address, uintptr_t hookAddress, int32_t stacksize) -{ - int32_t i = 0; - uint8_t data[HOOK_BYTE_COUNT] = {}; - - uintptr_t registerAddress = (uintptr_t)&gHookRegisters; - - data[i++] = 0x89; // mov [gHookRegisters], eax - data[i++] = (0b000 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 4], ebx - data[i++] = (0b011 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 4); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 8], ecx - data[i++] = (0b001 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 8); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 12], edx - data[i++] = (0b010 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 12); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 16], esi - data[i++] = (0b110 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 16); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 20], edi - data[i++] = (0b111 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 20); - i += 4; - - data[i++] = 0x89; // mov [gHookRegisters + 24], ebp - data[i++] = (0b101 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 24); - i += 4; - - // work out distance to nearest 0xC - // (esp - numargs * 4) & 0xC - // move to align - 4 - // save that amount - - // push the registers to be on the stack to access as arguments - data[i++] = 0x68; // push gHookRegisters - write_address_strictalias(&data[i], registerAddress); - i += 4; - - data[i++] = 0xE8; // call - - write_address_strictalias(&data[i], hookAddress - address - i - 4); - i += 4; - - data[i++] = 0x83; // add esp, 4 - data[i++] = 0xC4; - data[i++] = 0x04; - - data[i++] = 0x25; // and eax,0xff - data[i++] = 0xff; - data[i++] = 0x00; - data[i++] = 0x00; - data[i++] = 0x00; - data[i++] = 0xc1; // shl eax, 8 - data[i++] = 0xe0; - data[i++] = 0x08; - data[i++] = 0x9e; // sahf - data[i++] = 0x9c; // pushf - - data[i++] = 0x8B; // mov eax, [gHookRegisters] - data[i++] = (0b000 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress); - i += 4; - - data[i++] = 0x8B; // mov ebx, [gHookRegisters + 4] - data[i++] = (0b011 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 4); - i += 4; - - data[i++] = 0x8B; // mov ecx, [gHookRegisters + 8] - data[i++] = (0b001 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 8); - i += 4; - - data[i++] = 0x8B; // mov edx, [gHookRegisters + 12] - data[i++] = (0b010 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 12); - i += 4; - - data[i++] = 0x8B; // mov esi, [gHookRegisters + 16] - data[i++] = (0b110 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 16); - i += 4; - - data[i++] = 0x8B; // mov edi, [gHookRegisters + 20] - data[i++] = (0b111 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 20); - i += 4; - - data[i++] = 0x8B; // mov ebp, [gHookRegisters + 24] - data[i++] = (0b101 << 3) | 0b101; - write_address_strictalias(&data[i], registerAddress + 24); - i += 4; - - data[i++] = 0x9d; // popf - - data[i++] = 0xC3; // retn - -# ifdef _WIN32 - WriteProcessMemory(GetCurrentProcess(), (LPVOID)address, data, i, 0); -# else - // We own the pages with PROT_WRITE | PROT_EXEC, we can simply just memcpy the data - memcpy((void*)address, data, i); -# endif // _WIN32 -} - -void addhook(uintptr_t address, hook_function function) -{ - if (!_hookTableAddress) - { - size_t size = _maxHooks * HOOK_BYTE_COUNT; -# ifdef _WIN32 - _hookTableAddress = VirtualAllocEx(GetCurrentProcess(), NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE); -# else - _hookTableAddress = mmap(NULL, size, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); - if (_hookTableAddress == MAP_FAILED) - { - perror("mmap"); - exit(1); - } -# endif // _WIN32 - } - if (_hookTableOffset > _maxHooks) - { - return; - } - uint32_t hookaddress = (uint32_t)((uint64_t)(_hookTableAddress)&0xFFFFFFFF) + (_hookTableOffset * HOOK_BYTE_COUNT); - uint8_t data[9]; - int32_t i = 0; - data[i++] = 0xE9; // jmp - - write_address_strictalias(&data[i], hookaddress - address - i - 4); - i += 4; - - data[i++] = 0xC3; // retn -# ifdef _WIN32 - WriteProcessMemory(GetCurrentProcess(), (LPVOID)address, data, i, 0); -# else - // We own the pages with PROT_WRITE | PROT_EXEC, we can simply just memcpy the data - int32_t err = mprotect((void*)0x401000, 0x8a4000 - 0x401000, PROT_READ | PROT_WRITE); - if (err != 0) - { - perror("mprotect"); - } - - memcpy((void*)address, data, i); - - err = mprotect((void*)0x401000, 0x8a4000 - 0x401000, PROT_READ | PROT_EXEC); - if (err != 0) - { - perror("mprotect"); - } -# endif // _WIN32 - hookfunc(hookaddress, (uintptr_t)function, 0); - _hookTableOffset++; -} - -#endif diff --git a/test/testpaint/Hook.h b/test/testpaint/Hook.h deleted file mode 100644 index bceffb7cec..0000000000 --- a/test/testpaint/Hook.h +++ /dev/null @@ -1,96 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#ifndef NO_RCT2 - -# include - -enum -{ - X86_FLAG_CARRY = 1 << 0, - X86_FLAG_PARITY = 1 << 2, - - X86_FLAG_ADJUST = 1 << 4, - - X86_FLAG_ZERO = 1 << 6, - X86_FLAG_SIGN = 1 << 7, -}; - -/** - * x86 register structure, only used for easy interop to RCT2 code. - */ -# pragma pack(push, 1) -struct registers -{ - union - { - int32_t eax; - int16_t ax; - struct - { - char al; - char ah; - }; - }; - union - { - int32_t ebx; - int16_t bx; - struct - { - char bl; - char bh; - }; - }; - union - { - int32_t ecx; - int16_t cx; - struct - { - char cl; - char ch; - }; - }; - union - { - int32_t edx; - int16_t dx; - struct - { - char dl; - char dh; - }; - }; - union - { - int32_t esi; - int16_t si; - }; - union - { - int32_t edi; - int16_t di; - }; - union - { - int32_t ebp; - int16_t bp; - }; -}; -assert_struct_size(registers, 7 * 4); -# pragma pack(pop) - -using hook_function = uint8_t (*)(registers* regs); - -void addhook(uintptr_t address, hook_function function); - -#endif diff --git a/test/testpaint/PaintIntercept.cpp b/test/testpaint/PaintIntercept.cpp deleted file mode 100644 index f5f0ec2df3..0000000000 --- a/test/testpaint/PaintIntercept.cpp +++ /dev/null @@ -1,412 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "PaintIntercept.hpp" - -#include "FunctionCall.hpp" -#include "Hook.h" -#include "TestPaint.hpp" - -#include -#include -#include -#include -#include - -paint_session gPaintSession; - -static bool _woodenSupports = false; -static uint8_t _callCount = 0; -static function_call _calls[256] = {}; -static paint_struct _paintStructs = {}; - -namespace PaintIntercept -{ - static uint8_t InterceptWoodenASupports(registers* regs); - static uint8_t InterceptWoodenBSupports(registers* regs); - static uint8_t InterceptMetalASupports(registers* regs); - static uint8_t InterceptMetalBSupports(registers* regs); - static uint8_t InterceptPaint6C(registers* regs); - static uint8_t InterceptPaint7C(registers* regs); - static uint8_t InterceptPaint8C(registers* regs); - static uint8_t InterceptPaint9C(registers* regs); - static uint8_t InterceptPaintFull(uint8_t function, registers* regs); - - bool PaintMetalSupports( - uint8_t function, int supportType, uint8_t segment, int special, int height, uint32_t imageColourFlags, - const support_height* supportSegments); - bool PaintWoodenSupports( - uint8_t function, int supportType, int special, int height, uint32_t imageColourFlags, bool* underground, - const paint_struct* prependTo); - static void CheckSegmentSupportHeight(const support_height* supportSegments); - - void InitHooks() - { - addhook(0x006629BC, InterceptWoodenASupports); - addhook(0x00662D5C, InterceptWoodenBSupports); - - addhook(0x00663105, InterceptMetalASupports); - addhook(0x00663584, InterceptMetalBSupports); - - addhook(0x006861AC, InterceptPaint6C); - addhook(0x00686337, InterceptPaint6C); - addhook(0x006864D0, InterceptPaint6C); - addhook(0x0068666B, InterceptPaint6C); - - addhook(0x00686806, InterceptPaint7C); - addhook(0x006869B2, InterceptPaint7C); - addhook(0x00686B6F, InterceptPaint7C); - addhook(0x00686D31, InterceptPaint7C); - - addhook(0x00686EF0, InterceptPaint8C); - addhook(0x00687056, InterceptPaint8C); - addhook(0x006871C8, InterceptPaint8C); - addhook(0x0068733C, InterceptPaint8C); - - addhook(0x006874B0, InterceptPaint9C); - addhook(0x00687618, InterceptPaint9C); - addhook(0x0068778C, InterceptPaint9C); - addhook(0x00687902, InterceptPaint9C); - } - - bool PaintWoodenSupports( - uint8_t function, int supportType, int special, int height, uint32_t imageColourFlags, bool* underground, - const paint_struct* prependTo) - { - function_call* call = &_calls[_callCount]; - call->function = function; - call->supports.type = supportType; - call->supports.special = special; - call->supports.height = height; - call->supports.colour_flags = imageColourFlags; - - call->supports.prepend_to = SPR_NONE; - if (prependTo != nullptr) - { - for (int i = 0; i < _callCount; i++) - { - if (&_calls[i].paint.output_struct == prependTo) - { - call->supports.prepend_to = _calls[i].paint.image_id; - break; - } - } - } - - _callCount++; - - return _woodenSupports; - } - - bool PaintMetalSupports( - uint8_t function, int supportType, uint8_t segment, int special, int height, uint32_t imageColourFlags, - const support_height* supportSegments) - { - CheckSegmentSupportHeight(supportSegments); - - function_call* call = &_calls[_callCount]; - call->function = function; - call->supports.type = supportType; - call->supports.segment = segment; - call->supports.special = special; - call->supports.height = height; - call->supports.colour_flags = imageColourFlags; - - _callCount++; - - return false; - } - - static paint_struct* Paint6C( - uint32_t imageID, int8_t xOffset, int8_t yOffset, int16_t boundBoxLengthX, int16_t boundBoxLengthY, - int8_t boundBoxLengthZ, int16_t zOffset, uint32_t rotation) - { - function_call* call = &_calls[_callCount]; - call->function = PAINT_98196C; - call->paint.image_id = imageID; - call->paint.offset = { xOffset, yOffset }; - call->paint.bound_box_length = { boundBoxLengthX, boundBoxLengthY, boundBoxLengthZ }; - call->paint.z_offset = zOffset; - call->paint.rotation = rotation; - - _callCount++; - - return &call->paint.output_struct; - } - - static paint_struct* PaintFull( - uint8_t function, uint32_t imageID, int8_t xOffset, int8_t yOffset, int16_t boundBoxLengthX, int16_t boundBoxLengthY, - int8_t boundBoxLengthZ, int16_t zOffset, int16_t boundBoxOffsetX, int16_t boundBoxOffsetY, int16_t boundBoxOffsetZ, - uint32_t rotation) - { - function_call* call = &_calls[_callCount]; - call->function = function; - call->paint.image_id = imageID; - call->paint.offset = { xOffset, yOffset }; - call->paint.bound_box_length = { boundBoxLengthX, boundBoxLengthY, boundBoxLengthZ }; - call->paint.bound_box_offset = { boundBoxOffsetX, boundBoxOffsetY, boundBoxOffsetZ }; - call->paint.z_offset = zOffset; - call->paint.rotation = rotation; - - _callCount++; - - return &call->paint.output_struct; - } - - static paint_struct* PaintFull( - uint8_t function, uint32_t image_id, const CoordsXYZ& offset, const CoordsXYZ& boundBoxLength, - const CoordsXYZ& boundBoxOffset, uint32_t rotation) - { - return PaintFull( - function, image_id, static_cast(offset.x), static_cast(offset.y), - static_cast(boundBoxLength.x), static_cast(boundBoxLength.y), - static_cast(boundBoxLength.z), static_cast(offset.z), static_cast(boundBoxOffset.x), - static_cast(boundBoxOffset.y), static_cast(boundBoxOffset.z), rotation); - } - - void ClearCalls() - { - _callCount = 0; - memset(_calls, 0, sizeof(_calls)); - } - - int GetCalls(function_call* buffer) - { - memcpy(buffer, _calls, _callCount * sizeof(function_call)); - return _callCount; - } - - void SetSimulateWoodenSupports(bool enabled) - { - _woodenSupports = enabled; - } - - static uint8_t InterceptMetalASupports(registers* regs) - { - bool output = PaintMetalSupports( - SUPPORTS_METAL_A, regs->edi, regs->ebx, (int16_t)regs->ax, regs->dx, regs->ebp, gSupportSegments); - - return output ? X86_FLAG_CARRY : 0; - } - - static uint8_t InterceptMetalBSupports(registers* regs) - { - bool output = PaintMetalSupports( - SUPPORTS_METAL_B, regs->edi, regs->ebx, (int16_t)regs->ax, regs->dx, regs->ebp, gSupportSegments); - - return output ? X86_FLAG_CARRY : 0; - } - - static void CheckSegmentSupportHeight(const support_height* supportSegments) - { - bool hasChanged = false; - for (int i = 0; i < 9; i++) - { - if (supportSegments[i].height != 0) - hasChanged = true; - if (supportSegments[i].slope != 0xFF) - hasChanged = true; - } - - if (!hasChanged) - { - return; - } - - function_call call = {}; - call.function = SET_SEGMENT_HEIGHT; - - _calls[_callCount] = call; - _callCount++; - } - - static uint8_t InterceptWoodenASupports(registers* regs) - { - bool cf = false; - regs->al = PaintWoodenSupports( - SUPPORTS_WOOD_A, regs->edi, regs->ax, regs->dx, regs->ebp, &cf, gWoodenSupportsPrependTo); - - if (cf) - { - return X86_FLAG_CARRY; - } - - return 0; - } - - static uint8_t InterceptWoodenBSupports(registers* regs) - { - bool cf = false; - regs->al = PaintWoodenSupports( - SUPPORTS_WOOD_B, regs->edi, regs->ax, regs->dx, regs->ebp, &cf, gWoodenSupportsPrependTo); - - if (cf) - { - return X86_FLAG_CARRY; - } - - return 0; - } - - static uint8_t InterceptPaint6C(registers* regs) - { - if ((regs->ebp & 0x03) != RCT2_CurrentRotation) - { - // Log error - log_error("Ebp is different from current rotation"); - } - - paint_struct* out = Paint6C( - regs->ebx, (int8_t)regs->al, (int8_t)regs->cl, (int16_t)regs->di, (int16_t)regs->si, (int8_t)regs->ah, regs->dx, - regs->ebp & 0x03); - - if (out == nullptr) - { - return X86_FLAG_CARRY; - } - - regs->ebp = (int)out; - regs->al = 1; - return 0; - } - - static uint8_t InterceptPaint7C(registers* regs) - { - return InterceptPaintFull(PAINT_98197C, regs); - } - - static uint8_t InterceptPaint8C(registers* regs) - { - return InterceptPaintFull(PAINT_98198C, regs); - } - - static uint8_t InterceptPaint9C(registers* regs) - { - return InterceptPaintFull(PAINT_98199C, regs); - } - - static uint8_t InterceptPaintFull(uint8_t function, registers* regs) - { - if ((regs->ebp & 0x03) != RCT2_CurrentRotation) - { - // Log error - log_error("Ebp is different from current rotation"); - } - - LocationXYZ16 boundOffset = { RCT2_PaintBoundBoxOffsetX, RCT2_PaintBoundBoxOffsetY, RCT2_PaintBoundBoxOffsetZ }; - - paint_struct* out = PaintFull( - function, regs->ebx, (int8_t)regs->al, (int8_t)regs->cl, (int16_t)regs->di, (int16_t)regs->si, (int8_t)regs->ah, - regs->dx, boundOffset.x, boundOffset.y, boundOffset.z, regs->ebp & 0x03); - - if (out == nullptr) - { - return X86_FLAG_CARRY; - } - - regs->ebp = (int)out; - return 0; - } -}; // namespace PaintIntercept - -bool wooden_a_supports_paint_setup( - paint_session* session, int supportType, int special, int height, uint32_t imageColourFlags, bool* underground) -{ - return PaintIntercept::PaintWoodenSupports( - SUPPORTS_WOOD_A, supportType, special, height, imageColourFlags, underground, gPaintSession.WoodenSupportsPrependTo); -} - -bool wooden_b_supports_paint_setup( - paint_session* session, int supportType, int special, int height, uint32_t imageColourFlags, bool* underground) -{ - return PaintIntercept::PaintWoodenSupports( - SUPPORTS_WOOD_B, supportType, special, height, imageColourFlags, underground, gPaintSession.WoodenSupportsPrependTo); -} - -bool metal_a_supports_paint_setup( - paint_session* session, uint8_t supportType, uint8_t segment, int special, int height, uint32_t imageColourFlags) -{ - return PaintIntercept::PaintMetalSupports( - SUPPORTS_METAL_A, supportType, segment, special, height, imageColourFlags, gPaintSession.SupportSegments); -} - -bool metal_b_supports_paint_setup( - paint_session* session, uint8_t supportType, uint8_t segment, int special, int height, uint32_t imageColourFlags) -{ - return PaintIntercept::PaintMetalSupports( - SUPPORTS_METAL_B, supportType, segment, special, height, imageColourFlags, gPaintSession.SupportSegments); -} - -paint_struct* PaintAddImageAsParent( - paint_session* session, uint32_t image_id, int8_t x_offset, int8_t y_offset, int16_t bound_box_length_x, - int16_t bound_box_length_y, int8_t bound_box_length_z, int16_t z_offset) -{ - return PaintIntercept::Paint6C( - image_id, x_offset, y_offset, bound_box_length_x, bound_box_length_y, bound_box_length_z, z_offset, - session->CurrentRotation); -} - -paint_struct* PaintAddImageAsParent( - paint_session* session, uint32_t image_id, const CoordsXYZ& offset, const CoordsXYZ& boundBoxSize) -{ - return PaintIntercept::Paint6C( - image_id, offset.x, offset.y, boundBoxSize.x, boundBoxSize.y, boundBoxSize.z, offset.z, session->CurrentRotation); -} - -paint_struct* PaintAddImageAsParent( - paint_session* session, uint32_t image_id, int8_t x_offset, int8_t y_offset, int16_t bound_box_length_x, - int16_t bound_box_length_y, int8_t bound_box_length_z, int16_t z_offset, int16_t bound_box_offset_x, - int16_t bound_box_offset_y, int16_t bound_box_offset_z) -{ - return PaintIntercept::PaintFull( - PAINT_98197C, image_id, x_offset, y_offset, bound_box_length_x, bound_box_length_y, bound_box_length_z, z_offset, - bound_box_offset_x, bound_box_offset_y, bound_box_offset_z, session->CurrentRotation); -} - -paint_struct* PaintAddImageAsParent( - paint_session* session, uint32_t image_id, const CoordsXYZ& offset, const CoordsXYZ& boundBoxSize, - const CoordsXYZ& boundBoxOffset) -{ - return PaintAddImageAsParent( - session, image_id, offset.x, offset.y, boundBoxSize.x, boundBoxSize.y, boundBoxSize.z, offset.z, boundBoxOffset.x, - boundBoxOffset.y, boundBoxOffset.z); -} - -paint_struct* PaintAddImageAsChild( - paint_session* session, uint32_t image_id, const CoordsXYZ& offset, const CoordsXYZ& boundBoxLength, - const CoordsXYZ& boundBoxOffset) -{ - return PaintIntercept::PaintFull( - PAINT_98198C_COORDS, image_id, offset, boundBoxLength, boundBoxOffset, session->CurrentRotation); -} - -paint_struct* PaintAddImageAsOrphan( - paint_session* session, uint32_t image_id, int8_t x_offset, int8_t y_offset, int16_t bound_box_length_x, - int16_t bound_box_length_y, int8_t bound_box_length_z, int16_t z_offset, int16_t bound_box_offset_x, - int16_t bound_box_offset_y, int16_t bound_box_offset_z) -{ - return PaintIntercept::PaintFull( - PAINT_98198C, image_id, x_offset, y_offset, bound_box_length_x, bound_box_length_y, bound_box_length_z, z_offset, - bound_box_offset_x, bound_box_offset_y, bound_box_offset_z, session->CurrentRotation); -} - -paint_struct* PaintAddImageAsChild( - paint_session* session, uint32_t image_id, int8_t x_offset, int8_t y_offset, int16_t bound_box_length_x, - int16_t bound_box_length_y, int8_t bound_box_length_z, int16_t z_offset, int16_t bound_box_offset_x, - int16_t bound_box_offset_y, int16_t bound_box_offset_z) -{ - return PaintIntercept::PaintFull( - PAINT_98199C, image_id, x_offset, y_offset, bound_box_length_x, bound_box_length_y, bound_box_length_z, z_offset, - bound_box_offset_x, bound_box_offset_y, bound_box_offset_z, session->CurrentRotation); -} - -bool PaintAttachToPreviousPS(paint_session* session, uint32_t image_id, int16_t x, int16_t y) -{ - return false; -} diff --git a/test/testpaint/PaintIntercept.hpp b/test/testpaint/PaintIntercept.hpp deleted file mode 100644 index efa238b20c..0000000000 --- a/test/testpaint/PaintIntercept.hpp +++ /dev/null @@ -1,24 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include "FunctionCall.hpp" - -#include - -namespace PaintIntercept -{ - void InitHooks(); - - void ClearCalls(); - int GetCalls(function_call* buffer); - - void SetSimulateWoodenSupports(bool enabled); -}; // namespace PaintIntercept diff --git a/test/testpaint/Printer.cpp b/test/testpaint/Printer.cpp deleted file mode 100644 index af7578fad4..0000000000 --- a/test/testpaint/Printer.cpp +++ /dev/null @@ -1,309 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "Printer.hpp" - -#include "FunctionCall.hpp" -#include "String.hpp" - -#include -#include - -namespace Printer -{ - static const char* functionNames[] = { - "sub_98196C", - "sub_98197C", - "sub_98198C", - "sub_98199C", - "metal_a_supports_paint_setup", - "metal_b_supports_paint_setup", - "wooden_a_supports_paint_setup", - "wooden_b_supports_paint_setup", - "paint_util_set_segment_support_height", - }; - - static std::string GetImageIdString(uint32_t imageId); - - static std::string GetOffsetExpressionString(int offset); - - static std::string PrintSegmentSupportHeightCall(SegmentSupportCall call); - - static std::string PrintSideTunnelEdge(TunnelCall edge); - - std::string PrintFunctionCalls(std::vector calls, uint16_t baseHeight) - { - std::string out; - - for (auto&& call : calls) - { - out += PrintFunctionCall(call, baseHeight).c_str(); - out += "\n"; - } - - return out; - } - - std::string PrintFunctionCall(function_call call, uint16_t baseHeight) - { - std::string imageId = GetImageIdString(call.supports.colour_flags); - assert(call.function < std::size(functionNames)); - const char* functionName = functionNames[call.function]; - std::string out = ""; - - switch (call.function) - { - case SUPPORTS_WOOD_A: - case SUPPORTS_WOOD_B: - out += String::Format( - "%s(%d, %d, %s, %s)", functionName, call.supports.type, call.supports.special, - PrintHeightOffset(call.supports.height, baseHeight).c_str(), imageId.c_str()); - if (call.supports.special == 14 || call.supports.special == 15 || call.supports.special == 18 - || call.supports.special == 19 || call.supports.special == 22 || call.supports.special == 23) - { - if (call.supports.prepend_to == SPR_NONE) - { - out += " [prependTo:SPR_NONE]"; - } - else - { - std::string prependId = GetImageIdString(call.supports.prepend_to); - out += String::Format(" [prependTo:%s]", prependId.c_str()); - } - } - else if (call.supports.prepend_to != SPR_NONE) - { - std::string prependId = GetImageIdString(call.supports.prepend_to); - out += String::Format(" [prependTo:%s]", prependId.c_str()); - } - return out; - - case SUPPORTS_METAL_A: - case SUPPORTS_METAL_B: - return String::Format( - "%s(%d, %d, %d, %s, %s)", functionName, call.supports.type, call.supports.segment, call.supports.special, - PrintHeightOffset(call.supports.height, baseHeight).c_str(), imageId.c_str()); - - case SET_SEGMENT_HEIGHT: - return "paint_util_set_segment_support_height"; - } - - std::string s = String::Format("%s(", functionName); - - imageId = GetImageIdString(call.paint.image_id); - s += String::Format("%s, ", imageId.c_str()); - s += String::Format("%d, %d, ", call.paint.offset.x, call.paint.offset.y); - s += String::Format( - "%d, %d, %d, ", call.paint.bound_box_length.x, call.paint.bound_box_length.y, call.paint.bound_box_length.z); - s += String::Format("%s, ", PrintHeightOffset(call.paint.z_offset, baseHeight).c_str()); - - if (call.function != PAINT_98196C) - { - s += String::Format( - "%d, %d, %s, ", call.paint.bound_box_offset.x, call.paint.bound_box_offset.y, - PrintHeightOffset(call.paint.bound_box_offset.z, baseHeight).c_str()); - } - - s += String::Format("%d)", call.paint.rotation); - - if (call.function != PAINT_98196C) - { - s += String::Format( - " = { %d, %d, %s }, { %d, %d, %s }, { %d, %d, %d }", call.paint.offset.x, call.paint.offset.y, - PrintHeightOffset(call.paint.z_offset, baseHeight).c_str(), call.paint.bound_box_offset.x, - call.paint.bound_box_offset.y, PrintHeightOffset(call.paint.bound_box_offset.z, baseHeight).c_str(), - call.paint.bound_box_length.x, call.paint.bound_box_length.y, call.paint.bound_box_length.z); - } - - return s; - } - - std::string PrintSegmentSupportHeightCalls(std::vector calls) - { - std::string out = ""; - - for (auto&& call : calls) - { - out += PrintSegmentSupportHeightCall(call); - } - - return out; - } - - static std::string PrintSegmentSupportHeightCall(SegmentSupportCall call) - { - std::string out = ""; - - if (call.segments == SEGMENTS_ALL) - { - out += "SEGMENTS_ALL"; - } - else - { - int segmentsPrinted = 0; - for (int i = 0; i < 9; i++) - { - if (call.segments & segment_offsets[i]) - { - if (segmentsPrinted > 0) - { - out += " | "; - } - out += String::Format("SEGMENT_%02X", 0xB4 + 4 * i); - segmentsPrinted++; - } - } - } - - if (call.height == 0xFFFF) - { - out += ", 0xFFFF"; - } - else - { - out += String::Format(", %d", call.height); - } - - out += String::Format(", 0x%02X\n", call.slope); - - return out; - } - - std::string PrintSideTunnelCalls(TunnelCall tunnelCalls[4][4]) - { - std::string s; - - for (int direction = 0; direction < 4; ++direction) - { - s += " + "; - } - s += "\n"; - - for (int direction = 0; direction < 4; ++direction) - { - std::string leftEdge = PrintSideTunnelEdge(tunnelCalls[direction][3]); - std::string rightEdge = PrintSideTunnelEdge(tunnelCalls[direction][2]); - s += String::Format(" %s %s ", leftEdge.c_str(), rightEdge.c_str()); - } - s += "\n"; - - for (int direction = 0; direction < 4; ++direction) - { - s += " + + "; - } - s += "\n"; - - for (int direction = 0; direction < 4; ++direction) - { - std::string leftEdge = PrintSideTunnelEdge(tunnelCalls[direction][0]); - std::string rightEdge = PrintSideTunnelEdge(tunnelCalls[direction][1]); - s += String::Format(" %s %s ", leftEdge.c_str(), rightEdge.c_str()); - } - s += "\n"; - - for (int direction = 0; direction < 4; ++direction) - { - s += " + "; - } - s += "\n"; - - for (int direction = 0; direction < 4; ++direction) - { - s += String::Format(" direction %d ", direction); - } - s += "\n"; - - return s; - } - - static std::string PrintSideTunnelEdge(TunnelCall edge) - { - std::string s; - - switch (edge.call) - { - case TUNNELCALL_SKIPPED: - s = " "; - break; - - case TUNNELCALL_NONE: - s = " - "; - break; - - case TUNNELCALL_CALL: - std::string offset; - - if (edge.offset <= 0) - { - offset = String::Format("%d", edge.offset); - } - else - { - offset = String::Format("+%d", edge.offset); - } - s = String::Format("%3s/%X", offset.c_str(), edge.type); - break; - } - - return s; - } - - static std::string GetImageIdString(uint32_t imageId) - { - std::string result; - - uint32_t image = imageId & 0x7FFFF; - uint32_t palette = imageId & ~0x7FFFF; - - std::string paletteName; - if (palette == TestPaint::DEFAULT_SCHEME_TRACK) - paletteName = "SCHEME_TRACK"; - else if (palette == TestPaint::DEFAULT_SCHEME_SUPPORTS) - paletteName = "SCHEME_SUPPORTS"; - else if (palette == TestPaint::DEFAULT_SCHEME_MISC) - paletteName = "SCHEME_MISC"; - else if (palette == TestPaint::DEFAULT_SCHEME_3) - paletteName = "SCHEME_3"; - else - { - paletteName = String::Format("0x%08X", palette); - } - - if (image == 0) - { - result = paletteName; - } - else if (image & 0x70000) - { - result = String::Format("%s | vehicle.base_image_id + %d", paletteName.c_str(), image & ~0x70000); - } - else - { - result = String::Format("%s | %d", paletteName.c_str(), image); - } - - return result; - } - - std::string PrintHeightOffset(uint16_t height, uint16_t baseHeight) - { - int offset = height - baseHeight; - - return String::Format("height%s", GetOffsetExpressionString(offset).c_str()); - } - - static std::string GetOffsetExpressionString(int offset) - { - if (offset < 0) - return std::string(" - ") + std::to_string(-offset); - if (offset > 0) - return std::string(" + ") + std::to_string(offset); - return std::string(); - } -}; // namespace Printer diff --git a/test/testpaint/Printer.hpp b/test/testpaint/Printer.hpp deleted file mode 100644 index e2ad491f09..0000000000 --- a/test/testpaint/Printer.hpp +++ /dev/null @@ -1,29 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include "FunctionCall.hpp" -#include "SegmentSupportHeightCall.hpp" -#include "SideTunnelCall.hpp" - -#include -#include - -namespace Printer -{ - std::string PrintFunctionCall(function_call call, uint16_t baseHeight); - std::string PrintFunctionCalls(std::vector calls, uint16_t baseHeight); - - std::string PrintSegmentSupportHeightCalls(std::vector calls); - - std::string PrintSideTunnelCalls(TunnelCall tunnelCalls[4][4]); - - std::string PrintHeightOffset(uint16_t height, uint16_t baseHeight); -} // namespace Printer diff --git a/test/testpaint/SegmentSupportHeightCall.cpp b/test/testpaint/SegmentSupportHeightCall.cpp deleted file mode 100644 index 7fa8203862..0000000000 --- a/test/testpaint/SegmentSupportHeightCall.cpp +++ /dev/null @@ -1,155 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "SegmentSupportHeightCall.hpp" - -#include -#include -#include - -static bool SortSegmentSupportCalls(SegmentSupportCall lhs, SegmentSupportCall rhs) -{ - if (lhs.height != rhs.height) - { - return lhs.height < rhs.height; - } - - if (lhs.slope != rhs.slope) - { - return lhs.slope < rhs.slope; - } - - return lhs.segments < rhs.segments; -} - -std::vector SegmentSupportHeightCall::getSegmentCalls(support_height* supports, uint8_t rotation) -{ - uint16_t positionsRemaining = SEGMENTS_ALL; - - for (int i = 0; i < 9; i++) - { - if (supports[i].height == 0 && supports[i].slope == 0xFF) - { - positionsRemaining &= ~segment_offsets[i]; - } - } - - std::vector calls; - - while (positionsRemaining != 0) - { - SegmentSupportCall call = {}; - call.height = -1; - call.slope = -1; - - support_height referenceSupport = {}; - - for (int i = 0; i < 9; i++) - { - if (positionsRemaining & segment_offsets[i]) - { - referenceSupport = supports[i]; - if (supports[i].height != 0) - { - call.height = supports[i].height; - } - if (supports[i].slope != 0xFF) - { - call.slope = supports[i].slope; - } - break; - } - } - - uint16_t positionsMatched = 0; - for (int i = 0; i < 9; i++) - { - if (supports[i].height == referenceSupport.height && supports[i].slope == referenceSupport.slope) - { - positionsMatched |= segment_offsets[i]; - } - } - positionsRemaining &= ~positionsMatched; - - call.segments = paint_util_rotate_segments(positionsMatched, (4 - rotation) % 4); - - calls.push_back(call); - } - - if (calls.size() > 1) - { - std::sort(calls.begin(), calls.end(), SortSegmentSupportCalls); - } - - return calls; -} - -bool SegmentSupportHeightCall::CallsMatch(std::vector tileSegmentSupportCalls[4]) -{ - std::vector baseCallList = tileSegmentSupportCalls[0]; - for (int i = 1; i < 4; i++) - { - if (!CallsEqual(baseCallList, tileSegmentSupportCalls[i])) - { - return false; - } - } - - return true; -} - -bool SegmentSupportHeightCall::CallsEqual(std::vector lhs, std::vector rhs) -{ - if (lhs.size() != rhs.size()) - return false; - for (size_t i = 0; i < lhs.size(); ++i) - { - if (lhs[i].segments != rhs[i].segments) - return false; - if (lhs[i].height != rhs[i].height) - return false; - if (lhs[i].slope != rhs[i].slope) - return false; - } - - return true; -} - -bool SegmentSupportHeightCall::FindMostCommonSupportCall( - std::vector calls[4], std::vector* out) -{ - std::map, int> map; - - for (int i = 0; i < 4; ++i) - { - map[calls[i]] += 1; - } - - if (map.size() == 1) - { - (*out) = calls[0]; - return true; - } - - if (map.size() == 2) - { - for (auto&& item : map) - { - if (item.second == 3) - { - (*out) = item.first; - return true; - } - } - - return false; - } - - return false; -} diff --git a/test/testpaint/SegmentSupportHeightCall.hpp b/test/testpaint/SegmentSupportHeightCall.hpp deleted file mode 100644 index 4d830f3215..0000000000 --- a/test/testpaint/SegmentSupportHeightCall.hpp +++ /dev/null @@ -1,45 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include -#include -#include - -struct SegmentSupportCall -{ - uint16_t segments; - int32_t height; - int16_t slope; - - bool operator<(const SegmentSupportCall& other) const - { - if (height != other.height) - { - return height < other.height; - } - - if (segments != other.segments) - { - return segments < other.segments; - } - - return slope < other.slope; - } -}; - -class SegmentSupportHeightCall -{ -public: - static std::vector getSegmentCalls(support_height supports[9], uint8_t rotation); - static bool CallsMatch(std::vector tileSegmentSupportCalls[4]); - static bool CallsEqual(std::vector lhs, std::vector rhs); - static bool FindMostCommonSupportCall(std::vector calls[4], std::vector* out); -}; diff --git a/test/testpaint/SideTunnelCall.cpp b/test/testpaint/SideTunnelCall.cpp deleted file mode 100644 index 2bad52d0ec..0000000000 --- a/test/testpaint/SideTunnelCall.cpp +++ /dev/null @@ -1,121 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "SideTunnelCall.hpp" - -int16_t SideTunnelCall::GetTunnelOffset(uint32_t baseHeight, tunnel_entry calls[3]) -{ - for (int16_t offset = -56; offset <= 56; offset += 8) - { - if (calls[0].height != (baseHeight - 8 + offset) / 16) - continue; - if (calls[1].height != (baseHeight + 0 + offset) / 16) - continue; - if (calls[2].height != (baseHeight + 8 + offset) / 16) - continue; - - return offset; - } - - log_error("Unknown tunnel height. (%d, %d, %d)", calls[0].height, calls[1].height, calls[2].height); - return 0; -} - -TunnelCall SideTunnelCall::ExtractTunnelCalls(tunnel_entry* calls, uint8_t count, uint16_t baseHeight, bool* error) -{ - TunnelCall tunnelCall = {}; - - if (count == 0) - { - tunnelCall.call = TUNNELCALL_NONE; - return tunnelCall; - } - - if (count == 3) - { - tunnelCall.call = TUNNELCALL_CALL; - tunnelCall.offset = GetTunnelOffset(baseHeight, calls); - tunnelCall.type = calls[0].type; - return tunnelCall; - } - - *error = true; - return tunnelCall; -} - -bool SideTunnelCall::TunnelCallsLineUp(TunnelCall tunnelCalls[4][4]) -{ - for (int side = 0; side < 4; ++side) - { - TunnelCall* referenceCall = nullptr; - for (int direction = 0; direction < 4; ++direction) - { - if (tunnelCalls[direction][side].call == TUNNELCALL_SKIPPED) - { - continue; - } - - if (referenceCall == nullptr) - { - referenceCall = &tunnelCalls[direction][side]; - continue; - } - - if (referenceCall->call != tunnelCalls[direction][side].call) - return false; - - if (referenceCall->call == TUNNELCALL_CALL) - { - if (referenceCall->type != tunnelCalls[direction][side].type) - return false; - if (referenceCall->offset != tunnelCalls[direction][side].offset) - return false; - } - } - } - - return true; -} - -void SideTunnelCall::GetTunnelCallReferencePattern(TunnelCall tunnelCalls[4][4], TunnelCall (*out)[4]) -{ - for (int side = 0; side < 4; ++side) - { - for (int direction = 0; direction < 4; ++direction) - { - if (tunnelCalls[direction][side].call == TUNNELCALL_SKIPPED) - { - continue; - } - - (*out)[side].call = tunnelCalls[direction][side].call; - (*out)[side].type = tunnelCalls[direction][side].type; - (*out)[side].offset = tunnelCalls[direction][side].offset; - } - } -} - -bool SideTunnelCall::TunnelPatternsMatch(TunnelCall expected[4], TunnelCall actual[4]) -{ - for (int side = 0; side < 4; side++) - { - if (expected[side].call != actual[side].call) - return false; - - if (expected[side].call == TUNNELCALL_CALL) - { - if (expected[side].type != actual[side].type) - return false; - if (expected[side].offset != actual[side].offset) - return false; - } - } - - return true; -} diff --git a/test/testpaint/SideTunnelCall.hpp b/test/testpaint/SideTunnelCall.hpp deleted file mode 100644 index 5c440efb94..0000000000 --- a/test/testpaint/SideTunnelCall.hpp +++ /dev/null @@ -1,37 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include -#include - -enum -{ - TUNNELCALL_SKIPPED, - TUNNELCALL_NONE, - TUNNELCALL_CALL, -}; - -struct TunnelCall -{ - uint8_t call; - int16_t offset; - uint8_t type; -}; - -namespace SideTunnelCall -{ - int16_t GetTunnelOffset(uint32_t baseHeight, tunnel_entry calls[3]); - TunnelCall ExtractTunnelCalls(tunnel_entry* list, uint8_t count, uint16_t baseHeight, bool* error); - - bool TunnelPatternsMatch(TunnelCall expected[4], TunnelCall actual[4]); - void GetTunnelCallReferencePattern(TunnelCall tunnelCalls[4][4], TunnelCall (*out)[4]); - bool TunnelCallsLineUp(TunnelCall tunnelCalls[4][4]); -}; // namespace SideTunnelCall diff --git a/test/testpaint/String.cpp b/test/testpaint/String.cpp deleted file mode 100644 index f4b30c666c..0000000000 --- a/test/testpaint/String.cpp +++ /dev/null @@ -1,27 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "String.hpp" - -#include - -namespace String -{ - std::string Format(const char* format, ...) - { - va_list args; - char buffer[512]; - - va_start(args, format); - vsnprintf(buffer, sizeof(buffer), format, args); - va_end(args); - - return std::string(buffer); - } -}; // namespace String diff --git a/test/testpaint/String.hpp b/test/testpaint/String.hpp deleted file mode 100644 index 3f3b9713d4..0000000000 --- a/test/testpaint/String.hpp +++ /dev/null @@ -1,17 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include - -namespace String -{ - std::string Format(const char* format, ...); -} diff --git a/test/testpaint/TestPaint.cpp b/test/testpaint/TestPaint.cpp deleted file mode 100644 index 334fd850b6..0000000000 --- a/test/testpaint/TestPaint.cpp +++ /dev/null @@ -1,174 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "TestPaint.hpp" - -#include "GeneralSupportHeightCall.hpp" -#include "Hook.h" -#include "Printer.hpp" -#include "SegmentSupportHeightCall.hpp" -#include "Utils.hpp" - -#include -#include -#include -#include -#include -#include -#include - -namespace TestPaint -{ - void ResetEnvironment() - { - gPaintInteractionType = EnumValue(ViewportInteractionItem::Ride); - gPaintSession.InteractionType = ViewportInteractionItem::Ride; - - gTrackColours[SCHEME_TRACK] = DEFAULT_SCHEME_TRACK; - gTrackColours[SCHEME_SUPPORTS] = DEFAULT_SCHEME_SUPPORTS; - gTrackColours[SCHEME_MISC] = DEFAULT_SCHEME_MISC; - gTrackColours[SCHEME_3] = DEFAULT_SCHEME_3; - - gPaintSession.TrackColours[SCHEME_TRACK] = DEFAULT_SCHEME_TRACK; - gPaintSession.TrackColours[SCHEME_SUPPORTS] = DEFAULT_SCHEME_SUPPORTS; - gPaintSession.TrackColours[SCHEME_MISC] = DEFAULT_SCHEME_MISC; - gPaintSession.TrackColours[SCHEME_3] = DEFAULT_SCHEME_3; - - rct_drawpixelinfo dpi = {}; - dpi.zoom_level = 1; - RCT2_Unk140E9A8 = &dpi; - gPaintSession.DPI = dpi; - - { - static rct_ride_entry rideEntry = {}; - rct_ride_entry_vehicle vehicleEntry{}; - vehicleEntry.base_image_id = 0x70000; - rideEntry.vehicles[0] = vehicleEntry; - gRideList[0] = {}; - gRideEntries[0] = &rideEntry; - } - { - rct2_ride ride = {}; - ride.entrance_style = 0; - RCT2_Rides[0] = ride; - } - - g141E9DB = G141E9DB_FLAG_1 | G141E9DB_FLAG_2; - gPaintSession.Unk141E9DB = G141E9DB_FLAG_1 | G141E9DB_FLAG_2; - - RCT2_CurrentViewportFlags = 0; - - gScenarioTicks = 0; - RCT2_ScenarioTicks = 0; - } - - void ResetTunnels() - { - gLeftTunnelCount = 0; - gRightTunnelCount = 0; - gPaintSession.LeftTunnelCount = 0; - gPaintSession.RightTunnelCount = 0; - - for (int i = 0; i < TUNNEL_MAX_COUNT; i++) - { - gLeftTunnels[i].height = 0; - gLeftTunnels[i].type = 0; - gRightTunnels[i].height = 0; - gRightTunnels[i].type = 0; - gPaintSession.LeftTunnels[i].height = 0; - gPaintSession.LeftTunnels[i].type = 0; - gPaintSession.RightTunnels[i].height = 0; - gPaintSession.RightTunnels[i].type = 0; - } - - gLeftTunnels[0].height = 0xFF; - gLeftTunnels[0].type = 0xFF; - gRightTunnels[0].height = 0xFF; - gRightTunnels[0].type = 0xFF; - gPaintSession.LeftTunnels[0].height = 0xFF; - gPaintSession.LeftTunnels[0].type = 0xFF; - gPaintSession.RightTunnels[0].height = 0xFF; - gPaintSession.RightTunnels[0].type = 0xFF; - } - - void ResetSupportHeights() - { - for (int s = 0; s < 9; ++s) - { - gSupportSegments[s].height = 0; - gSupportSegments[s].slope = 0xFF; - gPaintSession.SupportSegments[s].height = 0; - gPaintSession.SupportSegments[s].slope = 0xFF; - } - - gSupport.height = 0; - gSupport.slope = 0xFF; - gPaintSession.Support.height = 0; - gPaintSession.Support.slope = 0xFF; - } - - struct IgnoredEntry - { - uint8_t Direction; - uint8_t TrackSequence; - }; - - static bool _ignoredAll; - static std::vector _ignoredEntries; - - void testClearIgnore() - { - _ignoredAll = false; - _ignoredEntries.clear(); - } - - void testIgnore(uint8_t direction, uint8_t trackSequence) - { - _ignoredEntries.push_back({ direction, trackSequence }); - } - - void testIgnoreAll() - { - _ignoredAll = true; - } - - bool testIsIgnored(uint8_t direction, uint8_t trackSequence) - { - if (_ignoredAll) - return true; - for (const IgnoredEntry& entry : _ignoredEntries) - { - if (entry.Direction == direction && entry.TrackSequence == trackSequence) - { - return true; - } - } - return false; - } -} // namespace TestPaint - -void testpaint_clear_ignore() -{ - TestPaint::testClearIgnore(); -} - -void testpaint_ignore(uint8_t direction, uint8_t trackSequence) -{ - TestPaint::testIgnore(direction, trackSequence); -} - -void testpaint_ignore_all() -{ - TestPaint::testIgnoreAll(); -} - -bool testpaint_is_ignored(uint8_t direction, uint8_t trackSequence) -{ - return TestPaint::testIsIgnored(direction, trackSequence); -} diff --git a/test/testpaint/TestPaint.hpp b/test/testpaint/TestPaint.hpp deleted file mode 100644 index 3e96cf123d..0000000000 --- a/test/testpaint/TestPaint.hpp +++ /dev/null @@ -1,81 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include "Addresses.h" - -#include -#include -#include -#include -#include -#include -#include - -#define gRideEntries RCT2_ADDRESS(0x009ACFA4, rct_ride_entry*) -#define gSupportSegments RCT2_ADDRESS(0x0141E9B4, support_height) -#define gWoodenSupportsPrependTo RCT2_GLOBAL(0x009DEA58, paint_struct*) -#define g_currently_drawn_item RCT2_GLOBAL(0x009DE578, void*) -#define gPaintInteractionType RCT2_GLOBAL(0x009DE570, uint8_t) -#define gSupportSegments RCT2_ADDRESS(0x0141E9B4, support_height) -#define gSupport RCT2_GLOBAL(0x0141E9D8, support_height) -#define gWoodenSupportsPrependTo RCT2_GLOBAL(0x009DEA58, paint_struct*) -#define gPaintMapPosition RCT2_GLOBAL(0x009DE574, LocationXY16) -#define gLeftTunnels RCT2_ADDRESS(0x009E3138, tunnel_entry) -#define gLeftTunnelCount RCT2_GLOBAL(0x0141F56A, uint8_t) -#define gRightTunnels RCT2_ADDRESS(0x009E30B6, tunnel_entry) -#define gRightTunnelCount RCT2_GLOBAL(0x0141F56B, uint8_t) -#define gVerticalTunnelHeight RCT2_GLOBAL(0x009E323C, uint8_t) -#define gSurfaceElement RCT2_GLOBAL(0x009E3250, TileElement*) -#define gDidPassSurface RCT2_GLOBAL(0x009DE57C, bool) -#define g141E9DB RCT2_GLOBAL(0x0141E9DB, uint8_t) -#define gTrackColours RCT2_ADDRESS(0x00F44198, uint32_t) -#define RCT2_CurrentViewportFlags RCT2_GLOBAL(0x0141E9E4, uint32_t) -#define RCT2_CurrentRotation RCT2_GLOBAL(0x0141E9E0, uint8_t) -#define RCT2_ScenarioTicks RCT2_GLOBAL(0x00F663AC, uint32_t) -#define RCT2_Rides RCT2_ADDRESS(0x013628F8, rct2_ride) -#define RCT2_Unk140E9A8 RCT2_GLOBAL(0x0140E9A8, rct_drawpixelinfo*) -#define RCT2_PaintBoundBoxOffsetX RCT2_GLOBAL(0x009DEA52, int16_t) -#define RCT2_PaintBoundBoxOffsetY RCT2_GLOBAL(0x009DEA54, int16_t) -#define RCT2_PaintBoundBoxOffsetZ RCT2_GLOBAL(0x009DEA56, int16_t) - -enum -{ - TEST_SUCCESS, - TEST_FAILED, - TEST_SKIPPED, -}; - -namespace TestPaint -{ - static const uint32_t DEFAULT_SCHEME_TRACK = SPRITE_ID_PALETTE_COLOUR_2(COLOUR_GREY, COLOUR_WHITE); - static const uint32_t DEFAULT_SCHEME_SUPPORTS = SPRITE_ID_PALETTE_COLOUR_2(COLOUR_LIGHT_BLUE, COLOUR_ICY_BLUE); - static const uint32_t DEFAULT_SCHEME_MISC = SPRITE_ID_PALETTE_COLOUR_2(COLOUR_DARK_PURPLE, COLOUR_LIGHT_PURPLE); - static const uint32_t DEFAULT_SCHEME_3 = SPRITE_ID_PALETTE_COLOUR_2(COLOUR_BRIGHT_PURPLE, COLOUR_DARK_BLUE); - - void ResetEnvironment(); - void ResetTunnels(); - void ResetSupportHeights(); - - void testClearIgnore(); - void testIgnore(uint8_t direction, uint8_t trackSequence); - void testIgnoreAll(); - bool testIsIgnored(uint8_t direction, uint8_t trackSequence); -} // namespace TestPaint - -enum Verbosity -{ - QUIET, - NORMAL, -}; - -extern Ride gRideList[RCT12_MAX_RIDES_IN_PARK]; - -int generatePaintCode(uint8_t rideType); diff --git a/test/testpaint/TestTrack.cpp b/test/testpaint/TestTrack.cpp deleted file mode 100644 index b37ab30907..0000000000 --- a/test/testpaint/TestTrack.cpp +++ /dev/null @@ -1,819 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "TestTrack.hpp" - -#include "../../src/openrct2/ride/RideData.h" -#include "Data.h" -#include "FunctionCall.hpp" -#include "GeneralSupportHeightCall.hpp" -#include "PaintIntercept.hpp" -#include "Printer.hpp" -#include "SegmentSupportHeightCall.hpp" -#include "SideTunnelCall.hpp" -#include "String.hpp" -#include "TestPaint.hpp" -#include "Utils.hpp" -#include "VerticalTunnelCall.hpp" - -#include -#include -#include -#include -#include -#include -#include - -struct ITestTrackFilter -{ -public: - virtual ~ITestTrackFilter() - { - } - - virtual bool AppliesTo(uint8_t rideType, uint8_t trackType) abstract; - - virtual int Variations(uint8_t rideType, uint8_t trackType) abstract; - - virtual std::string VariantName(uint8_t rideType, uint8_t trackType, int variant) abstract; - - virtual void ApplyTo( - uint8_t rideType, uint8_t trackType, int variant, TileElement* tileElement, TileElement* surfaceElement, Ride* ride, - rct_ride_entry* rideEntry) abstract; -}; - -class CableLiftFilter : public ITestTrackFilter -{ -public: - bool AppliesTo(uint8_t rideType, uint8_t trackType) override - { - return rideType == RIDE_TYPE_GIGA_COASTER; - } - - int Variations(uint8_t rideType, uint8_t trackType) override - { - return 2; - } - - std::string VariantName(uint8_t rideType, uint8_t trackType, int variant) override - { - return String::Format("cableLift:%d", variant); - } - - virtual void ApplyTo( - uint8_t rideType, uint8_t trackType, int variant, TileElement* tileElement, TileElement* surfaceElement, Ride* ride, - rct_ride_entry* rideEntry) override - { - if (variant == 0) - { - tileElement->AsTrack()->SetHasCableLift(false); - } - else - { - tileElement->AsTrack()->SetHasCableLift(true); - } - } -}; - -class ChainLiftFilter : public ITestTrackFilter -{ -public: - bool AppliesTo(uint8_t rideType, uint8_t trackType) override - { - return !GetRideTypeDescriptor(rideType).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE); - } - - int Variations(uint8_t rideType, uint8_t trackType) override - { - return 2; - } - - std::string VariantName(uint8_t rideType, uint8_t trackType, int variant) override - { - return String::Format("chainLift:%d", variant); - } - - virtual void ApplyTo( - uint8_t rideType, uint8_t trackType, int variant, TileElement* tileElement, TileElement* surfaceElement, Ride* ride, - rct_ride_entry* rideEntry) override - { - tileElement->AsTrack()->SetHasChain(variant != 0); - } -}; - -class InvertedFilter : public ITestTrackFilter -{ -public: - bool AppliesTo(uint8_t rideType, uint8_t trackType) override - { - if (rideType == RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER || rideType == RIDE_TYPE_FLYING_ROLLER_COASTER - || rideType == RIDE_TYPE_LAY_DOWN_ROLLER_COASTER) - { - return true; - } - - return false; - } - - int Variations(uint8_t rideType, uint8_t trackType) override - { - return 2; - } - - std::string VariantName(uint8_t rideType, uint8_t trackType, int variant) override - { - return String::Format("inverted:%d", variant); - } - - virtual void ApplyTo( - uint8_t rideType, uint8_t trackType, int variant, TileElement* tileElement, TileElement* surfaceElement, Ride* ride, - rct_ride_entry* rideEntry) override - { - if (variant == 0) - { - tileElement->AsTrack()->SetHasCableLift(false); - } - else - { - tileElement->AsTrack()->SetHasCableLift(true); - } - } -}; - -class EntranceStyleFilter : public ITestTrackFilter -{ -public: - bool AppliesTo(uint8_t rideType, uint8_t trackType) override - { - if (track_type_is_station(trackType)) - { - return true; - } - - return false; - } - - int Variations(uint8_t rideType, uint8_t trackType) override - { - return 12; - } - - std::string VariantName(uint8_t rideType, uint8_t trackType, int variant) override - { - return String::Format("entranceStyle:%d", variant); - } - - virtual void ApplyTo( - uint8_t rideType, uint8_t trackType, int variant, TileElement* tileElement, TileElement* surfaceElement, Ride* ride, - rct_ride_entry* rideEntry) override - { - ride->entrance_style = variant; - RCT2_Rides[0].entrance_style = variant; - } -}; - -static void CallOriginal( - uint8_t rideType, uint8_t trackType, uint8_t direction, uint8_t trackSequence, uint16_t height, TileElement* tileElement) -{ - uint32_t* trackDirectionList = (uint32_t*)RideTypeTrackPaintFunctionsOld[rideType][trackType]; - const uint8_t rideIndex = 0; - - // Have to call from this point as it pushes esi and expects callee to pop it - RCT2_CALLPROC_X( - 0x006C4934, rideType, (int)trackDirectionList, direction, height, (int)tileElement, rideIndex * sizeof(Ride), - trackSequence); -} - -static void CallNew( - uint8_t rideType, uint8_t trackType, uint8_t direction, uint8_t trackSequence, uint16_t height, TileElement* tileElement) -{ - TRACK_PAINT_FUNCTION_GETTER newPaintFunctionGetter = GetRideTypeDescriptor(rideType).TrackPaintFunction; - TRACK_PAINT_FUNCTION newPaintFunction = newPaintFunctionGetter(trackType); - - newPaintFunction(&gPaintSession, 0, trackSequence, direction, height, tileElement); -} - -using TestFunction = uint8_t (*)(uint8_t, uint8_t, uint8_t, std::string*); - -static uint8_t TestTrackElementPaintCalls(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error); - -static uint8_t TestTrackElementSegmentSupportHeight( - uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error); - -static uint8_t TestTrackElementGeneralSupportHeight( - uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error); - -static uint8_t TestTrackElementSideTunnels(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error); - -static uint8_t TestTrackElementVerticalTunnels(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error); - -uint8_t TestTrack::TestPaintTrackElement(uint8_t rideType, uint8_t trackType, std::string* out) -{ - if (!Utils::rideSupportsTrackType(rideType, trackType)) - { - return TEST_FAILED; - } - - if (rideType == RIDE_TYPE_CHAIRLIFT) - { - if (track_type_is_station(trackType)) - { - // These rides check neighbouring tiles for tracks - return TEST_SKIPPED; - } - } - - int sequenceCount = Utils::getTrackSequenceCount(rideType, trackType); - std::string error = String::Format("rct2: 0x%08X\n", RideTypeTrackPaintFunctionsOld[rideType][trackType]); - - uint8_t retVal = TEST_SUCCESS; - - static TestFunction functions[] = { - TestTrackElementPaintCalls, TestTrackElementSegmentSupportHeight, TestTrackElementGeneralSupportHeight, - TestTrackElementSideTunnels, TestTrackElementVerticalTunnels, - }; - - for (int trackSequence = 0; trackSequence < sequenceCount; trackSequence++) - { - for (auto&& function : functions) - { - retVal = function(rideType, trackType, trackSequence, &error); - - if (retVal != TEST_SUCCESS) - { - *out += error + "\n"; - return retVal; - } - } - } - - return retVal; -} - -static uint8_t TestTrackElementPaintCalls(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error) -{ - uint16_t height = 3 * 16; - - TileElement tileElement = {}; - tileElement.SetType(TILE_ELEMENT_TYPE_TRACK); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = height / 16; - g_currently_drawn_item = &tileElement; - - TileElement surfaceElement = {}; - surfaceElement.SetType(TILE_ELEMENT_TYPE_SURFACE); - surfaceElement.base_height = MINIMUM_LAND_HEIGHT; - gSurfaceElement = &surfaceElement; - gDidPassSurface = true; - - gPaintSession.CurrentlyDrawnTileElement = &tileElement; - gPaintSession.SurfaceElement = &surfaceElement; - gPaintSession.DidPassSurface = true; - - TestPaint::ResetEnvironment(); - TestPaint::ResetTunnels(); - - function_call callBuffer[256] = {}; - int callCount = 0; - - // TODO: test supports - // TODO: test flat rides - // TODO: test mazes - // TODO: test underground (Wooden RC) - // TODO: test station fences - - std::vector filters; - filters.push_back(new CableLiftFilter()); - filters.push_back(new ChainLiftFilter()); - filters.push_back(new InvertedFilter()); - filters.push_back(new EntranceStyleFilter()); - - std::vector activeFilters; - - for (auto&& filter : filters) - { - if (filter->AppliesTo(rideType, trackType)) - { - activeFilters.push_back(filter); - } - } - - // Add an element so there's always something to add to - std::vector filler; - filler.push_back(0); - - std::vector> argumentPermutations; - argumentPermutations.push_back(filler); - for (size_t filterIndex = 0; filterIndex < activeFilters.size(); ++filterIndex) - { - ITestTrackFilter* filter = activeFilters[filterIndex]; - uint8_t variantCount = filter->Variations(rideType, trackType); - - std::vector> newArgumentPermutations; - for (int variant = 0; variant < variantCount; variant++) - { - for (auto&& oldPermutation : argumentPermutations) - { - std::vector permutation; - permutation.insert(permutation.begin(), oldPermutation.begin(), oldPermutation.end()); - permutation.push_back(variant); - newArgumentPermutations.push_back(permutation); - } - } - - argumentPermutations.clear(); - argumentPermutations.insert( - argumentPermutations.begin(), newArgumentPermutations.begin(), newArgumentPermutations.end()); - } - - for (auto&& arguments : argumentPermutations) - { - std::string baseCaseName = "["; - - for (size_t filterIndex = 0; filterIndex < activeFilters.size(); ++filterIndex) - { - uint8_t& variant = arguments[1 + filterIndex]; - baseCaseName += activeFilters[filterIndex]->VariantName(rideType, trackType, variant); - baseCaseName += " "; - - activeFilters[filterIndex]->ApplyTo( - rideType, trackType, variant, &tileElement, &surfaceElement, &(gRideList[0]), gRideEntries[0]); - } - - for (int currentRotation = 0; currentRotation < 4; currentRotation++) - { - gCurrentRotation = currentRotation; - RCT2_CurrentRotation = currentRotation; - gPaintSession.CurrentRotation = currentRotation; - for (int direction = 0; direction < 4; direction++) - { - RCT2_GLOBAL(0x009DE56A, int16_t) = 64; // x - RCT2_GLOBAL(0x009DE56E, int16_t) = 64; // y - - std::string caseName = String::Format( - "%srotation:%d direction:%d trackSequence:%d]", baseCaseName.c_str(), currentRotation, direction, - trackSequence); - - PaintIntercept::ClearCalls(); - TestPaint::ResetSupportHeights(); - gWoodenSupportsPrependTo = nullptr; - - CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement); - - callCount = PaintIntercept::GetCalls(callBuffer); - std::vector oldCalls; - oldCalls.insert(oldCalls.begin(), callBuffer, callBuffer + callCount); - - PaintIntercept::ClearCalls(); - TestPaint::testClearIgnore(); - TestPaint::ResetSupportHeights(); - gPaintSession.WoodenSupportsPrependTo = nullptr; - - CallNew(rideType, trackType, direction, trackSequence, height, &tileElement); - - if (TestPaint::testIsIgnored(direction, trackSequence)) - { - *error += String::Format("[ IGNORED ] %s\n", caseName.c_str()); - continue; - } - - callCount = PaintIntercept::GetCalls(callBuffer); - std::vector newCalls; - newCalls.insert(newCalls.begin(), callBuffer, callBuffer + callCount); - - bool success = true; - if (oldCalls.size() != newCalls.size()) - { - *error += String::Format( - "Call counts don't match (was %d, expected %d). %s\n", newCalls.size(), oldCalls.size(), - caseName.c_str()); - success = false; - } - else if (!FunctionCall::AssertsEquals(oldCalls, newCalls)) - { - *error += String::Format("Calls don't match. %s\n", caseName.c_str()); - success = false; - } - - if (!success) - { - *error += " Expected:\n"; - *error += Printer::PrintFunctionCalls(oldCalls, height); - *error += " Actual:\n"; - *error += Printer::PrintFunctionCalls(newCalls, height); - - return TEST_FAILED; - } - } - } - } - - return TEST_SUCCESS; -} - -static uint8_t TestTrackElementSegmentSupportHeight( - uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error) -{ - uint16_t height = 3 * 16; - - TileElement tileElement = {}; - tileElement.SetType(TILE_ELEMENT_TYPE_TRACK); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = height / 16; - g_currently_drawn_item = &tileElement; - - TileElement surfaceElement = {}; - surfaceElement.SetType(TILE_ELEMENT_TYPE_SURFACE); - surfaceElement.base_height = MINIMUM_LAND_HEIGHT; - gSurfaceElement = &surfaceElement; - gDidPassSurface = true; - - gPaintSession.CurrentlyDrawnTileElement = &tileElement; - gPaintSession.SurfaceElement = &surfaceElement; - gPaintSession.DidPassSurface = true; - - TestPaint::ResetEnvironment(); - TestPaint::ResetTunnels(); - - // TODO: Test Chainlift - // TODO: Test Maze - // TODO: Allow skip - - std::string state = String::Format("[trackSequence:%d chainLift:%d]", trackSequence, 0); - - std::vector tileSegmentSupportCalls[4]; - - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetSupportHeights(); - - CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement); - - tileSegmentSupportCalls[direction] = SegmentSupportHeightCall::getSegmentCalls(gSupportSegments, direction); - } - - std::vector referenceCalls = tileSegmentSupportCalls[0]; - - if (!SegmentSupportHeightCall::CallsMatch(tileSegmentSupportCalls)) - { - bool success = SegmentSupportHeightCall::FindMostCommonSupportCall(tileSegmentSupportCalls, &referenceCalls); - if (!success) - { - *error += String::Format("Original segment calls didn't match. %s\n", state.c_str()); - for (int direction = 0; direction < 4; direction++) - { - *error += String::Format("# %d\n", direction); - *error += Printer::PrintSegmentSupportHeightCalls(tileSegmentSupportCalls[direction]); - } - return TEST_FAILED; - } - } - - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetSupportHeights(); - - TestPaint::testClearIgnore(); - CallNew(rideType, trackType, direction, trackSequence, height, &tileElement); - if (TestPaint::testIsIgnored(direction, trackSequence)) - { - continue; - } - - std::vector newCalls = SegmentSupportHeightCall::getSegmentCalls( - gPaintSession.SupportSegments, direction); - if (!SegmentSupportHeightCall::CallsEqual(referenceCalls, newCalls)) - { - *error += String::Format("Segment support heights didn't match. [direction:%d] %s\n", direction, state.c_str()); - *error += " Expected:\n"; - *error += Printer::PrintSegmentSupportHeightCalls(referenceCalls); - *error += " Actual:\n"; - *error += Printer::PrintSegmentSupportHeightCalls(newCalls); - - return TEST_FAILED; - } - } - - return TEST_SUCCESS; -} - -static uint8_t TestTrackElementGeneralSupportHeight( - uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error) -{ - uint16_t height = 3 * 16; - - TileElement tileElement = {}; - tileElement.SetType(TILE_ELEMENT_TYPE_TRACK); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = height / 16; - g_currently_drawn_item = &tileElement; - - TileElement surfaceElement = {}; - surfaceElement.SetType(TILE_ELEMENT_TYPE_SURFACE); - surfaceElement.base_height = MINIMUM_LAND_HEIGHT; - gSurfaceElement = &surfaceElement; - gDidPassSurface = true; - - gPaintSession.CurrentlyDrawnTileElement = &tileElement; - gPaintSession.SurfaceElement = &surfaceElement; - gPaintSession.DidPassSurface = true; - - TestPaint::ResetEnvironment(); - TestPaint::ResetTunnels(); - - // TODO: Test Chainlift - // TODO: Test Maze - // TODO: Allow skip - - std::string state = String::Format("[trackSequence:%d chainLift:%d]", trackSequence, 0); - - SupportCall tileGeneralSupportCalls[4]; - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetSupportHeights(); - - CallOriginal(rideType, trackType, direction, trackSequence, height, &tileElement); - - tileGeneralSupportCalls[direction].height = -1; - tileGeneralSupportCalls[direction].slope = -1; - if (gSupport.height != 0) - { - tileGeneralSupportCalls[direction].height = gSupport.height; - } - if (gSupport.slope != 0xFF) - { - tileGeneralSupportCalls[direction].slope = gSupport.slope; - } - } - - SupportCall referenceCall = tileGeneralSupportCalls[0]; - if (!GeneralSupportHeightCall::CallsMatch(tileGeneralSupportCalls)) - { - bool success = GeneralSupportHeightCall::FindMostCommonSupportCall(tileGeneralSupportCalls, &referenceCall); - if (!success) - { - *error += String::Format("Original support calls didn't match. %s\n", state.c_str()); - for (int i = 0; i < 4; ++i) - { - *error += String::Format("[%d, 0x%02X] ", tileGeneralSupportCalls[i].height, tileGeneralSupportCalls[i].slope); - } - *error += "\n"; - return TEST_FAILED; - } - } - - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetSupportHeights(); - - TestPaint::testClearIgnore(); - CallNew(rideType, trackType, direction, trackSequence, height, &tileElement); - if (TestPaint::testIsIgnored(direction, trackSequence)) - { - continue; - } - - if (referenceCall.height != -1) - { - if (gPaintSession.Support.height != referenceCall.height) - { - *error += String::Format( - "General support heights didn't match. (expected height + %d, actual: height + %d) [direction:%d] %s\n", - referenceCall.height - height, gPaintSession.Support.height - height, direction, state.c_str()); - return TEST_FAILED; - } - } - if (referenceCall.slope != -1) - { - if (gPaintSession.Support.slope != referenceCall.slope) - { - *error += String::Format( - "General support slopes didn't match. (expected 0x%02X, actual: 0x%02X) [direction:%d] %s\n", - referenceCall.slope, gPaintSession.Support.slope, direction, state.c_str()); - return TEST_FAILED; - } - } - } - - return TEST_SUCCESS; -} - -static uint8_t TestTrackElementSideTunnels(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error) -{ - uint16_t height = 3 * 16; - - TileElement tileElement = {}; - tileElement.SetType(TILE_ELEMENT_TYPE_TRACK); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = height / 16; - g_currently_drawn_item = &tileElement; - - TileElement surfaceElement = {}; - surfaceElement.SetType(TILE_ELEMENT_TYPE_SURFACE); - surfaceElement.base_height = MINIMUM_LAND_HEIGHT; - gSurfaceElement = &surfaceElement; - gDidPassSurface = true; - - gPaintSession.CurrentlyDrawnTileElement = &tileElement; - gPaintSession.SurfaceElement = &surfaceElement; - gPaintSession.DidPassSurface = true; - - TestPaint::ResetEnvironment(); - TestPaint::ResetTunnels(); - - TunnelCall tileTunnelCalls[4][4]; - - // TODO: test inverted tracks - - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetTunnels(); - - for (int8_t offset = -8; offset <= 8; offset += 8) - { - CallOriginal(rideType, trackType, direction, trackSequence, height + offset, &tileElement); - } - - uint8_t rightIndex = (direction + 1) % 4; - uint8_t leftIndex = direction; - - for (int i = 0; i < 4; ++i) - { - tileTunnelCalls[direction][i].call = TUNNELCALL_SKIPPED; - } - - bool err = false; - tileTunnelCalls[direction][rightIndex] = SideTunnelCall::ExtractTunnelCalls( - gRightTunnels, gRightTunnelCount, height, &err); - - tileTunnelCalls[direction][leftIndex] = SideTunnelCall::ExtractTunnelCalls( - gLeftTunnels, gLeftTunnelCount, height, &err); - - if (err) - { - *error += "Multiple tunnels on one side aren't supported.\n"; - return TEST_FAILED; - } - } - - TunnelCall newTileTunnelCalls[4][4]; - for (int direction = 0; direction < 4; direction++) - { - TestPaint::ResetTunnels(); - - TestPaint::testClearIgnore(); - - for (int8_t offset = -8; offset <= 8; offset += 8) - { - // TODO: move tunnel pushing to interface so we don't have to check the output 3 times - CallNew(rideType, trackType, direction, trackSequence, height + offset, &tileElement); - } - - uint8_t rightIndex = (direction + 1) % 4; - uint8_t leftIndex = direction; - - for (int i = 0; i < 4; ++i) - { - newTileTunnelCalls[direction][i].call = TUNNELCALL_SKIPPED; - } - - bool err = false; - newTileTunnelCalls[direction][rightIndex] = SideTunnelCall::ExtractTunnelCalls( - gPaintSession.RightTunnels, gPaintSession.RightTunnelCount, height, &err); - newTileTunnelCalls[direction][leftIndex] = SideTunnelCall::ExtractTunnelCalls( - gPaintSession.LeftTunnels, gPaintSession.LeftTunnelCount, height, &err); - if (err) - { - *error += "Multiple tunnels on one side aren't supported.\n"; - return TEST_FAILED; - } - } - - if (!SideTunnelCall::TunnelCallsLineUp(tileTunnelCalls)) - { - // TODO: Check that new pattern uses the same tunnel group (round, big round, etc.) - *error += String::Format( - "Original tunnel calls don\'t line up. Skipping tunnel validation [trackSequence:%d].\n", trackSequence); - *error += Printer::PrintSideTunnelCalls(tileTunnelCalls); - - if (!SideTunnelCall::TunnelCallsLineUp(newTileTunnelCalls)) - { - *error += String::Format("Decompiled tunnel calls don\'t line up. [trackSequence:%d].\n", trackSequence); - *error += Printer::PrintSideTunnelCalls(newTileTunnelCalls); - return TEST_FAILED; - } - - return TEST_SUCCESS; - } - - TunnelCall referencePattern[4]; - SideTunnelCall::GetTunnelCallReferencePattern(tileTunnelCalls, &referencePattern); - - TunnelCall actualPattern[4]; - SideTunnelCall::GetTunnelCallReferencePattern(newTileTunnelCalls, &actualPattern); - - if (!SideTunnelCall::TunnelPatternsMatch(referencePattern, actualPattern)) - { - *error += String::Format("Tunnel calls don't match expected pattern. [trackSequence:%d]\n", trackSequence); - *error += " Expected:\n"; - *error += Printer::PrintSideTunnelCalls(tileTunnelCalls); - *error += " Actual:\n"; - *error += Printer::PrintSideTunnelCalls(newTileTunnelCalls); - return TEST_FAILED; - } - - return TEST_SUCCESS; -} - -static uint8_t TestTrackElementVerticalTunnels(uint8_t rideType, uint8_t trackType, uint8_t trackSequence, std::string* error) -{ - uint16_t height = 3 * 16; - - TileElement tileElement = {}; - tileElement.SetType(TILE_ELEMENT_TYPE_TRACK); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = height / 16; - g_currently_drawn_item = &tileElement; - - TileElement surfaceElement = {}; - surfaceElement.SetType(TILE_ELEMENT_TYPE_SURFACE); - surfaceElement.base_height = MINIMUM_LAND_HEIGHT; - gSurfaceElement = &surfaceElement; - gDidPassSurface = true; - - gPaintSession.CurrentlyDrawnTileElement = &tileElement; - gPaintSession.SurfaceElement = &surfaceElement; - gPaintSession.DidPassSurface = true; - - TestPaint::ResetEnvironment(); - TestPaint::ResetTunnels(); - - uint16_t verticalTunnelHeights[4]; - - for (int direction = 0; direction < 4; direction++) - { - uint8_t tunnelHeights[3] = { 0 }; - - for (uint8_t i = 0; i < 3; i++) - { - gVerticalTunnelHeight = 0; - CallOriginal(rideType, trackType, direction, trackSequence, height - 8 + i * 8, &tileElement); - tunnelHeights[i] = gVerticalTunnelHeight; - } - - verticalTunnelHeights[direction] = VerticalTunnelCall::GetTunnelHeight(height, tunnelHeights); - } - - if (!VerticalTunnelCall::HeightIsConsistent(verticalTunnelHeights)) - { - *error += String::Format( - "Original vertical tunnel height is inconsistent, skipping test. [trackSequence:%d]\n", trackSequence); - return TEST_SUCCESS; - } - - uint16_t referenceHeight = verticalTunnelHeights[0]; - - for (int direction = 0; direction < 4; direction++) - { - TestPaint::testClearIgnore(); - - testPaintVerticalTunnelHeight = 0; - CallNew(rideType, trackType, direction, trackSequence, height, &tileElement); - - if (TestPaint::testIsIgnored(direction, trackSequence)) - { - continue; - } - - if (testPaintVerticalTunnelHeight != referenceHeight) - { - if (referenceHeight == 0) - { - *error += String::Format( - "Expected no tunnel. Actual: %s [trackSequence:%d]\n", - Printer::PrintHeightOffset(testPaintVerticalTunnelHeight, height).c_str(), trackSequence); - return TEST_FAILED; - } - - *error += String::Format( - "Expected vertical tunnel height to be `%s`, was `%s`. [trackSequence:%d direction:%d]\n", - Printer::PrintHeightOffset(referenceHeight, height).c_str(), - Printer::PrintHeightOffset(testPaintVerticalTunnelHeight, height).c_str(), trackSequence, direction); - - return TEST_FAILED; - } - } - - return TEST_SUCCESS; -} diff --git a/test/testpaint/TestTrack.hpp b/test/testpaint/TestTrack.hpp deleted file mode 100644 index 251b32f3c8..0000000000 --- a/test/testpaint/TestTrack.hpp +++ /dev/null @@ -1,19 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include -#include - -class TestTrack -{ -public: - static uint8_t TestPaintTrackElement(uint8_t rideType, uint8_t trackType, std::string* out); -}; diff --git a/test/testpaint/TrackDataOld.cpp b/test/testpaint/TrackDataOld.cpp deleted file mode 100644 index 028970b161..0000000000 --- a/test/testpaint/TrackDataOld.cpp +++ /dev/null @@ -1,19358 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2019 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "../../src/openrct2/ride/Ride.h" - -#include - -/** rct2: 0x008A42F4 */ -// clang-format off -static constexpr const uint32_t _OldSpiralRollerCoasterTrackPaintFunctions[256] = { - 0x008A4ABC, // TrackElemType::Flat - 0x008A4D0C, // TrackElemType::EndStation - 0x008A4D1C, // TrackElemType::BeginStation - 0x008A4D2C, // TrackElemType::MiddleStation - 0x008A4ACC, // TrackElemType::Up25 - 0x008A4ADC, // TrackElemType::Up60 - 0x008A4AEC, // TrackElemType::FlatToUp25 - 0x008A4AFC, // TrackElemType::Up25ToUp60 - 0x008A4B0C, // TrackElemType::Up60ToUp25 - 0x008A4B1C, // TrackElemType::Up25ToFlat - 0x008A4B2C, // TrackElemType::Down25 - 0x008A4B3C, // TrackElemType::Down60 - 0x008A4B4C, // TrackElemType::FlatToDown25 - 0x008A4B5C, // TrackElemType::Down25ToDown60 - 0x008A4B6C, // TrackElemType::Down60ToDown25 - 0x008A4B7C, // TrackElemType::Down25ToFlat - 0x008A4B8C, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A4B9C, // TrackElemType::RightQuarterTurn5Tiles - 0x008A4BAC, // TrackElemType::FlatToLeftBank - 0x008A4BBC, // TrackElemType::FlatToRightBank - 0x008A4BCC, // TrackElemType::LeftBankToFlat - 0x008A4BDC, // TrackElemType::RightBankToFlat - 0x008A4BEC, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A4BFC, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A4C0C, // TrackElemType::LeftBankToUp25 - 0x008A4C1C, // TrackElemType::RightBankToUp25 - 0x008A4C2C, // TrackElemType::Up25ToLeftBank - 0x008A4C3C, // TrackElemType::Up25ToRightBank - 0x008A4C4C, // TrackElemType::LeftBankToDown25 - 0x008A4C5C, // TrackElemType::RightBankToDown25 - 0x008A4C6C, // TrackElemType::Down25ToLeftBank - 0x008A4C7C, // TrackElemType::Down25ToRightBank - 0x008A4C8C, // TrackElemType::LeftBank - 0x008A4C9C, // TrackElemType::RightBank - 0x008A4CAC, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A4CBC, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A4CCC, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A4CDC, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A4CEC, // TrackElemType::SBendLeft - 0x008A4CFC, // TrackElemType::SBendRight - 0, - 0, - 0x008A4D3C, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A4D4C, // TrackElemType::RightQuarterTurn3Tiles - 0x008A4D5C, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A4D6C, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A4D7C, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A4D8C, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A4D9C, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A4DAC, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A4DBC, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A4DCC, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A4DDC, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A4DEC, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A4DFC, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A4E0C, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A4E1C, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A4E2C, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008A4E5C, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A4E3C, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A4E4C, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A4E6C, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A4E7C, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A50CC, // TrackElemType::Up25LeftBanked - 0x008A50DC, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008A4E8C, // TrackElemType::OnRidePhoto - 0x008A50EC, // TrackElemType::Down25LeftBanked - 0x008A50FC, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A4EAC, // TrackElemType::LeftEighthToDiag - 0x008A4EBC, // TrackElemType::RightEighthToDiag - 0x008A4ECC, // TrackElemType::LeftEighthToOrthogonal - 0x008A4EDC, // TrackElemType::RightEighthToOrthogonal - 0x008A4EEC, // TrackElemType::LeftEighthBankToDiag - 0x008A4EFC, // TrackElemType::RightEighthBankToDiag - 0x008A4F0C, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A4F1C, // TrackElemType::RightEighthBankToOrthogonal - 0x008A4E9C, // TrackElemType::DiagFlat - 0x008A4F4C, // TrackElemType::DiagUp25 - 0x008A4FAC, // TrackElemType::DiagUp60 - 0x008A4F2C, // TrackElemType::DiagFlatToUp25 - 0x008A4F8C, // TrackElemType::DiagUp25ToUp60 - 0x008A4F9C, // TrackElemType::DiagUp60ToUp25 - 0x008A4F3C, // TrackElemType::DiagUp25ToFlat - 0x008A4F7C, // TrackElemType::DiagDown25 - 0x008A4FDC, // TrackElemType::DiagDown60 - 0x008A4F5C, // TrackElemType::DiagFlatToDown25 - 0x008A4FBC, // TrackElemType::DiagDown25ToDown60 - 0x008A4FCC, // TrackElemType::DiagDown60ToDown25 - 0x008A4F6C, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A500C, // TrackElemType::DiagFlatToLeftBank - 0x008A501C, // TrackElemType::DiagFlatToRightBank - 0x008A502C, // TrackElemType::DiagLeftBankToFlat - 0x008A503C, // TrackElemType::DiagRightBankToFlat - 0x008A506C, // TrackElemType::DiagLeftBankToUp25 - 0x008A507C, // TrackElemType::DiagRightBankToUp25 - 0x008A504C, // TrackElemType::DiagUp25ToLeftBank - 0x008A505C, // TrackElemType::DiagUp25ToRightBank - 0x008A508C, // TrackElemType::DiagLeftBankToDown25 - 0x008A509C, // TrackElemType::DiagRightBankToDown25 - 0x008A50AC, // TrackElemType::DiagDown25ToLeftBank - 0x008A50BC, // TrackElemType::DiagDown25ToRightBank - 0x008A4FEC, // TrackElemType::DiagLeftBank - 0x008A4FFC, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A531C, // TrackElemType::LeftCurvedLiftHill - 0x008A532C, // TrackElemType::RightCurvedLiftHill - 0, - 0, - 0, - 0, - 0, - 0x008A530C, // TrackElemType::BlockBrakes - 0x008A510C, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008A511C, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008A512C, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008A513C, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008A514C, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008A515C, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008A516C, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008A517C, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008A518C, // TrackElemType::Up25ToLeftBankedUp25 - 0x008A519C, // TrackElemType::Up25ToRightBankedUp25 - 0x008A51AC, // TrackElemType::LeftBankedUp25ToUp25 - 0x008A51BC, // TrackElemType::RightBankedUp25ToUp25 - 0x008A51CC, // TrackElemType::Down25ToLeftBankedDown25 - 0x008A51DC, // TrackElemType::Down25ToRightBankedDown25 - 0x008A51EC, // TrackElemType::LeftBankedDown25ToDown25 - 0x008A51FC, // TrackElemType::RightBankedDown25ToDown25 - 0x008A520C, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008A521C, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008A524C, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008A525C, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008A526C, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008A527C, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008A522C, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008A523C, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008A528C, // TrackElemType::FlatToLeftBankedUp25 - 0x008A529C, // TrackElemType::FlatToRightBankedUp25 - 0x008A52AC, // TrackElemType::LeftBankedUp25ToFlat - 0x008A52BC, // TrackElemType::RightBankedUp25ToFlat - 0x008A52CC, // TrackElemType::FlatToLeftBankedDown25 - 0x008A52DC, // TrackElemType::FlatToRightBankedDown25 - 0x008A52EC, // TrackElemType::LeftBankedDown25ToFlat - 0x008A52FC, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A6DB0 */ -static constexpr const uint32_t _OldStandUpRollerCoasterTrackPaintFunctions[256] = { - 0x008A7114, // TrackElemType::Flat - 0x008A7384, // TrackElemType::EndStation - 0x008A7394, // TrackElemType::BeginStation - 0x008A73A4, // TrackElemType::MiddleStation - 0x008A7124, // TrackElemType::Up25 - 0x008A7134, // TrackElemType::Up60 - 0x008A7144, // TrackElemType::FlatToUp25 - 0x008A7154, // TrackElemType::Up25ToUp60 - 0x008A7164, // TrackElemType::Up60ToUp25 - 0x008A7174, // TrackElemType::Up25ToFlat - 0x008A7184, // TrackElemType::Down25 - 0x008A7194, // TrackElemType::Down60 - 0x008A71A4, // TrackElemType::FlatToDown25 - 0x008A71B4, // TrackElemType::Down25ToDown60 - 0x008A71C4, // TrackElemType::Down60ToDown25 - 0x008A71D4, // TrackElemType::Down25ToFlat - 0x008A71E4, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A71F4, // TrackElemType::RightQuarterTurn5Tiles - 0x008A7204, // TrackElemType::FlatToLeftBank - 0x008A7214, // TrackElemType::FlatToRightBank - 0x008A7224, // TrackElemType::LeftBankToFlat - 0x008A7234, // TrackElemType::RightBankToFlat - 0x008A7244, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A7254, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A7264, // TrackElemType::LeftBankToUp25 - 0x008A7274, // TrackElemType::RightBankToUp25 - 0x008A7284, // TrackElemType::Up25ToLeftBank - 0x008A7294, // TrackElemType::Up25ToRightBank - 0x008A72A4, // TrackElemType::LeftBankToDown25 - 0x008A72B4, // TrackElemType::RightBankToDown25 - 0x008A72C4, // TrackElemType::Down25ToLeftBank - 0x008A72D4, // TrackElemType::Down25ToRightBank - 0x008A72E4, // TrackElemType::LeftBank - 0x008A72F4, // TrackElemType::RightBank - 0x008A7304, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A7314, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A7324, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A7334, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A7344, // TrackElemType::SBendLeft - 0x008A7354, // TrackElemType::SBendRight - 0x008A7364, // TrackElemType::LeftVerticalLoop - 0x008A7374, // TrackElemType::RightVerticalLoop - 0x008A73B4, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A73C4, // TrackElemType::RightQuarterTurn3Tiles - 0x008A73D4, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A73E4, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A73F4, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A7404, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A7414, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A7424, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7434, // TrackElemType::HalfLoopUp - 0x008A7444, // TrackElemType::HalfLoopDown - 0x008A7454, // TrackElemType::LeftCorkscrewUp - 0x008A7464, // TrackElemType::RightCorkscrewUp - 0x008A7474, // TrackElemType::LeftCorkscrewDown - 0x008A7484, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7734, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A7744, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A7754, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A7764, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A76F4, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A7704, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A7714, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A7724, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x008A7494, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A74A4, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A74B4, // TrackElemType::LeftEighthToDiag - 0x008A74C4, // TrackElemType::RightEighthToDiag - 0x008A74D4, // TrackElemType::LeftEighthToOrthogonal - 0x008A74E4, // TrackElemType::RightEighthToOrthogonal - 0x008A76A4, // TrackElemType::LeftEighthBankToDiag - 0x008A76B4, // TrackElemType::RightEighthBankToDiag - 0x008A76C4, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A76D4, // TrackElemType::RightEighthBankToOrthogonal - 0x008A74F4, // TrackElemType::DiagFlat - 0x008A7524, // TrackElemType::DiagUp25 - 0x008A7584, // TrackElemType::DiagUp60 - 0x008A7504, // TrackElemType::DiagFlatToUp25 - 0x008A7564, // TrackElemType::DiagUp25ToUp60 - 0x008A7574, // TrackElemType::DiagUp60ToUp25 - 0x008A7514, // TrackElemType::DiagUp25ToFlat - 0x008A7554, // TrackElemType::DiagDown25 - 0x008A75B4, // TrackElemType::DiagDown60 - 0x008A7534, // TrackElemType::DiagFlatToDown25 - 0x008A7594, // TrackElemType::DiagDown25ToDown60 - 0x008A75A4, // TrackElemType::DiagDown60ToDown25 - 0x008A7544, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A75E4, // TrackElemType::DiagFlatToLeftBank - 0x008A75F4, // TrackElemType::DiagFlatToRightBank - 0x008A7604, // TrackElemType::DiagLeftBankToFlat - 0x008A7614, // TrackElemType::DiagRightBankToFlat - 0x008A7644, // TrackElemType::DiagLeftBankToUp25 - 0x008A7654, // TrackElemType::DiagRightBankToUp25 - 0x008A7624, // TrackElemType::DiagUp25ToLeftBank - 0x008A7634, // TrackElemType::DiagUp25ToRightBank - 0x008A7664, // TrackElemType::DiagLeftBankToDown25 - 0x008A7674, // TrackElemType::DiagRightBankToDown25 - 0x008A7684, // TrackElemType::DiagDown25ToLeftBank - 0x008A7694, // TrackElemType::DiagDown25ToRightBank - 0x008A75C4, // TrackElemType::DiagLeftBank - 0x008A75D4, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A76E4, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A85E4 */ -static constexpr const uint32_t _OldSuspendedSwingingCoasterTrackPaintFunctions[256] = { - 0x008A8958, // TrackElemType::Flat - 0x008A8AA8, // TrackElemType::EndStation - 0x008A8AB8, // TrackElemType::BeginStation - 0x008A8AC8, // TrackElemType::MiddleStation - 0x008A8968, // TrackElemType::Up25 - 0x008A8978, // TrackElemType::Up60 - 0x008A8988, // TrackElemType::FlatToUp25 - 0x008A8998, // TrackElemType::Up25ToUp60 - 0x008A89A8, // TrackElemType::Up60ToUp25 - 0x008A89B8, // TrackElemType::Up25ToFlat - 0x008A89C8, // TrackElemType::Down25 - 0x008A89D8, // TrackElemType::Down60 - 0x008A89E8, // TrackElemType::FlatToDown25 - 0x008A89F8, // TrackElemType::Down25ToDown60 - 0x008A8A08, // TrackElemType::Down60ToDown25 - 0x008A8A18, // TrackElemType::Down25ToFlat - 0x008A8A28, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A8A38, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8A48, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A8A58, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A8A68, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A8A78, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A8A88, // TrackElemType::SBendLeft - 0x008A8A98, // TrackElemType::SBendRight - 0, - 0, - 0x008A8AD8, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A8AE8, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0x008A8AF8, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A8B08, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A8B18, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A8B28, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8B38, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8B48, // TrackElemType::LeftQuarterHelixLargeUp - 0x008A8B58, // TrackElemType::RightQuarterHelixLargeUp - 0x008A8B68, // TrackElemType::LeftQuarterHelixLargeDown - 0x008A8B78, // TrackElemType::RightQuarterHelixLargeDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8B88, // TrackElemType::LeftEighthToDiag - 0x008A8B98, // TrackElemType::RightEighthToDiag - 0x008A8BA8, // TrackElemType::LeftEighthToOrthogonal - 0x008A8BB8, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008A8BC8, // TrackElemType::DiagFlat - 0x008A8BF8, // TrackElemType::DiagUp25 - 0x008A8C58, // TrackElemType::DiagUp60 - 0x008A8BD8, // TrackElemType::DiagFlatToUp25 - 0x008A8C38, // TrackElemType::DiagUp25ToUp60 - 0x008A8C48, // TrackElemType::DiagUp60ToUp25 - 0x008A8BE8, // TrackElemType::DiagUp25ToFlat - 0x008A8C28, // TrackElemType::DiagDown25 - 0x008A8C88, // TrackElemType::DiagDown60 - 0x008A8C08, // TrackElemType::DiagFlatToDown25 - 0x008A8C68, // TrackElemType::DiagDown25ToDown60 - 0x008A8C78, // TrackElemType::DiagDown60ToDown25 - 0x008A8C18, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8B38, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A8EE4 */ -static constexpr const uint32_t _OldInvertedRollerCoasterTrackPaintFunctions[256] = { - 0x008A92E8, // TrackElemType::Flat - 0x008A9558, // TrackElemType::EndStation - 0x008A9568, // TrackElemType::BeginStation - 0x008A9578, // TrackElemType::MiddleStation - 0x008A92F8, // TrackElemType::Up25 - 0x008A9308, // TrackElemType::Up60 - 0x008A9318, // TrackElemType::FlatToUp25 - 0x008A9328, // TrackElemType::Up25ToUp60 - 0x008A9338, // TrackElemType::Up60ToUp25 - 0x008A9348, // TrackElemType::Up25ToFlat - 0x008A9358, // TrackElemType::Down25 - 0x008A9368, // TrackElemType::Down60 - 0x008A9378, // TrackElemType::FlatToDown25 - 0x008A9388, // TrackElemType::Down25ToDown60 - 0x008A9398, // TrackElemType::Down60ToDown25 - 0x008A93A8, // TrackElemType::Down25ToFlat - 0x008A93B8, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A93C8, // TrackElemType::RightQuarterTurn5Tiles - 0x008A93D8, // TrackElemType::FlatToLeftBank - 0x008A93E8, // TrackElemType::FlatToRightBank - 0x008A93F8, // TrackElemType::LeftBankToFlat - 0x008A9408, // TrackElemType::RightBankToFlat - 0x008A9418, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A9428, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A9438, // TrackElemType::LeftBankToUp25 - 0x008A9448, // TrackElemType::RightBankToUp25 - 0x008A9458, // TrackElemType::Up25ToLeftBank - 0x008A9468, // TrackElemType::Up25ToRightBank - 0x008A9478, // TrackElemType::LeftBankToDown25 - 0x008A9488, // TrackElemType::RightBankToDown25 - 0x008A9498, // TrackElemType::Down25ToLeftBank - 0x008A94A8, // TrackElemType::Down25ToRightBank - 0x008A94B8, // TrackElemType::LeftBank - 0x008A94C8, // TrackElemType::RightBank - 0x008A94D8, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A94E8, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A94F8, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A9508, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A9518, // TrackElemType::SBendLeft - 0x008A9528, // TrackElemType::SBendRight - 0x008A9538, // TrackElemType::LeftVerticalLoop - 0x008A9548, // TrackElemType::RightVerticalLoop - 0x008A9588, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A9598, // TrackElemType::RightQuarterTurn3Tiles - 0x008A95A8, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A95B8, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A95C8, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A95D8, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A95E8, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A95F8, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0x008A9608, // TrackElemType::LeftTwistDownToUp - 0x008A9618, // TrackElemType::RightTwistDownToUp - 0x008A9628, // TrackElemType::LeftTwistUpToDown - 0x008A9638, // TrackElemType::RightTwistUpToDown - 0x008A9648, // TrackElemType::HalfLoopUp - 0x008A9658, // TrackElemType::HalfLoopDown - 0x008A9668, // TrackElemType::LeftCorkscrewUp - 0x008A9678, // TrackElemType::RightCorkscrewUp - 0x008A9688, // TrackElemType::LeftCorkscrewDown - 0x008A9698, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A96D8, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A96B8, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A96C8, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A96E8, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A96A8, // TrackElemType::Brakes - 0, - 0, - 0x008A96F8, // TrackElemType::LeftQuarterBankedHelixLargeUp - 0x008A9708, // TrackElemType::RightQuarterBankedHelixLargeUp - 0x008A9718, // TrackElemType::LeftQuarterBankedHelixLargeDown - 0x008A9728, // TrackElemType::RightQuarterBankedHelixLargeDown - 0, - 0, - 0, - 0, - 0x008A9A38, // TrackElemType::Up25LeftBanked - 0x008A9A48, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008A9738, // TrackElemType::OnRidePhoto - 0x008A9A58, // TrackElemType::Down25LeftBanked - 0x008A9A68, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A9748, // TrackElemType::LeftEighthToDiag - 0x008A9758, // TrackElemType::RightEighthToDiag - 0x008A9768, // TrackElemType::LeftEighthToOrthogonal - 0x008A9778, // TrackElemType::RightEighthToOrthogonal - 0x008A9938, // TrackElemType::LeftEighthBankToDiag - 0x008A9948, // TrackElemType::RightEighthBankToDiag - 0x008A9958, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A9968, // TrackElemType::RightEighthBankToOrthogonal - 0x008A9788, // TrackElemType::DiagFlat - 0x008A97B8, // TrackElemType::DiagUp25 - 0x008A9818, // TrackElemType::DiagUp60 - 0x008A9798, // TrackElemType::DiagFlatToUp25 - 0x008A97F8, // TrackElemType::DiagUp25ToUp60 - 0x008A9808, // TrackElemType::DiagUp60ToUp25 - 0x008A97A8, // TrackElemType::DiagUp25ToFlat - 0x008A97E8, // TrackElemType::DiagDown25 - 0x008A9848, // TrackElemType::DiagDown60 - 0x008A97C8, // TrackElemType::DiagFlatToDown25 - 0x008A9828, // TrackElemType::DiagDown25ToDown60 - 0x008A9838, // TrackElemType::DiagDown60ToDown25 - 0x008A97D8, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A9878, // TrackElemType::DiagFlatToLeftBank - 0x008A9888, // TrackElemType::DiagFlatToRightBank - 0x008A9898, // TrackElemType::DiagLeftBankToFlat - 0x008A98A8, // TrackElemType::DiagRightBankToFlat - 0x008A98D8, // TrackElemType::DiagLeftBankToUp25 - 0x008A98E8, // TrackElemType::DiagRightBankToUp25 - 0x008A98B8, // TrackElemType::DiagUp25ToLeftBank - 0x008A98C8, // TrackElemType::DiagUp25ToRightBank - 0x008A98F8, // TrackElemType::DiagLeftBankToDown25 - 0x008A9908, // TrackElemType::DiagRightBankToDown25 - 0x008A9918, // TrackElemType::DiagDown25ToLeftBank - 0x008A9928, // TrackElemType::DiagDown25ToRightBank - 0x008A9858, // TrackElemType::DiagLeftBank - 0x008A9868, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A9978, // TrackElemType::LeftLargeHalfLoopUp - 0x008A9988, // TrackElemType::RightLargeHalfLoopUp - 0x008A9998, // TrackElemType::RightLargeHalfLoopDown - 0x008A99A8, // TrackElemType::LeftLargeHalfLoopDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A96A8, // TrackElemType::BlockBrakes - 0x008A9A78, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008A9A88, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008A9A98, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008A9AA8, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008A9BB8, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008A9BC8, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008A9BD8, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008A9BE8, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008A9AB8, // TrackElemType::Up25ToLeftBankedUp25 - 0x008A9AC8, // TrackElemType::Up25ToRightBankedUp25 - 0x008A9AD8, // TrackElemType::LeftBankedUp25ToUp25 - 0x008A9AE8, // TrackElemType::RightBankedUp25ToUp25 - 0x008A9AF8, // TrackElemType::Down25ToLeftBankedDown25 - 0x008A9B08, // TrackElemType::Down25ToRightBankedDown25 - 0x008A9B18, // TrackElemType::LeftBankedDown25ToDown25 - 0x008A9B28, // TrackElemType::RightBankedDown25ToDown25 - 0x008A9B38, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008A9B48, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008A9B58, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008A9B68, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008A9B78, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008A9B88, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008A9B98, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008A9BA8, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008A99B8, // TrackElemType::FlatToLeftBankedUp25 - 0x008A99C8, // TrackElemType::FlatToRightBankedUp25 - 0x008A99D8, // TrackElemType::LeftBankedUp25ToFlat - 0x008A99E8, // TrackElemType::RightBankedUp25ToFlat - 0x008A99F8, // TrackElemType::FlatToLeftBankedDown25 - 0x008A9A08, // TrackElemType::FlatToRightBankedDown25 - 0x008A9A18, // TrackElemType::LeftBankedDown25ToFlat - 0x008A9A28, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AAA0C */ -static constexpr const uint32_t _OldJuniorRollerCoasterTrackPaintFunctions[256] = { - 0x008AAD80, // TrackElemType::Flat - 0x008AAE70, // TrackElemType::EndStation - 0x008AAE80, // TrackElemType::BeginStation - 0x008AAE90, // TrackElemType::MiddleStation - 0x008AAD90, // TrackElemType::Up25 - 0, - 0x008AADA0, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008AADB0, // TrackElemType::Up25ToFlat - 0x008AADC0, // TrackElemType::Down25 - 0, - 0x008AADD0, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008AADE0, // TrackElemType::Down25ToFlat - 0x008AADF0, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AAE00, // TrackElemType::RightQuarterTurn5Tiles - 0x008AAFC0, // TrackElemType::FlatToLeftBank - 0x008AAFD0, // TrackElemType::FlatToRightBank - 0x008AAFE0, // TrackElemType::LeftBankToFlat - 0x008AAFF0, // TrackElemType::RightBankToFlat - 0x008AB000, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AB010, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AB020, // TrackElemType::LeftBankToUp25 - 0x008AB030, // TrackElemType::RightBankToUp25 - 0x008AB040, // TrackElemType::Up25ToLeftBank - 0x008AB050, // TrackElemType::Up25ToRightBank - 0x008AB060, // TrackElemType::LeftBankToDown25 - 0x008AB070, // TrackElemType::RightBankToDown25 - 0x008AB080, // TrackElemType::Down25ToLeftBank - 0x008AB090, // TrackElemType::Down25ToRightBank - 0x008AB0A0, // TrackElemType::LeftBank - 0x008AB0B0, // TrackElemType::RightBank - 0x008AAE10, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AAE20, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AAE30, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AAE40, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AAE50, // TrackElemType::SBendLeft - 0x008AAE60, // TrackElemType::SBendRight - 0, - 0, - 0x008AAEA0, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AAEB0, // TrackElemType::RightQuarterTurn3Tiles - 0x008AB0C0, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AB0D0, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AAEC0, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AAED0, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AAEE0, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AAEF0, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AB0E0, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008AB0F0, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008AB100, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008AB110, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008AB120, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008AB130, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008AB140, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008AB150, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x008AAF00, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AAF80, // TrackElemType::LeftEighthToDiag - 0x008AAF90, // TrackElemType::RightEighthToDiag - 0x008AAFA0, // TrackElemType::LeftEighthToOrthogonal - 0x008AAFB0, // TrackElemType::RightEighthToOrthogonal - 0x008AB160, // TrackElemType::LeftEighthBankToDiag - 0x008AB170, // TrackElemType::RightEighthBankToDiag - 0x008AB180, // TrackElemType::LeftEighthBankToOrthogonal - 0x008AB190, // TrackElemType::RightEighthBankToOrthogonal - 0x008AAF10, // TrackElemType::DiagFlat - 0x008AAF40, // TrackElemType::DiagUp25 - 0, - 0x008AAF20, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008AAF30, // TrackElemType::DiagUp25ToFlat - 0x008AAF70, // TrackElemType::DiagDown25 - 0, - 0x008AAF50, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008AAF60, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008AB1C0, // TrackElemType::DiagFlatToLeftBank - 0x008AB1D0, // TrackElemType::DiagFlatToRightBank - 0x008AB1E0, // TrackElemType::DiagLeftBankToFlat - 0x008AB1F0, // TrackElemType::DiagRightBankToFlat - 0x008AB220, // TrackElemType::DiagLeftBankToUp25 - 0x008AB230, // TrackElemType::DiagRightBankToUp25 - 0x008AB200, // TrackElemType::DiagUp25ToLeftBank - 0x008AB210, // TrackElemType::DiagUp25ToRightBank - 0x008AB240, // TrackElemType::DiagLeftBankToDown25 - 0x008AB250, // TrackElemType::DiagRightBankToDown25 - 0x008AB260, // TrackElemType::DiagDown25ToLeftBank - 0x008AB270, // TrackElemType::DiagDown25ToRightBank - 0x008AB1A0, // TrackElemType::DiagLeftBank - 0x008AB1B0, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AB280, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008ACE48 */ -static constexpr const uint32_t _OldMiniatureRailwayTrackPaintFunctions[256] = { - 0x008AD0C0, // TrackElemType::Flat - 0x008AD170, // TrackElemType::EndStation - 0x008AD180, // TrackElemType::BeginStation - 0x008AD190, // TrackElemType::MiddleStation - 0x008AD0D0, // TrackElemType::Up25 - 0, - 0x008AD0E0, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008AD0F0, // TrackElemType::Up25ToFlat - 0x008AD100, // TrackElemType::Down25 - 0, - 0x008AD110, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008AD120, // TrackElemType::Down25ToFlat - 0x008AD130, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AD140, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AD150, // TrackElemType::SBendLeft - 0x008AD160, // TrackElemType::SBendRight - 0, - 0, - 0x008AD1A0, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AD1B0, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AD1C0, // TrackElemType::LeftEighthToDiag - 0x008AD1D0, // TrackElemType::RightEighthToDiag - 0x008AD1E0, // TrackElemType::LeftEighthToOrthogonal - 0x008AD1F0, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008AD200, // TrackElemType::DiagFlat - 0x008AD230, // TrackElemType::DiagUp25 - 0, - 0x008AD210, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008AD220, // TrackElemType::DiagUp25ToFlat - 0x008AD260, // TrackElemType::DiagDown25 - 0, - 0x008AD240, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008AD250, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008ADF34 */ -static constexpr const uint32_t _OldMonorailTrackPaintFunctions[256] = { - 0x008AE1AC, // TrackElemType::Flat - 0x008AE25C, // TrackElemType::EndStation - 0x008AE26C, // TrackElemType::BeginStation - 0x008AE27C, // TrackElemType::MiddleStation - 0x008AE1BC, // TrackElemType::Up25 - 0, - 0x008AE1CC, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008AE1DC, // TrackElemType::Up25ToFlat - 0x008AE1EC, // TrackElemType::Down25 - 0, - 0x008AE1FC, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008AE20C, // TrackElemType::Down25ToFlat - 0x008AE21C, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AE22C, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AE23C, // TrackElemType::SBendLeft - 0x008AE24C, // TrackElemType::SBendRight - 0, - 0, - 0x008AE28C, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AE29C, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AE31C, // TrackElemType::LeftEighthToDiag - 0x008AE32C, // TrackElemType::RightEighthToDiag - 0x008AE33C, // TrackElemType::LeftEighthToOrthogonal - 0x008AE34C, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008AE2AC, // TrackElemType::DiagFlat - 0x008AE2DC, // TrackElemType::DiagUp25 - 0, - 0x008AE2BC, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008AE2CC, // TrackElemType::DiagUp25ToFlat - 0x008AE30C, // TrackElemType::DiagDown25 - 0, - 0x008AE2EC, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008AE2FC, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AFC24 */ -static constexpr const uint32_t _OldMiniSuspendedCoasterTrackPaintFunctions[256] = { - 0x008AFE9C, // TrackElemType::Flat - 0x008AFF4C, // TrackElemType::EndStation - 0x008AFF5C, // TrackElemType::BeginStation - 0x008AFF6C, // TrackElemType::MiddleStation - 0x008AFEAC, // TrackElemType::Up25 - 0, - 0x008AFEBC, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008AFECC, // TrackElemType::Up25ToFlat - 0x008AFEDC, // TrackElemType::Down25 - 0, - 0x008AFEEC, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008AFEFC, // TrackElemType::Down25ToFlat - 0x008AFF0C, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AFF1C, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFF2C, // TrackElemType::SBendLeft - 0x008AFF3C, // TrackElemType::SBendRight - 0, - 0, - 0x008AFF7C, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AFF8C, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFFAC, // TrackElemType::LeftEighthToDiag - 0x008AFFBC, // TrackElemType::RightEighthToDiag - 0x008AFFCC, // TrackElemType::LeftEighthToOrthogonal - 0x008AFFDC, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008AFF9C, // TrackElemType::DiagFlat - 0x008B000C, // TrackElemType::DiagUp25 - 0, - 0x008AFFEC, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008AFFFC, // TrackElemType::DiagUp25ToFlat - 0x008B003C, // TrackElemType::DiagDown25 - 0, - 0x008B001C, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008B002C, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008B0D60 */ -static constexpr const uint32_t _OldBoatHireTrackPaintFunctions[256] = { - 0x008B0E40, // TrackElemType::Flat - 0x008B0E50, // TrackElemType::EndStation - 0x008B0E60, // TrackElemType::BeginStation - 0x008B0E70, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B0E80, // TrackElemType::LeftQuarterTurn1Tile - 0x008B0E90, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A534C */ -static constexpr const uint32_t _OldWoodenWildMouseTrackPaintFunctions[256] = { - 0x008A5464, // TrackElemType::Flat - 0x008A5534, // TrackElemType::EndStation - 0x008A5544, // TrackElemType::BeginStation - 0x008A5554, // TrackElemType::MiddleStation - 0x008A5474, // TrackElemType::Up25 - 0x008A5484, // TrackElemType::Up60 - 0x008A5494, // TrackElemType::FlatToUp25 - 0x008A54A4, // TrackElemType::Up25ToUp60 - 0x008A54B4, // TrackElemType::Up60ToUp25 - 0x008A54C4, // TrackElemType::Up25ToFlat - 0x008A54D4, // TrackElemType::Down25 - 0x008A54E4, // TrackElemType::Down60 - 0x008A54F4, // TrackElemType::FlatToDown25 - 0x008A5504, // TrackElemType::Down25ToDown60 - 0x008A5514, // TrackElemType::Down60ToDown25 - 0x008A5524, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A5564, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A5574, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0x008A5584, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A5594, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A55A4, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A55B4, // TrackElemType::RightQuarterTurn3TilesDown25 - 0x008A55C4, // TrackElemType::LeftQuarterTurn1Tile - 0x008A55D4, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A55E4, // TrackElemType::FlatToUp60 - 0x008A55F4, // TrackElemType::Up60ToFlat - 0x008A5604, // TrackElemType::FlatToDown60 - 0x008A5614, // TrackElemType::Down60ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A5634 */ -static constexpr const uint32_t _OldSteeplechaseTrackPaintFunctions[256] = { - 0x008A59A8, // TrackElemType::Flat - 0x008A5A58, // TrackElemType::EndStation - 0x008A5A68, // TrackElemType::BeginStation - 0x008A5A78, // TrackElemType::MiddleStation - 0x008A59B8, // TrackElemType::Up25 - 0, - 0x008A59C8, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008A59D8, // TrackElemType::Up25ToFlat - 0x008A59E8, // TrackElemType::Down25 - 0, - 0x008A59F8, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008A5A08, // TrackElemType::Down25ToFlat - 0x008A5A18, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A5A28, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A5A38, // TrackElemType::SBendLeft - 0x008A5A48, // TrackElemType::SBendRight - 0, - 0, - 0x008A5A88, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A5A98, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A5AA8, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A5AD8, // TrackElemType::LeftEighthToDiag - 0x008A5AE8, // TrackElemType::RightEighthToDiag - 0x008A5AF8, // TrackElemType::LeftEighthToOrthogonal - 0x008A5B08, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008A5AC8, // TrackElemType::DiagFlat - 0x008A5B38, // TrackElemType::DiagUp25 - 0, - 0x008A5B18, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008A5B28, // TrackElemType::DiagUp25ToFlat - 0x008A5B68, // TrackElemType::DiagDown25 - 0, - 0x008A5B48, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008A5B58, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A5AB8, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x006F7000 */ -static constexpr const uint32_t _OldCarRideTrackPaintFunctions[256] = { - 0x006F72C8, // TrackElemType::Flat - 0x006F7338, // TrackElemType::EndStation - 0x006F7348, // TrackElemType::BeginStation - 0x006F7358, // TrackElemType::MiddleStation - 0x006F72D8, // TrackElemType::Up25 - 0x006F73B8, // TrackElemType::Up60 - 0x006F72E8, // TrackElemType::FlatToUp25 - 0x006F73C8, // TrackElemType::Up25ToUp60 - 0x006F73D8, // TrackElemType::Up60ToUp25 - 0x006F72F8, // TrackElemType::Up25ToFlat - 0x006F7308, // TrackElemType::Down25 - 0x006F73E8, // TrackElemType::Down60 - 0x006F7318, // TrackElemType::FlatToDown25 - 0x006F73F8, // TrackElemType::Down25ToDown60 - 0x006F7408, // TrackElemType::Down60ToDown25 - 0x006F7328, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006F7368, // TrackElemType::LeftQuarterTurn3Tiles - 0x006F7378, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0x006F7388, // TrackElemType::LeftQuarterTurn1Tile - 0x006F7398, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006F7418, // TrackElemType::Rapids - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006F73A8, // TrackElemType::SpinningTunnel - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x006FD0E8 */ -static constexpr const uint32_t _OldLaunchedFreefallTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006FD1F8, // TrackElemType::TowerBase - 0x006FD208, // TrackElemType::TowerSection - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x006FE240 */ -static constexpr const uint32_t _OldBobsleighCoasterTrackPaintFunctions[256] = { - 0x006FE5B4, // TrackElemType::Flat - 0x006FE764, // TrackElemType::EndStation - 0x006FE774, // TrackElemType::BeginStation - 0x006FE784, // TrackElemType::MiddleStation - 0x006FE5C4, // TrackElemType::Up25 - 0, - 0x006FE5D4, // TrackElemType::FlatToUp25 - 0, - 0, - 0x006FE5E4, // TrackElemType::Up25ToFlat - 0x006FE5F4, // TrackElemType::Down25 - 0, - 0x006FE604, // TrackElemType::FlatToDown25 - 0, - 0, - 0x006FE614, // TrackElemType::Down25ToFlat - 0x006FE624, // TrackElemType::LeftQuarterTurn5Tiles - 0x006FE634, // TrackElemType::RightQuarterTurn5Tiles - 0x006FE644, // TrackElemType::FlatToLeftBank - 0x006FE654, // TrackElemType::FlatToRightBank - 0x006FE664, // TrackElemType::LeftBankToFlat - 0x006FE674, // TrackElemType::RightBankToFlat - 0x006FE684, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x006FE694, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x006FE6A4, // TrackElemType::LeftBankToUp25 - 0x006FE6B4, // TrackElemType::RightBankToUp25 - 0x006FE6C4, // TrackElemType::Up25ToLeftBank - 0x006FE6D4, // TrackElemType::Up25ToRightBank - 0x006FE6E4, // TrackElemType::LeftBankToDown25 - 0x006FE6F4, // TrackElemType::RightBankToDown25 - 0x006FE704, // TrackElemType::Down25ToLeftBank - 0x006FE714, // TrackElemType::Down25ToRightBank - 0x006FE724, // TrackElemType::LeftBank - 0x006FE734, // TrackElemType::RightBank - 0, - 0, - 0, - 0, - 0x006FE744, // TrackElemType::SBendLeft - 0x006FE754, // TrackElemType::SBendRight - 0, - 0, - 0x006FE794, // TrackElemType::LeftQuarterTurn3Tiles - 0x006FE7A4, // TrackElemType::RightQuarterTurn3Tiles - 0x006FE7B4, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x006FE7C4, // TrackElemType::RightBankedQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006FE7D4, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x006FE7E4, // TrackElemType::RightHalfBankedHelixUpSmall - 0x006FE7F4, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x006FE804, // TrackElemType::RightHalfBankedHelixDownSmall - 0x006FE814, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x006FE824, // TrackElemType::RightHalfBankedHelixUpLarge - 0x006FE834, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x006FE844, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x006FE854, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x006FE864, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0070DC5C */ -static constexpr const uint32_t _OldObservationTowerTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0070DD6C, // TrackElemType::TowerBase - 0x0070DD7C, // TrackElemType::TowerSection - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A5B88 */ -static constexpr const uint32_t _OldLoopingRollerCoasterTrackPaintFunctions[256] = { - 0x008A6370, // TrackElemType::Flat - 0x008A6600, // TrackElemType::EndStation - 0x008A6610, // TrackElemType::BeginStation - 0x008A6620, // TrackElemType::MiddleStation - 0x008A6380, // TrackElemType::Up25 - 0x008A6390, // TrackElemType::Up60 - 0x008A63A0, // TrackElemType::FlatToUp25 - 0x008A63B0, // TrackElemType::Up25ToUp60 - 0x008A63C0, // TrackElemType::Up60ToUp25 - 0x008A63D0, // TrackElemType::Up25ToFlat - 0x008A63E0, // TrackElemType::Down25 - 0x008A63F0, // TrackElemType::Down60 - 0x008A6400, // TrackElemType::FlatToDown25 - 0x008A6410, // TrackElemType::Down25ToDown60 - 0x008A6420, // TrackElemType::Down60ToDown25 - 0x008A6430, // TrackElemType::Down25ToFlat - 0x008A6440, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A6450, // TrackElemType::RightQuarterTurn5Tiles - 0x008A6460, // TrackElemType::FlatToLeftBank - 0x008A6470, // TrackElemType::FlatToRightBank - 0x008A6480, // TrackElemType::LeftBankToFlat - 0x008A6490, // TrackElemType::RightBankToFlat - 0x008A64A0, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A64B0, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A64C0, // TrackElemType::LeftBankToUp25 - 0x008A64D0, // TrackElemType::RightBankToUp25 - 0x008A64E0, // TrackElemType::Up25ToLeftBank - 0x008A64F0, // TrackElemType::Up25ToRightBank - 0x008A6500, // TrackElemType::LeftBankToDown25 - 0x008A6510, // TrackElemType::RightBankToDown25 - 0x008A6520, // TrackElemType::Down25ToLeftBank - 0x008A6530, // TrackElemType::Down25ToRightBank - 0x008A6540, // TrackElemType::LeftBank - 0x008A6550, // TrackElemType::RightBank - 0x008A6560, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A6570, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A6580, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A6590, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A65A0, // TrackElemType::SBendLeft - 0x008A65B0, // TrackElemType::SBendRight - 0x008A65C0, // TrackElemType::LeftVerticalLoop - 0x008A65D0, // TrackElemType::RightVerticalLoop - 0x008A6630, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A6640, // TrackElemType::RightQuarterTurn3Tiles - 0x008A6650, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A6660, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A6670, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A6680, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A6690, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A66A0, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A66B0, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A66C0, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A66D0, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A66E0, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A66F0, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A6700, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A6710, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A6720, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008A6750, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A6730, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A6740, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A6760, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A6770, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6A40, // TrackElemType::Up25LeftBanked - 0x008A6A50, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008A6780, // TrackElemType::OnRidePhoto - 0x008A6A60, // TrackElemType::Down25LeftBanked - 0x008A6A70, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6860, // TrackElemType::LeftEighthToDiag - 0x008A6870, // TrackElemType::RightEighthToDiag - 0x008A6880, // TrackElemType::LeftEighthToOrthogonal - 0x008A6890, // TrackElemType::RightEighthToOrthogonal - 0x008A68A0, // TrackElemType::LeftEighthBankToDiag - 0x008A68B0, // TrackElemType::RightEighthBankToDiag - 0x008A68C0, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A68D0, // TrackElemType::RightEighthBankToOrthogonal - 0x008A6790, // TrackElemType::DiagFlat - 0x008A67C0, // TrackElemType::DiagUp25 - 0x008A67F0, // TrackElemType::DiagUp60 - 0x008A67A0, // TrackElemType::DiagFlatToUp25 - 0x008A67D0, // TrackElemType::DiagUp25ToUp60 - 0x008A67E0, // TrackElemType::DiagUp60ToUp25 - 0x008A67B0, // TrackElemType::DiagUp25ToFlat - 0x008A6820, // TrackElemType::DiagDown25 - 0x008A6850, // TrackElemType::DiagDown60 - 0x008A6800, // TrackElemType::DiagFlatToDown25 - 0x008A6830, // TrackElemType::DiagDown25ToDown60 - 0x008A6840, // TrackElemType::DiagDown60ToDown25 - 0x008A6810, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A6900, // TrackElemType::DiagFlatToLeftBank - 0x008A6910, // TrackElemType::DiagFlatToRightBank - 0x008A6920, // TrackElemType::DiagLeftBankToFlat - 0x008A6930, // TrackElemType::DiagRightBankToFlat - 0x008A6960, // TrackElemType::DiagLeftBankToUp25 - 0x008A6970, // TrackElemType::DiagRightBankToUp25 - 0x008A6940, // TrackElemType::DiagUp25ToLeftBank - 0x008A6950, // TrackElemType::DiagUp25ToRightBank - 0x008A6980, // TrackElemType::DiagLeftBankToDown25 - 0x008A6990, // TrackElemType::DiagRightBankToDown25 - 0x008A69A0, // TrackElemType::DiagDown25ToLeftBank - 0x008A69B0, // TrackElemType::DiagDown25ToRightBank - 0x008A68E0, // TrackElemType::DiagLeftBank - 0x008A68F0, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6C00, // TrackElemType::BlockBrakes - 0x008A6BC0, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008A6BD0, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008A6BE0, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008A6BF0, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008A6B80, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008A6B90, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008A6BA0, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008A6BB0, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008A6A80, // TrackElemType::Up25ToLeftBankedUp25 - 0x008A6A90, // TrackElemType::Up25ToRightBankedUp25 - 0x008A6AA0, // TrackElemType::LeftBankedUp25ToUp25 - 0x008A6AB0, // TrackElemType::RightBankedUp25ToUp25 - 0x008A6AC0, // TrackElemType::Down25ToLeftBankedDown25 - 0x008A6AD0, // TrackElemType::Down25ToRightBankedDown25 - 0x008A6AE0, // TrackElemType::LeftBankedDown25ToDown25 - 0x008A6AF0, // TrackElemType::RightBankedDown25ToDown25 - 0x008A6B00, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008A6B10, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008A6B40, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008A6B50, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008A6B60, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008A6B70, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008A6B20, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008A6B30, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008A69C0, // TrackElemType::FlatToLeftBankedUp25 - 0x008A69D0, // TrackElemType::FlatToRightBankedUp25 - 0x008A69E0, // TrackElemType::LeftBankedUp25ToFlat - 0x008A69F0, // TrackElemType::RightBankedUp25ToFlat - 0x008A6A00, // TrackElemType::FlatToLeftBankedDown25 - 0x008A6A10, // TrackElemType::FlatToRightBankedDown25 - 0x008A6A20, // TrackElemType::LeftBankedDown25ToFlat - 0x008A6A30, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0070EDB4 */ -static constexpr const uint32_t _OldDinghySlideTrackPaintFunctions[256] = { - 0x0070EF20, // TrackElemType::Flat - 0x0070F030, // TrackElemType::EndStation - 0x0070F040, // TrackElemType::BeginStation - 0x0070F050, // TrackElemType::MiddleStation - 0x0070EF30, // TrackElemType::Up25 - 0x0070EFD0, // TrackElemType::Up60 - 0x0070EF40, // TrackElemType::FlatToUp25 - 0x0070EF90, // TrackElemType::Up25ToUp60 - 0x0070EFA0, // TrackElemType::Up60ToUp25 - 0x0070EF50, // TrackElemType::Up25ToFlat - 0x0070EF60, // TrackElemType::Down25 - 0x0070EFE0, // TrackElemType::Down60 - 0x0070EF70, // TrackElemType::FlatToDown25 - 0x0070EFB0, // TrackElemType::Down25ToDown60 - 0x0070EFC0, // TrackElemType::Down60ToDown25 - 0x0070EF80, // TrackElemType::Down25ToFlat - 0x0070EFF0, // TrackElemType::LeftQuarterTurn5Tiles - 0x0070F000, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0070F010, // TrackElemType::SBendLeft - 0x0070F020, // TrackElemType::SBendRight - 0, - 0, - 0x0070F060, // TrackElemType::LeftQuarterTurn3Tiles - 0x0070F070, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0070F080, // TrackElemType::FlatCovered - 0x0070F090, // TrackElemType::Up25Covered - 0x0070F130, // TrackElemType::Up60Covered - 0x0070F0A0, // TrackElemType::FlatToUp25Covered - 0x0070F0F0, // TrackElemType::Up25ToUp60Covered - 0x0070F100, // TrackElemType::Up60ToUp25Covered - 0x0070F0B0, // TrackElemType::Up25ToFlatCovered - 0x0070F0C0, // TrackElemType::Down25Covered - 0x0070F140, // TrackElemType::Down60Covered - 0x0070F0D0, // TrackElemType::FlatToDown25Covered - 0x0070F110, // TrackElemType::Down25ToDown60Covered - 0x0070F120, // TrackElemType::Down60ToDown25Covered - 0x0070F0E0, // TrackElemType::Down25ToFlatCovered - 0x0070F150, // TrackElemType::LeftQuarterTurn5TilesCovered - 0x0070F160, // TrackElemType::RightQuarterTurn5TilesCovered - 0x0070F190, // TrackElemType::SBendLeftCovered - 0x0070F1A0, // TrackElemType::SBendRightCovered - 0x0070F170, // TrackElemType::LeftQuarterTurn3TilesCovered - 0x0070F180, // TrackElemType::RightQuarterTurn3TilesCovered - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0071BC40 */ -static constexpr const uint32_t _OldMineTrainCoasterTrackPaintFunctions[256] = { - 0x0071BFA4, // TrackElemType::Flat - 0x0071C154, // TrackElemType::EndStation - 0x0071C164, // TrackElemType::BeginStation - 0x0071C174, // TrackElemType::MiddleStation - 0x0071BFB4, // TrackElemType::Up25 - 0x0071BFC4, // TrackElemType::Up60 - 0x0071BFD4, // TrackElemType::FlatToUp25 - 0x0071BFE4, // TrackElemType::Up25ToUp60 - 0x0071BFF4, // TrackElemType::Up60ToUp25 - 0x0071C004, // TrackElemType::Up25ToFlat - 0x0071C014, // TrackElemType::Down25 - 0x0071C024, // TrackElemType::Down60 - 0x0071C034, // TrackElemType::FlatToDown25 - 0x0071C044, // TrackElemType::Down25ToDown60 - 0x0071C054, // TrackElemType::Down60ToDown25 - 0x0071C064, // TrackElemType::Down25ToFlat - 0x0071C0B4, // TrackElemType::LeftQuarterTurn5Tiles - 0x0071C0C4, // TrackElemType::RightQuarterTurn5Tiles - 0x0071C074, // TrackElemType::FlatToLeftBank - 0x0071C084, // TrackElemType::FlatToRightBank - 0x0071C094, // TrackElemType::LeftBankToFlat - 0x0071C0A4, // TrackElemType::RightBankToFlat - 0x0071C0D4, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x0071C0E4, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x0071C204, // TrackElemType::LeftBankToUp25 - 0x0071C214, // TrackElemType::RightBankToUp25 - 0x0071C224, // TrackElemType::Up25ToLeftBank - 0x0071C234, // TrackElemType::Up25ToRightBank - 0x0071C244, // TrackElemType::LeftBankToDown25 - 0x0071C254, // TrackElemType::RightBankToDown25 - 0x0071C264, // TrackElemType::Down25ToLeftBank - 0x0071C274, // TrackElemType::Down25ToRightBank - 0x0071C304, // TrackElemType::LeftBank - 0x0071C314, // TrackElemType::RightBank - 0x0071C0F4, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x0071C104, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x0071C114, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x0071C124, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x0071C134, // TrackElemType::SBendLeft - 0x0071C144, // TrackElemType::SBendRight - 0, - 0, - 0x0071C184, // TrackElemType::LeftQuarterTurn3Tiles - 0x0071C194, // TrackElemType::RightQuarterTurn3Tiles - 0x0071C1A4, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x0071C1B4, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x0071C1C4, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x0071C1D4, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x0071C1E4, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x0071C1F4, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0071C284, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x0071C294, // TrackElemType::RightHalfBankedHelixUpSmall - 0x0071C2A4, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x0071C2B4, // TrackElemType::RightHalfBankedHelixDownSmall - 0x0071C2C4, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x0071C2D4, // TrackElemType::RightHalfBankedHelixUpLarge - 0x0071C2E4, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x0071C2F4, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x0071C324, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0071C334, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0071C354, // TrackElemType::LeftEighthToDiag - 0x0071C364, // TrackElemType::RightEighthToDiag - 0x0071C374, // TrackElemType::LeftEighthToOrthogonal - 0x0071C384, // TrackElemType::RightEighthToOrthogonal - 0x0071C394, // TrackElemType::LeftEighthBankToDiag - 0x0071C3A4, // TrackElemType::RightEighthBankToDiag - 0x0071C3B4, // TrackElemType::LeftEighthBankToOrthogonal - 0x0071C3C4, // TrackElemType::RightEighthBankToOrthogonal - 0x0071C344, // TrackElemType::DiagFlat - 0x0071C414, // TrackElemType::DiagUp25 - 0x0071C474, // TrackElemType::DiagUp60 - 0x0071C3F4, // TrackElemType::DiagFlatToUp25 - 0x0071C454, // TrackElemType::DiagUp25ToUp60 - 0x0071C464, // TrackElemType::DiagUp60ToUp25 - 0x0071C404, // TrackElemType::DiagUp25ToFlat - 0x0071C444, // TrackElemType::DiagDown25 - 0x0071C4A4, // TrackElemType::DiagDown60 - 0x0071C424, // TrackElemType::DiagFlatToDown25 - 0x0071C484, // TrackElemType::DiagDown25ToDown60 - 0x0071C494, // TrackElemType::DiagDown60ToDown25 - 0x0071C434, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x0071C4D4, // TrackElemType::DiagFlatToLeftBank - 0x0071C4B4, // TrackElemType::DiagFlatToRightBank - 0x0071C4C4, // TrackElemType::DiagLeftBankToFlat - 0x0071C4E4, // TrackElemType::DiagRightBankToFlat - 0x0071C514, // TrackElemType::DiagLeftBankToUp25 - 0x0071C524, // TrackElemType::DiagRightBankToUp25 - 0x0071C4F4, // TrackElemType::DiagUp25ToLeftBank - 0x0071C504, // TrackElemType::DiagUp25ToRightBank - 0x0071C534, // TrackElemType::DiagLeftBankToDown25 - 0x0071C544, // TrackElemType::DiagRightBankToDown25 - 0x0071C554, // TrackElemType::DiagDown25ToLeftBank - 0x0071C564, // TrackElemType::DiagDown25ToRightBank - 0x0071C3D4, // TrackElemType::DiagLeftBank - 0x0071C3E4, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0071C574, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00743EC8 */ -static constexpr const uint32_t _OldChairliftTrackPaintFunctions[256] = { - 0x00743FC8, // TrackElemType::Flat - 0x00743F98, // TrackElemType::EndStation - 0x00743FA8, // TrackElemType::BeginStation - 0x00743FB8, // TrackElemType::MiddleStation - 0x00743FD8, // TrackElemType::Up25 - 0, - 0x00743FE8, // TrackElemType::FlatToUp25 - 0, - 0, - 0x00743FF8, // TrackElemType::Up25ToFlat - 0x00744008, // TrackElemType::Down25 - 0, - 0x00744018, // TrackElemType::FlatToDown25 - 0, - 0, - 0x00744028, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00744038, // TrackElemType::LeftQuarterTurn1Tile - 0x00744048, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A7784 */ -static constexpr const uint32_t _OldCorkscrewRollerCoasterTrackPaintFunctions[256] = { - 0x008A7AF8, // TrackElemType::Flat - 0x008A7D68, // TrackElemType::EndStation - 0x008A7D78, // TrackElemType::BeginStation - 0x008A7D88, // TrackElemType::MiddleStation - 0x008A7B08, // TrackElemType::Up25 - 0x008A7B18, // TrackElemType::Up60 - 0x008A7B28, // TrackElemType::FlatToUp25 - 0x008A7B38, // TrackElemType::Up25ToUp60 - 0x008A7B48, // TrackElemType::Up60ToUp25 - 0x008A7B58, // TrackElemType::Up25ToFlat - 0x008A7B68, // TrackElemType::Down25 - 0x008A7B78, // TrackElemType::Down60 - 0x008A7B88, // TrackElemType::FlatToDown25 - 0x008A7B98, // TrackElemType::Down25ToDown60 - 0x008A7BA8, // TrackElemType::Down60ToDown25 - 0x008A7BB8, // TrackElemType::Down25ToFlat - 0x008A7BC8, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A7BD8, // TrackElemType::RightQuarterTurn5Tiles - 0x008A7BE8, // TrackElemType::FlatToLeftBank - 0x008A7BF8, // TrackElemType::FlatToRightBank - 0x008A7C08, // TrackElemType::LeftBankToFlat - 0x008A7C18, // TrackElemType::RightBankToFlat - 0x008A7C28, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A7C38, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A7C48, // TrackElemType::LeftBankToUp25 - 0x008A7C58, // TrackElemType::RightBankToUp25 - 0x008A7C68, // TrackElemType::Up25ToLeftBank - 0x008A7C78, // TrackElemType::Up25ToRightBank - 0x008A7C88, // TrackElemType::LeftBankToDown25 - 0x008A7C98, // TrackElemType::RightBankToDown25 - 0x008A7CA8, // TrackElemType::Down25ToLeftBank - 0x008A7CB8, // TrackElemType::Down25ToRightBank - 0x008A7CC8, // TrackElemType::LeftBank - 0x008A7CD8, // TrackElemType::RightBank - 0x008A7CE8, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A7CF8, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A7D08, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A7D18, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A7D28, // TrackElemType::SBendLeft - 0x008A7D38, // TrackElemType::SBendRight - 0x008A7D48, // TrackElemType::LeftVerticalLoop - 0x008A7D58, // TrackElemType::RightVerticalLoop - 0x008A7D98, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A7DA8, // TrackElemType::RightQuarterTurn3Tiles - 0x008A7DB8, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A7DC8, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A7DD8, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A7DE8, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A7DF8, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A7E08, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7E18, // TrackElemType::HalfLoopUp - 0x008A7E28, // TrackElemType::HalfLoopDown - 0x008A7E38, // TrackElemType::LeftCorkscrewUp - 0x008A7E48, // TrackElemType::RightCorkscrewUp - 0x008A7E58, // TrackElemType::LeftCorkscrewDown - 0x008A7E68, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7E78, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A7E88, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A7E98, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A7EA8, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A7EB8, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A7EC8, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A7ED8, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A7EE8, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008A7F18, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A7EF8, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A7F08, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A7F28, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A7F38, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7F48, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0x008A8198, // TrackElemType::FlatToUp60LongBase - 0x008A81A8, // TrackElemType::Up60ToFlatLongBase - 0, - 0x008A81B8, // TrackElemType::Down60ToFlatLongBase - 0x008A81C8, // TrackElemType::FlatToDown60LongBase - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A7F68, // TrackElemType::LeftEighthToDiag - 0x008A7F78, // TrackElemType::RightEighthToDiag - 0x008A7F88, // TrackElemType::LeftEighthToOrthogonal - 0x008A7F98, // TrackElemType::RightEighthToOrthogonal - 0x008A7FA8, // TrackElemType::LeftEighthBankToDiag - 0x008A7FB8, // TrackElemType::RightEighthBankToDiag - 0x008A7FC8, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A7FD8, // TrackElemType::RightEighthBankToOrthogonal - 0x008A7F58, // TrackElemType::DiagFlat - 0x008A8008, // TrackElemType::DiagUp25 - 0x008A8068, // TrackElemType::DiagUp60 - 0x008A7FE8, // TrackElemType::DiagFlatToUp25 - 0x008A8048, // TrackElemType::DiagUp25ToUp60 - 0x008A8058, // TrackElemType::DiagUp60ToUp25 - 0x008A7FF8, // TrackElemType::DiagUp25ToFlat - 0x008A8038, // TrackElemType::DiagDown25 - 0x008A8098, // TrackElemType::DiagDown60 - 0x008A8018, // TrackElemType::DiagFlatToDown25 - 0x008A8078, // TrackElemType::DiagDown25ToDown60 - 0x008A8088, // TrackElemType::DiagDown60ToDown25 - 0x008A8028, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A80C8, // TrackElemType::DiagFlatToLeftBank - 0x008A80D8, // TrackElemType::DiagFlatToRightBank - 0x008A80E8, // TrackElemType::DiagLeftBankToFlat - 0x008A80F8, // TrackElemType::DiagRightBankToFlat - 0x008A8128, // TrackElemType::DiagLeftBankToUp25 - 0x008A8138, // TrackElemType::DiagRightBankToUp25 - 0x008A8108, // TrackElemType::DiagUp25ToLeftBank - 0x008A8118, // TrackElemType::DiagUp25ToRightBank - 0x008A8148, // TrackElemType::DiagLeftBankToDown25 - 0x008A8158, // TrackElemType::DiagRightBankToDown25 - 0x008A8168, // TrackElemType::DiagDown25ToLeftBank - 0x008A8178, // TrackElemType::DiagDown25ToRightBank - 0x008A80A8, // TrackElemType::DiagLeftBank - 0x008A80B8, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8188, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A81E8 */ -static constexpr const uint32_t _OldMazeTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8380, // TrackElemType::InvertedUp90ToFlatQuarterLoopAlias - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0074840C */ -static constexpr const uint32_t _OldSpiralSlideTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007485C8, // 110 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0074A668 */ -static constexpr const uint32_t _OldGoKartsTrackPaintFunctions[256] = { - 0x0074A748, // TrackElemType::Flat - 0x0074A7B8, // TrackElemType::EndStation - 0x0074A7C8, // TrackElemType::BeginStation - 0x0074A7D8, // TrackElemType::MiddleStation - 0x0074A758, // TrackElemType::Up25 - 0, - 0x0074A768, // TrackElemType::FlatToUp25 - 0, - 0, - 0x0074A778, // TrackElemType::Up25ToFlat - 0x0074A788, // TrackElemType::Down25 - 0, - 0x0074A798, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0074A7A8, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0074A7E8, // TrackElemType::LeftQuarterTurn1Tile - 0x0074A7F8, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0074DDEC */ -static constexpr const uint32_t _OldLogFlumeTrackPaintFunctions[256] = { - 0x0074E0B0, // TrackElemType::Flat - 0x0074E140, // TrackElemType::EndStation - 0x0074E150, // TrackElemType::BeginStation - 0x0074E160, // TrackElemType::MiddleStation - 0x0074E0C0, // TrackElemType::Up25 - 0, - 0x0074E0D0, // TrackElemType::FlatToUp25 - 0, - 0, - 0x0074E0E0, // TrackElemType::Up25ToFlat - 0x0074E0F0, // TrackElemType::Down25 - 0, - 0x0074E100, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0074E110, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0074E120, // TrackElemType::SBendLeft - 0x0074E130, // TrackElemType::SBendRight - 0, - 0, - 0x0074E170, // TrackElemType::LeftQuarterTurn3Tiles - 0x0074E180, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0074E1A0, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0074E190, // TrackElemType::LogFlumeReverser - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0075745C */ -static constexpr const uint32_t _OldRiverRapidsTrackPaintFunctions[256] = { - 0x00757650, // TrackElemType::Flat - 0x007576C0, // TrackElemType::EndStation - 0x007576D0, // TrackElemType::BeginStation - 0x007576E0, // TrackElemType::MiddleStation - 0x00757660, // TrackElemType::Up25 - 0, - 0x00757670, // TrackElemType::FlatToUp25 - 0, - 0, - 0x00757680, // TrackElemType::Up25ToFlat - 0x00757690, // TrackElemType::Down25 - 0, - 0x007576A0, // TrackElemType::FlatToDown25 - 0, - 0, - 0x007576B0, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007576F0, // TrackElemType::LeftQuarterTurn1Tile - 0x00757700, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00757710, // TrackElemType::Waterfall - 0x00757720, // TrackElemType::Rapids - 0x00757740, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0x00757730, // TrackElemType::Whirlpool - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0075C9D0 */ -static constexpr const uint32_t _OldDodgemsTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0075CBA0, // 111 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A83E0 */ -static constexpr const uint32_t _OldSwingingShipTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A85C4, // 116 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00760070 */ -static constexpr const uint32_t _OldSwingingInverterShipTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00760260, // 119 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** - * FoodStall, 1D, DrinkStall, 1F, Shop, 22, InformationKiosk, CashMachine, 50, 52, 53, 54 - * - * rct2: 0x00761160 - */ -static constexpr const uint32_t _OldShopTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00761358, // 118 - 0, - 0, - 0x00761358, // 121 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076190C */ -static constexpr const uint32_t _OldMerryGoRoundTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00761B0C, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** - * Toilets, FirstAid - * - * rct2: 0x00762D44 - */ -static constexpr const uint32_t _OldFacilityTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00762F30, // 118 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A8CC8 */ -static constexpr const uint32_t _OldFerrisWheelTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A8EC4, // 122 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00763520 */ -static constexpr const uint32_t _OldMotionSimulatorTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007636EC, // 110 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076554C */ -static constexpr const uint32_t _Old3DCinemaTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076574C, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076659C */ -static constexpr const uint32_t _OldTopSpinTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076679C, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00767A40 */ -static constexpr const uint32_t _OldSpaceRingsTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00767C40, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00768BAC */ -static constexpr const uint32_t _OldReverseFreefallCoasterTrackPaintFunctions[256] = { - 0x00768DB4, // TrackElemType::Flat - 0x00768DC4, // TrackElemType::EndStation - 0x00768DD4, // TrackElemType::BeginStation - 0x00768DE4, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00768DF4, // TrackElemType::ReverseFreefallSlope - 0x00768E04, // TrackElemType::ReverseFreefallVertical - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076C5BC */ -static constexpr const uint32_t _OldLiftTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076C6CC, // TrackElemType::TowerBase - 0x0076C6DC, // TrackElemType::TowerSection - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A9C08 */ -static constexpr const uint32_t _OldVerticalDropRollerCoasterTrackPaintFunctions[256] = { - 0x008AA00C, // TrackElemType::Flat - 0x008AA25C, // TrackElemType::EndStation - 0x008AA26C, // TrackElemType::BeginStation - 0x008AA27C, // TrackElemType::MiddleStation - 0x008AA01C, // TrackElemType::Up25 - 0x008AA02C, // TrackElemType::Up60 - 0x008AA03C, // TrackElemType::FlatToUp25 - 0x008AA04C, // TrackElemType::Up25ToUp60 - 0x008AA05C, // TrackElemType::Up60ToUp25 - 0x008AA06C, // TrackElemType::Up25ToFlat - 0x008AA07C, // TrackElemType::Down25 - 0x008AA08C, // TrackElemType::Down60 - 0x008AA09C, // TrackElemType::FlatToDown25 - 0x008AA0AC, // TrackElemType::Down25ToDown60 - 0x008AA0BC, // TrackElemType::Down60ToDown25 - 0x008AA0CC, // TrackElemType::Down25ToFlat - 0x008AA0DC, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AA0EC, // TrackElemType::RightQuarterTurn5Tiles - 0x008AA0FC, // TrackElemType::FlatToLeftBank - 0x008AA10C, // TrackElemType::FlatToRightBank - 0x008AA11C, // TrackElemType::LeftBankToFlat - 0x008AA12C, // TrackElemType::RightBankToFlat - 0x008AA13C, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AA14C, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AA15C, // TrackElemType::LeftBankToUp25 - 0x008AA16C, // TrackElemType::RightBankToUp25 - 0x008AA17C, // TrackElemType::Up25ToLeftBank - 0x008AA18C, // TrackElemType::Up25ToRightBank - 0x008AA19C, // TrackElemType::LeftBankToDown25 - 0x008AA1AC, // TrackElemType::RightBankToDown25 - 0x008AA1BC, // TrackElemType::Down25ToLeftBank - 0x008AA1CC, // TrackElemType::Down25ToRightBank - 0x008AA1DC, // TrackElemType::LeftBank - 0x008AA1EC, // TrackElemType::RightBank - 0x008AA1FC, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AA20C, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AA21C, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AA22C, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AA23C, // TrackElemType::SBendLeft - 0x008AA24C, // TrackElemType::SBendRight - 0x008AA49C, // TrackElemType::LeftVerticalLoop - 0x008AA4AC, // TrackElemType::RightVerticalLoop - 0x008AA28C, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AA29C, // TrackElemType::RightQuarterTurn3Tiles - 0x008AA2AC, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AA2BC, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AA2CC, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AA2DC, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AA2EC, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AA2FC, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA3CC, // TrackElemType::FlatToUp60 - 0x008AA3DC, // TrackElemType::Up60ToFlat - 0x008AA3EC, // TrackElemType::FlatToDown60 - 0x008AA3FC, // TrackElemType::Down60ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA30C, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008AA31C, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008AA32C, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008AA33C, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008AA34C, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008AA35C, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008AA36C, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008AA37C, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008AA3AC, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008AA38C, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008AA39C, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008AA3BC, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008AA40C, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA7EC, // TrackElemType::Up25LeftBanked - 0x008AA7FC, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008AA41C, // TrackElemType::OnRidePhoto - 0x008AA80C, // TrackElemType::Down25LeftBanked - 0x008AA81C, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA42C, // TrackElemType::Up90 - 0x008AA43C, // TrackElemType::Down90 - 0x008AA44C, // TrackElemType::Up60ToUp90 - 0x008AA45C, // TrackElemType::Down90ToDown60 - 0x008AA46C, // TrackElemType::Up90ToUp60 - 0x008AA47C, // TrackElemType::Down60ToDown90 - 0x008AA48C, // TrackElemType::BrakeForDrop - 0x008AA4CC, // TrackElemType::LeftEighthToDiag - 0x008AA4DC, // TrackElemType::RightEighthToDiag - 0x008AA4EC, // TrackElemType::LeftEighthToOrthogonal - 0x008AA4FC, // TrackElemType::RightEighthToOrthogonal - 0x008AA50C, // TrackElemType::LeftEighthBankToDiag - 0x008AA51C, // TrackElemType::RightEighthBankToDiag - 0x008AA52C, // TrackElemType::LeftEighthBankToOrthogonal - 0x008AA53C, // TrackElemType::RightEighthBankToOrthogonal - 0x008AA4BC, // TrackElemType::DiagFlat - 0x008AA56C, // TrackElemType::DiagUp25 - 0x008AA5CC, // TrackElemType::DiagUp60 - 0x008AA54C, // TrackElemType::DiagFlatToUp25 - 0x008AA5AC, // TrackElemType::DiagUp25ToUp60 - 0x008AA5BC, // TrackElemType::DiagUp60ToUp25 - 0x008AA55C, // TrackElemType::DiagUp25ToFlat - 0x008AA59C, // TrackElemType::DiagDown25 - 0x008AA5FC, // TrackElemType::DiagDown60 - 0x008AA57C, // TrackElemType::DiagFlatToDown25 - 0x008AA5DC, // TrackElemType::DiagDown25ToDown60 - 0x008AA5EC, // TrackElemType::DiagDown60ToDown25 - 0x008AA58C, // TrackElemType::DiagDown25ToFlat - 0x008AA6EC, // TrackElemType::DiagFlatToUp60 - 0x008AA6FC, // TrackElemType::DiagUp60ToFlat - 0x008AA70C, // TrackElemType::DiagFlatToDown60 - 0x008AA71C, // TrackElemType::DiagDown60ToFlat - 0x008AA62C, // TrackElemType::DiagFlatToLeftBank - 0x008AA63C, // TrackElemType::DiagFlatToRightBank - 0x008AA64C, // TrackElemType::DiagLeftBankToFlat - 0x008AA65C, // TrackElemType::DiagRightBankToFlat - 0x008AA68C, // TrackElemType::DiagLeftBankToUp25 - 0x008AA69C, // TrackElemType::DiagRightBankToUp25 - 0x008AA66C, // TrackElemType::DiagUp25ToLeftBank - 0x008AA67C, // TrackElemType::DiagUp25ToRightBank - 0x008AA6AC, // TrackElemType::DiagLeftBankToDown25 - 0x008AA6BC, // TrackElemType::DiagRightBankToDown25 - 0x008AA6CC, // TrackElemType::DiagDown25ToLeftBank - 0x008AA6DC, // TrackElemType::DiagDown25ToRightBank - 0x008AA60C, // TrackElemType::DiagLeftBank - 0x008AA61C, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA72C, // TrackElemType::LeftBankToLeftQuarterTurn3TilesUp25 - 0x008AA73C, // TrackElemType::RightBankToRightQuarterTurn3TilesUp25 - 0x008AA74C, // TrackElemType::LeftQuarterTurn3TilesDown25ToLeftBank - 0x008AA75C, // TrackElemType::RightQuarterTurn3TilesDown25ToRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AA9EC, // TrackElemType::BlockBrakes - 0x008AA96C, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008AA97C, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008AA98C, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008AA99C, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008AA8AC, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008AA8BC, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008AA8CC, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008AA8DC, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008AA82C, // TrackElemType::Up25ToLeftBankedUp25 - 0x008AA83C, // TrackElemType::Up25ToRightBankedUp25 - 0x008AA84C, // TrackElemType::LeftBankedUp25ToUp25 - 0x008AA85C, // TrackElemType::RightBankedUp25ToUp25 - 0x008AA86C, // TrackElemType::Down25ToLeftBankedDown25 - 0x008AA87C, // TrackElemType::Down25ToRightBankedDown25 - 0x008AA88C, // TrackElemType::LeftBankedDown25ToDown25 - 0x008AA89C, // TrackElemType::RightBankedDown25ToDown25 - 0x008AA8EC, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008AA8FC, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008AA92C, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008AA93C, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008AA94C, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008AA95C, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008AA90C, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008AA91C, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008AA76C, // TrackElemType::FlatToLeftBankedUp25 - 0x008AA77C, // TrackElemType::FlatToRightBankedUp25 - 0x008AA78C, // TrackElemType::LeftBankedUp25ToFlat - 0x008AA79C, // TrackElemType::RightBankedUp25ToFlat - 0x008AA7AC, // TrackElemType::FlatToLeftBankedDown25 - 0x008AA7BC, // TrackElemType::FlatToRightBankedDown25 - 0x008AA7CC, // TrackElemType::LeftBankedDown25ToFlat - 0x008AA7DC, // TrackElemType::RightBankedDown25ToFlat - 0x008AA9AC, // TrackElemType::LeftQuarterTurn1TileUp90 - 0x008AA9BC, // TrackElemType::RightQuarterTurn1TileUp90 - 0x008AA9CC, // TrackElemType::LeftQuarterTurn1TileDown90 - 0x008AA9DC, // TrackElemType::RightQuarterTurn1TileDown90 - 0, - 0, - 0, -}; - -/** rct2: 0x0076D658 */ -static constexpr const uint32_t _OldTwistTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076D858, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076E7B0 */ -static constexpr const uint32_t _OldHauntedHouseTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076E9B0, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0076F8D4 */ -static constexpr const uint32_t _OldCircusTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0076FAD4, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00770924 */ -static constexpr const uint32_t _OldGhostTrainTrackPaintFunctions[256] = { - 0x00770BEC, // TrackElemType::Flat - 0x00770C5C, // TrackElemType::EndStation - 0x00770C6C, // TrackElemType::BeginStation - 0x00770C7C, // TrackElemType::MiddleStation - 0x00770BFC, // TrackElemType::Up25 - 0, - 0x00770C0C, // TrackElemType::FlatToUp25 - 0, - 0, - 0x00770C1C, // TrackElemType::Up25ToFlat - 0x00770C2C, // TrackElemType::Down25 - 0, - 0x00770C3C, // TrackElemType::FlatToDown25 - 0, - 0, - 0x00770C4C, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00770C8C, // TrackElemType::LeftQuarterTurn3Tiles - 0x00770C9C, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0x00770CAC, // TrackElemType::LeftQuarterTurn1Tile - 0x00770CBC, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00770CDC, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00770CCC, // TrackElemType::SpinningTunnel - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AB2A0 */ -static constexpr const uint32_t _OldTwisterRollerCoasterTrackPaintFunctions[256] = { - 0x008AB6A4, // TrackElemType::Flat - 0x008AB8F4, // TrackElemType::EndStation - 0x008AB904, // TrackElemType::BeginStation - 0x008AB914, // TrackElemType::MiddleStation - 0x008AB6B4, // TrackElemType::Up25 - 0x008AB6C4, // TrackElemType::Up60 - 0x008AB6D4, // TrackElemType::FlatToUp25 - 0x008AB6E4, // TrackElemType::Up25ToUp60 - 0x008AB6F4, // TrackElemType::Up60ToUp25 - 0x008AB704, // TrackElemType::Up25ToFlat - 0x008AB714, // TrackElemType::Down25 - 0x008AB724, // TrackElemType::Down60 - 0x008AB734, // TrackElemType::FlatToDown25 - 0x008AB744, // TrackElemType::Down25ToDown60 - 0x008AB754, // TrackElemType::Down60ToDown25 - 0x008AB764, // TrackElemType::Down25ToFlat - 0x008AB774, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AB784, // TrackElemType::RightQuarterTurn5Tiles - 0x008AB794, // TrackElemType::FlatToLeftBank - 0x008AB7A4, // TrackElemType::FlatToRightBank - 0x008AB7B4, // TrackElemType::LeftBankToFlat - 0x008AB7C4, // TrackElemType::RightBankToFlat - 0x008AB7D4, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AB7E4, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AB7F4, // TrackElemType::LeftBankToUp25 - 0x008AB804, // TrackElemType::RightBankToUp25 - 0x008AB814, // TrackElemType::Up25ToLeftBank - 0x008AB824, // TrackElemType::Up25ToRightBank - 0x008AB834, // TrackElemType::LeftBankToDown25 - 0x008AB844, // TrackElemType::RightBankToDown25 - 0x008AB854, // TrackElemType::Down25ToLeftBank - 0x008AB864, // TrackElemType::Down25ToRightBank - 0x008AB874, // TrackElemType::LeftBank - 0x008AB884, // TrackElemType::RightBank - 0x008AB894, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AB8A4, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AB8B4, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AB8C4, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AB8D4, // TrackElemType::SBendLeft - 0x008AB8E4, // TrackElemType::SBendRight - 0x008ABA84, // TrackElemType::LeftVerticalLoop - 0x008ABA94, // TrackElemType::RightVerticalLoop - 0x008AB924, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AB934, // TrackElemType::RightQuarterTurn3Tiles - 0x008AB944, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AB954, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AB964, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AB974, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AB984, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AB994, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ABCD4, // TrackElemType::HalfLoopUp - 0x008ABCE4, // TrackElemType::HalfLoopDown - 0x008ABD34, // TrackElemType::LeftCorkscrewUp - 0x008ABD44, // TrackElemType::RightCorkscrewUp - 0x008ABD54, // TrackElemType::LeftCorkscrewDown - 0x008ABD64, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AB9A4, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008AB9B4, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008AB9C4, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008AB9D4, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008AB9E4, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008AB9F4, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008ABA04, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008ABA14, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008ABA44, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008ABA24, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008ABA34, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008ABA54, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008ABA64, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ABE04, // TrackElemType::Up25LeftBanked - 0x008ABE14, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008ABA74, // TrackElemType::OnRidePhoto - 0x008ABE24, // TrackElemType::Down25LeftBanked - 0x008ABE34, // TrackElemType::Down25RightBanked - 0, - 0x008AC0F4, // TrackElemType::FlatToUp60LongBase - 0x008AC104, // TrackElemType::Up60ToFlatLongBase - 0, - 0x008AC114, // TrackElemType::Down60ToFlatLongBase - 0x008AC124, // TrackElemType::FlatToDown60LongBase - 0, - 0, - 0, - 0x008ABE44, // TrackElemType::Up90 - 0x008ABE54, // TrackElemType::Down90 - 0x008ABE64, // TrackElemType::Up60ToUp90 - 0x008ABE74, // TrackElemType::Down90ToDown60 - 0x008ABE84, // TrackElemType::Up90ToUp60 - 0x008ABE94, // TrackElemType::Down60ToDown90 - 0, - 0x008ABAB4, // TrackElemType::LeftEighthToDiag - 0x008ABAC4, // TrackElemType::RightEighthToDiag - 0x008ABAD4, // TrackElemType::LeftEighthToOrthogonal - 0x008ABAE4, // TrackElemType::RightEighthToOrthogonal - 0x008ABAF4, // TrackElemType::LeftEighthBankToDiag - 0x008ABB04, // TrackElemType::RightEighthBankToDiag - 0x008ABB14, // TrackElemType::LeftEighthBankToOrthogonal - 0x008ABB24, // TrackElemType::RightEighthBankToOrthogonal - 0x008ABAA4, // TrackElemType::DiagFlat - 0x008ABB54, // TrackElemType::DiagUp25 - 0x008ABBB4, // TrackElemType::DiagUp60 - 0x008ABB34, // TrackElemType::DiagFlatToUp25 - 0x008ABB94, // TrackElemType::DiagUp25ToUp60 - 0x008ABBA4, // TrackElemType::DiagUp60ToUp25 - 0x008ABB44, // TrackElemType::DiagUp25ToFlat - 0x008ABB84, // TrackElemType::DiagDown25 - 0x008ABBE4, // TrackElemType::DiagDown60 - 0x008ABB64, // TrackElemType::DiagFlatToDown25 - 0x008ABBC4, // TrackElemType::DiagDown25ToDown60 - 0x008ABBD4, // TrackElemType::DiagDown60ToDown25 - 0x008ABB74, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008ABC14, // TrackElemType::DiagFlatToLeftBank - 0x008ABC24, // TrackElemType::DiagFlatToRightBank - 0x008ABC34, // TrackElemType::DiagLeftBankToFlat - 0x008ABC44, // TrackElemType::DiagRightBankToFlat - 0x008ABC74, // TrackElemType::DiagLeftBankToUp25 - 0x008ABC84, // TrackElemType::DiagRightBankToUp25 - 0x008ABC54, // TrackElemType::DiagUp25ToLeftBank - 0x008ABC64, // TrackElemType::DiagUp25ToRightBank - 0x008ABC94, // TrackElemType::DiagLeftBankToDown25 - 0x008ABCA4, // TrackElemType::DiagRightBankToDown25 - 0x008ABCB4, // TrackElemType::DiagDown25ToLeftBank - 0x008ABCC4, // TrackElemType::DiagDown25ToRightBank - 0x008ABBF4, // TrackElemType::DiagLeftBank - 0x008ABC04, // TrackElemType::DiagRightBank - 0, - 0, - 0x008ABCF4, // TrackElemType::LeftBarrelRollUpToDown - 0x008ABD04, // TrackElemType::RightBarrelRollUpToDown - 0x008ABD14, // TrackElemType::LeftBarrelRollDownToUp - 0x008ABD24, // TrackElemType::RightBarrelRollDownToUp - 0x008ABD74, // TrackElemType::LeftBankToLeftQuarterTurn3TilesUp25 - 0x008ABD84, // TrackElemType::RightBankToRightQuarterTurn3TilesUp25 - 0x008ABD94, // TrackElemType::LeftQuarterTurn3TilesDown25ToLeftBank - 0x008ABDA4, // TrackElemType::RightQuarterTurn3TilesDown25ToRightBank - 0x008ABDB4, // TrackElemType::PoweredLift - 0x008ABDC4, // TrackElemType::LeftLargeHalfLoopUp - 0x008ABDD4, // TrackElemType::RightLargeHalfLoopUp - 0x008ABDE4, // TrackElemType::RightLargeHalfLoopDown - 0x008ABDF4, // TrackElemType::LeftLargeHalfLoopDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AC134, // TrackElemType::Up90ToInvertedFlatQuarterLoop - 0x008AC144, // TrackElemType::InvertedFlatToDown90QuarterLoop - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AC0E4, // TrackElemType::BlockBrakes - 0x008ABEA4, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008ABEB4, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008ABEC4, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008ABED4, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008ABEE4, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008ABEF4, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008ABF04, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008ABF14, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008ABF24, // TrackElemType::Up25ToLeftBankedUp25 - 0x008ABF34, // TrackElemType::Up25ToRightBankedUp25 - 0x008ABF44, // TrackElemType::LeftBankedUp25ToUp25 - 0x008ABF54, // TrackElemType::RightBankedUp25ToUp25 - 0x008ABF64, // TrackElemType::Down25ToLeftBankedDown25 - 0x008ABF74, // TrackElemType::Down25ToRightBankedDown25 - 0x008ABF84, // TrackElemType::LeftBankedDown25ToDown25 - 0x008ABF94, // TrackElemType::RightBankedDown25ToDown25 - 0x008ABFA4, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008ABFB4, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008ABFE4, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008ABFF4, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008AC004, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008AC014, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008ABFC4, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008ABFD4, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008AC024, // TrackElemType::FlatToLeftBankedUp25 - 0x008AC034, // TrackElemType::FlatToRightBankedUp25 - 0x008AC044, // TrackElemType::LeftBankedUp25ToFlat - 0x008AC054, // TrackElemType::RightBankedUp25ToFlat - 0x008AC064, // TrackElemType::FlatToLeftBankedDown25 - 0x008AC074, // TrackElemType::FlatToRightBankedDown25 - 0x008AC084, // TrackElemType::LeftBankedDown25ToFlat - 0x008AC094, // TrackElemType::RightBankedDown25ToFlat - 0x008AC0A4, // TrackElemType::LeftQuarterTurn1TileUp90 - 0x008AC0B4, // TrackElemType::RightQuarterTurn1TileUp90 - 0x008AC0C4, // TrackElemType::LeftQuarterTurn1TileDown90 - 0x008AC0D4, // TrackElemType::RightQuarterTurn1TileDown90 - 0, - 0, - 0, -}; - -/** rct2: 0x008AC164 */ -static constexpr const uint32_t _OldWoodenRollerCoasterTrackPaintFunctions[256] = { - 0x008AC568, // TrackElemType::Flat - 0x008AC7B8, // TrackElemType::EndStation - 0x008AC7C8, // TrackElemType::BeginStation - 0x008AC7D8, // TrackElemType::MiddleStation - 0x008AC578, // TrackElemType::Up25 - 0x008AC588, // TrackElemType::Up60 - 0x008AC598, // TrackElemType::FlatToUp25 - 0x008AC5A8, // TrackElemType::Up25ToUp60 - 0x008AC5B8, // TrackElemType::Up60ToUp25 - 0x008AC5C8, // TrackElemType::Up25ToFlat - 0x008AC5D8, // TrackElemType::Down25 - 0x008AC5E8, // TrackElemType::Down60 - 0x008AC5F8, // TrackElemType::FlatToDown25 - 0x008AC608, // TrackElemType::Down25ToDown60 - 0x008AC618, // TrackElemType::Down60ToDown25 - 0x008AC628, // TrackElemType::Down25ToFlat - 0x008AC638, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AC648, // TrackElemType::RightQuarterTurn5Tiles - 0x008AC658, // TrackElemType::FlatToLeftBank - 0x008AC668, // TrackElemType::FlatToRightBank - 0x008AC678, // TrackElemType::LeftBankToFlat - 0x008AC688, // TrackElemType::RightBankToFlat - 0x008AC698, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AC6A8, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AC6B8, // TrackElemType::LeftBankToUp25 - 0x008AC6C8, // TrackElemType::RightBankToUp25 - 0x008AC6D8, // TrackElemType::Up25ToLeftBank - 0x008AC6E8, // TrackElemType::Up25ToRightBank - 0x008AC6F8, // TrackElemType::LeftBankToDown25 - 0x008AC708, // TrackElemType::RightBankToDown25 - 0x008AC718, // TrackElemType::Down25ToLeftBank - 0x008AC728, // TrackElemType::Down25ToRightBank - 0x008AC738, // TrackElemType::LeftBank - 0x008AC748, // TrackElemType::RightBank - 0x008AC758, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AC768, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AC778, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AC788, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AC798, // TrackElemType::SBendLeft - 0x008AC7A8, // TrackElemType::SBendRight - 0x008ACE18, // TrackElemType::LeftVerticalLoop - 0x008ACE28, // TrackElemType::RightVerticalLoop - 0x008AC7E8, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AC7F8, // TrackElemType::RightQuarterTurn3Tiles - 0x008AC808, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AC818, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AC828, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AC838, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AC848, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AC858, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ACAB8, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008ACAC8, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008ACAD8, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008ACAE8, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008ACAF8, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008ACB08, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008ACB18, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008ACB28, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008ACB98, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008ACB78, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008ACB88, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008ACBA8, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008AC868, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ACC78, // TrackElemType::Up25LeftBanked - 0x008ACC88, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008AC878, // TrackElemType::OnRidePhoto - 0x008ACC98, // TrackElemType::Down25LeftBanked - 0x008ACCA8, // TrackElemType::Down25RightBanked - 0x008ACE08, // TrackElemType::Watersplash - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AC958, // TrackElemType::LeftEighthToDiag - 0x008AC968, // TrackElemType::RightEighthToDiag - 0x008AC978, // TrackElemType::LeftEighthToOrthogonal - 0x008AC988, // TrackElemType::RightEighthToOrthogonal - 0x008AC998, // TrackElemType::LeftEighthBankToDiag - 0x008AC9A8, // TrackElemType::RightEighthBankToDiag - 0x008AC9B8, // TrackElemType::LeftEighthBankToOrthogonal - 0x008AC9C8, // TrackElemType::RightEighthBankToOrthogonal - 0x008AC888, // TrackElemType::DiagFlat - 0x008AC8B8, // TrackElemType::DiagUp25 - 0x008AC8E8, // TrackElemType::DiagUp60 - 0x008AC898, // TrackElemType::DiagFlatToUp25 - 0x008AC8C8, // TrackElemType::DiagUp25ToUp60 - 0x008AC8D8, // TrackElemType::DiagUp60ToUp25 - 0x008AC8A8, // TrackElemType::DiagUp25ToFlat - 0x008AC918, // TrackElemType::DiagDown25 - 0x008AC948, // TrackElemType::DiagDown60 - 0x008AC8F8, // TrackElemType::DiagFlatToDown25 - 0x008AC928, // TrackElemType::DiagDown25ToDown60 - 0x008AC938, // TrackElemType::DiagDown60ToDown25 - 0x008AC908, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008ACA18, // TrackElemType::DiagFlatToLeftBank - 0x008AC9F8, // TrackElemType::DiagFlatToRightBank - 0x008ACA08, // TrackElemType::DiagLeftBankToFlat - 0x008ACA28, // TrackElemType::DiagRightBankToFlat - 0x008ACA58, // TrackElemType::DiagLeftBankToUp25 - 0x008ACA68, // TrackElemType::DiagRightBankToUp25 - 0x008ACA38, // TrackElemType::DiagUp25ToLeftBank - 0x008ACA48, // TrackElemType::DiagUp25ToRightBank - 0x008ACA78, // TrackElemType::DiagLeftBankToDown25 - 0x008ACA88, // TrackElemType::DiagRightBankToDown25 - 0x008ACA98, // TrackElemType::DiagDown25ToLeftBank - 0x008ACAA8, // TrackElemType::DiagDown25ToRightBank - 0x008AC9D8, // TrackElemType::DiagLeftBank - 0x008AC9E8, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ACB38, // TrackElemType::LeftBankToLeftQuarterTurn3TilesUp25 - 0x008ACB48, // TrackElemType::RightBankToRightQuarterTurn3TilesUp25 - 0x008ACB58, // TrackElemType::LeftQuarterTurn3TilesDown25ToLeftBank - 0x008ACB68, // TrackElemType::RightQuarterTurn3TilesDown25ToRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ACDF8, // TrackElemType::BlockBrakes - 0x008ACCB8, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008ACCC8, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008ACCD8, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008ACCE8, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008ACC38, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008ACC48, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008ACC58, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008ACC68, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008ACCF8, // TrackElemType::Up25ToLeftBankedUp25 - 0x008ACD08, // TrackElemType::Up25ToRightBankedUp25 - 0x008ACD18, // TrackElemType::LeftBankedUp25ToUp25 - 0x008ACD28, // TrackElemType::RightBankedUp25ToUp25 - 0x008ACD38, // TrackElemType::Down25ToLeftBankedDown25 - 0x008ACD48, // TrackElemType::Down25ToRightBankedDown25 - 0x008ACD58, // TrackElemType::LeftBankedDown25ToDown25 - 0x008ACD68, // TrackElemType::RightBankedDown25ToDown25 - 0x008ACD78, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008ACD88, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008ACD98, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008ACDA8, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008ACDB8, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008ACDC8, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008ACDD8, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008ACDE8, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008ACBB8, // TrackElemType::FlatToLeftBankedUp25 - 0x008ACBC8, // TrackElemType::FlatToRightBankedUp25 - 0x008ACBD8, // TrackElemType::LeftBankedUp25ToFlat - 0x008ACBE8, // TrackElemType::RightBankedUp25ToFlat - 0x008ACBF8, // TrackElemType::FlatToLeftBankedDown25 - 0x008ACC08, // TrackElemType::FlatToRightBankedDown25 - 0x008ACC18, // TrackElemType::LeftBankedDown25ToFlat - 0x008ACC28, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00778124 */ -static constexpr const uint32_t _OldSideFrictionRollerCoasterTrackPaintFunctions[256] = { - 0x0077839C, // TrackElemType::Flat - 0x007784AC, // TrackElemType::EndStation - 0x007784BC, // TrackElemType::BeginStation - 0x007784CC, // TrackElemType::MiddleStation - 0x007783AC, // TrackElemType::Up25 - 0, - 0x007783CC, // TrackElemType::FlatToUp25 - 0, - 0, - 0x007783FC, // TrackElemType::Up25ToFlat - 0x0077840C, // TrackElemType::Down25 - 0, - 0x0077842C, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0077845C, // TrackElemType::Down25ToFlat - 0x0077846C, // TrackElemType::LeftQuarterTurn5Tiles - 0x0077847C, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0077848C, // TrackElemType::SBendLeft - 0x0077849C, // TrackElemType::SBendRight - 0, - 0, - 0x007784DC, // TrackElemType::LeftQuarterTurn3Tiles - 0x007784EC, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007784FC, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007785DC, // TrackElemType::LeftEighthToDiag - 0x007785EC, // TrackElemType::RightEighthToDiag - 0x007785FC, // TrackElemType::LeftEighthToOrthogonal - 0x0077860C, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x0077850C, // TrackElemType::DiagFlat - 0x0077853C, // TrackElemType::DiagUp25 - 0, - 0x0077851C, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x0077852C, // TrackElemType::DiagUp25ToFlat - 0x0077859C, // TrackElemType::DiagDown25 - 0, - 0x0077857C, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x0077858C, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0078AE80 */ -static constexpr const uint32_t _OldWildMouseTrackPaintFunctions[256] = { - 0x0078B1E4, // TrackElemType::Flat - 0x0078B2B4, // TrackElemType::EndStation - 0x0078B2C4, // TrackElemType::BeginStation - 0x0078B2D4, // TrackElemType::MiddleStation - 0x0078B1F4, // TrackElemType::Up25 - 0x0078B204, // TrackElemType::Up60 - 0x0078B214, // TrackElemType::FlatToUp25 - 0x0078B224, // TrackElemType::Up25ToUp60 - 0x0078B234, // TrackElemType::Up60ToUp25 - 0x0078B244, // TrackElemType::Up25ToFlat - 0x0078B254, // TrackElemType::Down25 - 0x0078B264, // TrackElemType::Down60 - 0x0078B274, // TrackElemType::FlatToDown25 - 0x0078B284, // TrackElemType::Down25ToDown60 - 0x0078B294, // TrackElemType::Down60ToDown25 - 0x0078B2A4, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0078B2E4, // TrackElemType::LeftQuarterTurn3Tiles - 0x0078B2F4, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0x0078B304, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x0078B314, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x0078B324, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x0078B334, // TrackElemType::RightQuarterTurn3TilesDown25 - 0x0078B394, // TrackElemType::LeftQuarterTurn1Tile - 0x0078B3A4, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0078B354, // TrackElemType::FlatToUp60 - 0x0078B364, // TrackElemType::Up60ToFlat - 0x0078B374, // TrackElemType::FlatToDown60 - 0x0078B384, // TrackElemType::Down60ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0078B344, // TrackElemType::Brakes - 0x0078B3C4, // TrackElemType::RotationControlToggle - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0078B3B4, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00792978 */ -static constexpr const uint32_t _OldMultiDimensionRollerCoasterTrackPaintFunctions[256] = { - 0x00792D88, // TrackElemType::Flat - 0x00792F98, // TrackElemType::EndStation - 0x00792FA8, // TrackElemType::BeginStation - 0x00792FB8, // TrackElemType::MiddleStation - 0x00792D98, // TrackElemType::Up25 - 0x00792DA8, // TrackElemType::Up60 - 0x00792DB8, // TrackElemType::FlatToUp25 - 0x00792DC8, // TrackElemType::Up25ToUp60 - 0x00792DD8, // TrackElemType::Up60ToUp25 - 0x00792DE8, // TrackElemType::Up25ToFlat - 0x00792DF8, // TrackElemType::Down25 - 0x00792E08, // TrackElemType::Down60 - 0x00792E18, // TrackElemType::FlatToDown25 - 0x00792E28, // TrackElemType::Down25ToDown60 - 0x00792E38, // TrackElemType::Down60ToDown25 - 0x00792E48, // TrackElemType::Down25ToFlat - 0x00792E58, // TrackElemType::LeftQuarterTurn5Tiles - 0x00792E68, // TrackElemType::RightQuarterTurn5Tiles - 0x00792E78, // TrackElemType::FlatToLeftBank - 0x00792E88, // TrackElemType::FlatToRightBank - 0x00792E98, // TrackElemType::LeftBankToFlat - 0x00792EA8, // TrackElemType::RightBankToFlat - 0x00792EB8, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x00792EC8, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x00792ED8, // TrackElemType::LeftBankToUp25 - 0x00792EE8, // TrackElemType::RightBankToUp25 - 0x00792EF8, // TrackElemType::Up25ToLeftBank - 0x00792F08, // TrackElemType::Up25ToRightBank - 0x00792F18, // TrackElemType::LeftBankToDown25 - 0x00792F28, // TrackElemType::RightBankToDown25 - 0x00792F38, // TrackElemType::Down25ToLeftBank - 0x00792F48, // TrackElemType::Down25ToRightBank - 0x00792F58, // TrackElemType::LeftBank - 0x00792F68, // TrackElemType::RightBank - 0, - 0, - 0, - 0, - 0x00792F78, // TrackElemType::SBendLeft - 0x00792F88, // TrackElemType::SBendRight - 0, - 0, - 0x00792FC8, // TrackElemType::LeftQuarterTurn3Tiles - 0x00792FD8, // TrackElemType::RightQuarterTurn3Tiles - 0x00792FE8, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x00792FF8, // TrackElemType::RightBankedQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793008, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x00793018, // TrackElemType::RightHalfBankedHelixUpSmall - 0x00793028, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x00793038, // TrackElemType::RightHalfBankedHelixDownSmall - 0x00793048, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x00793058, // TrackElemType::RightHalfBankedHelixUpLarge - 0x00793068, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x00793078, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x00793088, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793098, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793328, // TrackElemType::Up90 - 0x00793338, // TrackElemType::Down90 - 0x00793348, // TrackElemType::Up60ToUp90 - 0x00793358, // TrackElemType::Down90ToDown60 - 0x00793368, // TrackElemType::Up90ToUp60 - 0x00793378, // TrackElemType::Down60ToDown90 - 0, - 0x007930B8, // TrackElemType::LeftEighthToDiag - 0x007930C8, // TrackElemType::RightEighthToDiag - 0x007930D8, // TrackElemType::LeftEighthToOrthogonal - 0x007930E8, // TrackElemType::RightEighthToOrthogonal - 0x007930F8, // TrackElemType::LeftEighthBankToDiag - 0x00793108, // TrackElemType::RightEighthBankToDiag - 0x00793118, // TrackElemType::LeftEighthBankToOrthogonal - 0x00793128, // TrackElemType::RightEighthBankToOrthogonal - 0x007930A8, // TrackElemType::DiagFlat - 0x00793158, // TrackElemType::DiagUp25 - 0x007931B8, // TrackElemType::DiagUp60 - 0x00793138, // TrackElemType::DiagFlatToUp25 - 0x00793198, // TrackElemType::DiagUp25ToUp60 - 0x007931A8, // TrackElemType::DiagUp60ToUp25 - 0x00793148, // TrackElemType::DiagUp25ToFlat - 0x00793188, // TrackElemType::DiagDown25 - 0x007931E8, // TrackElemType::DiagDown60 - 0x00793168, // TrackElemType::DiagFlatToDown25 - 0x007931C8, // TrackElemType::DiagDown25ToDown60 - 0x007931D8, // TrackElemType::DiagDown60ToDown25 - 0x00793178, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x00793218, // TrackElemType::DiagFlatToLeftBank - 0x00793228, // TrackElemType::DiagFlatToRightBank - 0x00793238, // TrackElemType::DiagLeftBankToFlat - 0x00793248, // TrackElemType::DiagRightBankToFlat - 0x00793278, // TrackElemType::DiagLeftBankToUp25 - 0x00793288, // TrackElemType::DiagRightBankToUp25 - 0x00793258, // TrackElemType::DiagUp25ToLeftBank - 0x00793268, // TrackElemType::DiagUp25ToRightBank - 0x00793298, // TrackElemType::DiagLeftBankToDown25 - 0x007932A8, // TrackElemType::DiagRightBankToDown25 - 0x007932B8, // TrackElemType::DiagDown25ToLeftBank - 0x007932C8, // TrackElemType::DiagDown25ToRightBank - 0x007931F8, // TrackElemType::DiagLeftBank - 0x00793208, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007932D8, // TrackElemType::LeftFlyerTwistUp - 0x007932E8, // TrackElemType::RightFlyerTwistUp - 0x007932F8, // TrackElemType::LeftFlyerTwistDown - 0x00793308, // TrackElemType::RightFlyerTwistDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793398, // TrackElemType::MultiDimInvertedFlatToDown90QuarterLoop - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793318, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00793388, // TrackElemType::MultiDimUp90ToInvertedFlatQuarterLoop - 0x00793398, // TrackElemType::MultiDimFlatToDown90QuarterLoop - 0x00793388, // (null) -}; - -/** rct2: 0x007C6C00 */ -static constexpr const uint32_t _OldFlyingRollerCoasterTrackPaintFunctions[256] = { - 0x007C6FF4, // TrackElemType::Flat - 0x007C7244, // TrackElemType::EndStation - 0x007C7254, // TrackElemType::BeginStation - 0x007C7264, // TrackElemType::MiddleStation - 0x007C7004, // TrackElemType::Up25 - 0x007C7014, // TrackElemType::Up60 - 0x007C7024, // TrackElemType::FlatToUp25 - 0x007C7034, // TrackElemType::Up25ToUp60 - 0x007C7044, // TrackElemType::Up60ToUp25 - 0x007C7054, // TrackElemType::Up25ToFlat - 0x007C7064, // TrackElemType::Down25 - 0x007C7074, // TrackElemType::Down60 - 0x007C7084, // TrackElemType::FlatToDown25 - 0x007C7094, // TrackElemType::Down25ToDown60 - 0x007C70A4, // TrackElemType::Down60ToDown25 - 0x007C70B4, // TrackElemType::Down25ToFlat - 0x007C70C4, // TrackElemType::LeftQuarterTurn5Tiles - 0x007C70D4, // TrackElemType::RightQuarterTurn5Tiles - 0x007C70E4, // TrackElemType::FlatToLeftBank - 0x007C70F4, // TrackElemType::FlatToRightBank - 0x007C7104, // TrackElemType::LeftBankToFlat - 0x007C7114, // TrackElemType::RightBankToFlat - 0x007C7124, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x007C7134, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x007C7144, // TrackElemType::LeftBankToUp25 - 0x007C7154, // TrackElemType::RightBankToUp25 - 0x007C7164, // TrackElemType::Up25ToLeftBank - 0x007C7174, // TrackElemType::Up25ToRightBank - 0x007C7184, // TrackElemType::LeftBankToDown25 - 0x007C7194, // TrackElemType::RightBankToDown25 - 0x007C71A4, // TrackElemType::Down25ToLeftBank - 0x007C71B4, // TrackElemType::Down25ToRightBank - 0x007C71C4, // TrackElemType::LeftBank - 0x007C71D4, // TrackElemType::RightBank - 0x007C71E4, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x007C71F4, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x007C7204, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x007C7214, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x007C7224, // TrackElemType::SBendLeft - 0x007C7234, // TrackElemType::SBendRight - 0, - 0, - 0x007C7274, // TrackElemType::LeftQuarterTurn3Tiles - 0x007C7284, // TrackElemType::RightQuarterTurn3Tiles - 0x007C7294, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x007C72A4, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x007C72B4, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x007C72C4, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x007C72D4, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x007C72E4, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007C7314, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x007C7324, // TrackElemType::RightHalfBankedHelixUpSmall - 0x007C7334, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x007C7344, // TrackElemType::RightHalfBankedHelixDownSmall - 0x007C7354, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x007C7364, // TrackElemType::RightHalfBankedHelixUpLarge - 0x007C7374, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x007C7384, // TrackElemType::RightHalfBankedHelixDownLarge - 0x007C73B4, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x007C7394, // TrackElemType::RightQuarterTurn1TileUp60 - 0x007C73A4, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x007C73C4, // TrackElemType::RightQuarterTurn1TileDown60 - 0x007C73D4, // TrackElemType::Brakes - 0, - 0, - 0x007C7674, // TrackElemType::LeftQuarterBankedHelixLargeUp - 0x007C7684, // TrackElemType::RightQuarterBankedHelixLargeUp - 0x007C7694, // TrackElemType::LeftQuarterBankedHelixLargeDown - 0x007C76A4, // TrackElemType::RightQuarterBankedHelixLargeDown - 0, - 0, - 0, - 0, - 0x007C78B4, // TrackElemType::Up25LeftBanked - 0x007C78C4, // TrackElemType::Up25RightBanked - 0, - 0, - 0x007C73E4, // TrackElemType::OnRidePhoto - 0x007C78D4, // TrackElemType::Down25LeftBanked - 0x007C78E4, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007C7404, // TrackElemType::LeftEighthToDiag - 0x007C7414, // TrackElemType::RightEighthToDiag - 0x007C7424, // TrackElemType::LeftEighthToOrthogonal - 0x007C7434, // TrackElemType::RightEighthToOrthogonal - 0x007C7444, // TrackElemType::LeftEighthBankToDiag - 0x007C7454, // TrackElemType::RightEighthBankToDiag - 0x007C7464, // TrackElemType::LeftEighthBankToOrthogonal - 0x007C7474, // TrackElemType::RightEighthBankToOrthogonal - 0x007C73F4, // TrackElemType::DiagFlat - 0x007C74A4, // TrackElemType::DiagUp25 - 0x007C7504, // TrackElemType::DiagUp60 - 0x007C7484, // TrackElemType::DiagFlatToUp25 - 0x007C74E4, // TrackElemType::DiagUp25ToUp60 - 0x007C74F4, // TrackElemType::DiagUp60ToUp25 - 0x007C7494, // TrackElemType::DiagUp25ToFlat - 0x007C74D4, // TrackElemType::DiagDown25 - 0x007C7534, // TrackElemType::DiagDown60 - 0x007C74B4, // TrackElemType::DiagFlatToDown25 - 0x007C7514, // TrackElemType::DiagDown25ToDown60 - 0x007C7524, // TrackElemType::DiagDown60ToDown25 - 0x007C74C4, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x007C7564, // TrackElemType::DiagFlatToLeftBank - 0x007C7574, // TrackElemType::DiagFlatToRightBank - 0x007C7584, // TrackElemType::DiagLeftBankToFlat - 0x007C7594, // TrackElemType::DiagRightBankToFlat - 0x007C75C4, // TrackElemType::DiagLeftBankToUp25 - 0x007C75D4, // TrackElemType::DiagRightBankToUp25 - 0x007C75A4, // TrackElemType::DiagUp25ToLeftBank - 0x007C75B4, // TrackElemType::DiagUp25ToRightBank - 0x007C75E4, // TrackElemType::DiagLeftBankToDown25 - 0x007C75F4, // TrackElemType::DiagRightBankToDown25 - 0x007C7604, // TrackElemType::DiagDown25ToLeftBank - 0x007C7614, // TrackElemType::DiagDown25ToRightBank - 0x007C7544, // TrackElemType::DiagLeftBank - 0x007C7554, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007C7624, // TrackElemType::LeftFlyerTwistUp - 0x007C7634, // TrackElemType::RightFlyerTwistUp - 0x007C7644, // TrackElemType::LeftFlyerTwistDown - 0x007C7654, // TrackElemType::RightFlyerTwistDown - 0x007C72F4, // TrackElemType::FlyerHalfLoopUp - 0x007C7304, // TrackElemType::FlyerHalfLoopDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x007C7664, // TrackElemType::BlockBrakes - 0x007C76B4, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x007C76C4, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x007C76D4, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x007C76E4, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x007C76F4, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x007C7704, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x007C7714, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x007C7724, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x007C7734, // TrackElemType::Up25ToLeftBankedUp25 - 0x007C7744, // TrackElemType::Up25ToRightBankedUp25 - 0x007C7754, // TrackElemType::LeftBankedUp25ToUp25 - 0x007C7764, // TrackElemType::RightBankedUp25ToUp25 - 0x007C7774, // TrackElemType::Down25ToLeftBankedDown25 - 0x007C7784, // TrackElemType::Down25ToRightBankedDown25 - 0x007C7794, // TrackElemType::LeftBankedDown25ToDown25 - 0x007C77A4, // TrackElemType::RightBankedDown25ToDown25 - 0x007C77B4, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x007C77C4, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x007C77F4, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x007C7804, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x007C7814, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x007C7824, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x007C77D4, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x007C77E4, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x007C7834, // TrackElemType::FlatToLeftBankedUp25 - 0x007C7844, // TrackElemType::FlatToRightBankedUp25 - 0x007C7854, // TrackElemType::LeftBankedUp25ToFlat - 0x007C7864, // TrackElemType::RightBankedUp25ToFlat - 0x007C7874, // TrackElemType::FlatToLeftBankedDown25 - 0x007C7884, // TrackElemType::FlatToRightBankedDown25 - 0x007C7894, // TrackElemType::LeftBankedDown25ToFlat - 0x007C78A4, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00811184 */ -static constexpr const uint32_t _OldVirginiaReelTrackPaintFunctions[256] = { - 0x00811264, // TrackElemType::Flat - 0x008112D4, // TrackElemType::EndStation - 0x008112E4, // TrackElemType::BeginStation - 0x008112F4, // TrackElemType::MiddleStation - 0x00811274, // TrackElemType::Up25 - 0, - 0x00811284, // TrackElemType::FlatToUp25 - 0, - 0, - 0x00811294, // TrackElemType::Up25ToFlat - 0x008112A4, // TrackElemType::Down25 - 0, - 0x008112B4, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008112C4, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00811304, // TrackElemType::LeftQuarterTurn3Tiles - 0x00811314, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0x00811324, // TrackElemType::LeftQuarterTurn1Tile - 0x00811334, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008164AC */ -static constexpr const uint32_t _OldSplashBoatsTrackPaintFunctions[256] = { - 0x00816584, // TrackElemType::Flat - 0x00816614, // TrackElemType::EndStation - 0x00816624, // TrackElemType::BeginStation - 0x00816634, // TrackElemType::MiddleStation - 0x00816594, // TrackElemType::Up25 - 0x008166A4, // TrackElemType::Up60 - 0x008165A4, // TrackElemType::FlatToUp25 - 0x00816664, // TrackElemType::Up25ToUp60 - 0x00816674, // TrackElemType::Up60ToUp25 - 0x008165B4, // TrackElemType::Up25ToFlat - 0x008165C4, // TrackElemType::Down25 - 0x008166B4, // TrackElemType::Down60 - 0x008165D4, // TrackElemType::FlatToDown25 - 0x00816684, // TrackElemType::Down25ToDown60 - 0x00816694, // TrackElemType::Down60ToDown25 - 0x008165E4, // TrackElemType::Down25ToFlat - 0x00816644, // TrackElemType::LeftQuarterTurn5Tiles - 0x00816654, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008165F4, // TrackElemType::SBendLeft - 0x00816604, // TrackElemType::SBendRight - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0081F268 */ -static constexpr const uint32_t _OldMiniHelicoptersTrackPaintFunctions[256] = { - 0x0081F348, // TrackElemType::Flat - 0x0081F3B8, // TrackElemType::EndStation - 0x0081F3C8, // TrackElemType::BeginStation - 0x0081F3D8, // TrackElemType::MiddleStation - 0x0081F358, // TrackElemType::Up25 - 0, - 0x0081F368, // TrackElemType::FlatToUp25 - 0, - 0, - 0x0081F378, // TrackElemType::Up25ToFlat - 0x0081F388, // TrackElemType::Down25 - 0, - 0x0081F398, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0081F3A8, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0081F3E8, // TrackElemType::LeftQuarterTurn3Tiles - 0x0081F3F8, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0x0081F408, // TrackElemType::LeftQuarterTurn1Tile - 0x0081F418, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008245A8 */ -static constexpr const uint32_t _OldLayDownRollerCoasterTrackPaintFunctions[256] = { - 0x0082491C, // TrackElemType::Flat - 0x00824B8C, // TrackElemType::EndStation - 0x00824B9C, // TrackElemType::BeginStation - 0x00824BAC, // TrackElemType::MiddleStation - 0x0082492C, // TrackElemType::Up25 - 0x0082493C, // TrackElemType::Up60 - 0x0082494C, // TrackElemType::FlatToUp25 - 0x0082495C, // TrackElemType::Up25ToUp60 - 0x0082496C, // TrackElemType::Up60ToUp25 - 0x0082497C, // TrackElemType::Up25ToFlat - 0x0082498C, // TrackElemType::Down25 - 0x0082499C, // TrackElemType::Down60 - 0x008249AC, // TrackElemType::FlatToDown25 - 0x008249BC, // TrackElemType::Down25ToDown60 - 0x008249CC, // TrackElemType::Down60ToDown25 - 0x008249DC, // TrackElemType::Down25ToFlat - 0x008249EC, // TrackElemType::LeftQuarterTurn5Tiles - 0x008249FC, // TrackElemType::RightQuarterTurn5Tiles - 0x00824A0C, // TrackElemType::FlatToLeftBank - 0x00824A1C, // TrackElemType::FlatToRightBank - 0x00824A2C, // TrackElemType::LeftBankToFlat - 0x00824A3C, // TrackElemType::RightBankToFlat - 0x00824A4C, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x00824A5C, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x00824A6C, // TrackElemType::LeftBankToUp25 - 0x00824A7C, // TrackElemType::RightBankToUp25 - 0x00824A8C, // TrackElemType::Up25ToLeftBank - 0x00824A9C, // TrackElemType::Up25ToRightBank - 0x00824AAC, // TrackElemType::LeftBankToDown25 - 0x00824ABC, // TrackElemType::RightBankToDown25 - 0x00824ACC, // TrackElemType::Down25ToLeftBank - 0x00824ADC, // TrackElemType::Down25ToRightBank - 0x00824AEC, // TrackElemType::LeftBank - 0x00824AFC, // TrackElemType::RightBank - 0x00824B0C, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x00824B1C, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x00824B2C, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x00824B3C, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x00824B4C, // TrackElemType::SBendLeft - 0x00824B5C, // TrackElemType::SBendRight - 0x00824B6C, // TrackElemType::LeftVerticalLoop - 0x00824B7C, // TrackElemType::RightVerticalLoop - 0x00824BBC, // TrackElemType::LeftQuarterTurn3Tiles - 0x00824BCC, // TrackElemType::RightQuarterTurn3Tiles - 0x00824BDC, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x00824BEC, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x00824BFC, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x00824C0C, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x00824C1C, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x00824C2C, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00824C9C, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x00824CAC, // TrackElemType::RightHalfBankedHelixUpSmall - 0x00824CBC, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x00824CCC, // TrackElemType::RightHalfBankedHelixDownSmall - 0x00824CDC, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x00824CEC, // TrackElemType::RightHalfBankedHelixUpLarge - 0x00824CFC, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x00824D0C, // TrackElemType::RightHalfBankedHelixDownLarge - 0x00824D3C, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x00824D1C, // TrackElemType::RightQuarterTurn1TileUp60 - 0x00824D2C, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x00824D4C, // TrackElemType::RightQuarterTurn1TileDown60 - 0x00824D5C, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00824D6C, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00824D8C, // TrackElemType::LeftEighthToDiag - 0x00824D9C, // TrackElemType::RightEighthToDiag - 0x00824DAC, // TrackElemType::LeftEighthToOrthogonal - 0x00824DBC, // TrackElemType::RightEighthToOrthogonal - 0x00824DCC, // TrackElemType::LeftEighthBankToDiag - 0x00824DDC, // TrackElemType::RightEighthBankToDiag - 0x00824DEC, // TrackElemType::LeftEighthBankToOrthogonal - 0x00824DFC, // TrackElemType::RightEighthBankToOrthogonal - 0x00824D7C, // TrackElemType::DiagFlat - 0x00824E2C, // TrackElemType::DiagUp25 - 0x00824E8C, // TrackElemType::DiagUp60 - 0x00824E0C, // TrackElemType::DiagFlatToUp25 - 0x00824E6C, // TrackElemType::DiagUp25ToUp60 - 0x00824E7C, // TrackElemType::DiagUp60ToUp25 - 0x00824E1C, // TrackElemType::DiagUp25ToFlat - 0x00824E5C, // TrackElemType::DiagDown25 - 0x00824EBC, // TrackElemType::DiagDown60 - 0x00824E3C, // TrackElemType::DiagFlatToDown25 - 0x00824E9C, // TrackElemType::DiagDown25ToDown60 - 0x00824EAC, // TrackElemType::DiagDown60ToDown25 - 0x00824E4C, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x00824EEC, // TrackElemType::DiagFlatToLeftBank - 0x00824EFC, // TrackElemType::DiagFlatToRightBank - 0x00824F0C, // TrackElemType::DiagLeftBankToFlat - 0x00824F1C, // TrackElemType::DiagRightBankToFlat - 0x00824F4C, // TrackElemType::DiagLeftBankToUp25 - 0x00824F5C, // TrackElemType::DiagRightBankToUp25 - 0x00824F2C, // TrackElemType::DiagUp25ToLeftBank - 0x00824F3C, // TrackElemType::DiagUp25ToRightBank - 0x00824F6C, // TrackElemType::DiagLeftBankToDown25 - 0x00824F7C, // TrackElemType::DiagRightBankToDown25 - 0x00824F8C, // TrackElemType::DiagDown25ToLeftBank - 0x00824F9C, // TrackElemType::DiagDown25ToRightBank - 0x00824ECC, // TrackElemType::DiagLeftBank - 0x00824EDC, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00824FAC, // TrackElemType::LeftFlyerTwistUp - 0x00824FBC, // TrackElemType::RightFlyerTwistUp - 0x00824FCC, // TrackElemType::LeftFlyerTwistDown - 0x00824FDC, // TrackElemType::RightFlyerTwistDown - 0x00824C3C, // TrackElemType::FlyerHalfLoopUp - 0x00824C4C, // TrackElemType::FlyerHalfLoopDown - 0x00824C5C, // TrackElemType::LeftFlyerCorkscrewUp - 0x00824C6C, // TrackElemType::RightFlyerCorkscrewUp - 0x00824C7C, // TrackElemType::LeftFlyerCorkscrewDown - 0x00824C8C, // TrackElemType::RightFlyerCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00824FEC, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0086347C */ -static constexpr const uint32_t _OldSuspendedMonorailTrackPaintFunctions[256] = { - 0x008636F4, // TrackElemType::Flat - 0x008637A4, // TrackElemType::EndStation - 0x008637B4, // TrackElemType::BeginStation - 0x008637C4, // TrackElemType::MiddleStation - 0x00863704, // TrackElemType::Up25 - 0, - 0x00863714, // TrackElemType::FlatToUp25 - 0, - 0, - 0x00863724, // TrackElemType::Up25ToFlat - 0x00863734, // TrackElemType::Down25 - 0, - 0x00863744, // TrackElemType::FlatToDown25 - 0, - 0, - 0x00863754, // TrackElemType::Down25ToFlat - 0x00863764, // TrackElemType::LeftQuarterTurn5Tiles - 0x00863774, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00863784, // TrackElemType::SBendLeft - 0x00863794, // TrackElemType::SBendRight - 0, - 0, - 0x008637D4, // TrackElemType::LeftQuarterTurn3Tiles - 0x008637E4, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00863864, // TrackElemType::LeftEighthToDiag - 0x00863874, // TrackElemType::RightEighthToDiag - 0x00863884, // TrackElemType::LeftEighthToOrthogonal - 0x00863894, // TrackElemType::RightEighthToOrthogonal - 0, - 0, - 0, - 0, - 0x008637F4, // TrackElemType::DiagFlat - 0x00863824, // TrackElemType::DiagUp25 - 0, - 0x00863804, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x00863814, // TrackElemType::DiagUp25ToFlat - 0x00863854, // TrackElemType::DiagDown25 - 0, - 0x00863834, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x00863844, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0086E2F8 */ -static constexpr const uint32_t _OldReverserRollerCoasterTrackPaintFunctions[256] = { - 0x0086E65C, // TrackElemType::Flat - 0x0086E70C, // TrackElemType::EndStation - 0x0086E71C, // TrackElemType::BeginStation - 0x0086E72C, // TrackElemType::MiddleStation - 0x0086E66C, // TrackElemType::Up25 - 0, - 0x0086E67C, // TrackElemType::FlatToUp25 - 0, - 0, - 0x0086E68C, // TrackElemType::Up25ToFlat - 0x0086E69C, // TrackElemType::Down25 - 0, - 0x0086E6AC, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0086E6BC, // TrackElemType::Down25ToFlat - 0x0086E6CC, // TrackElemType::LeftQuarterTurn5Tiles - 0x0086E6DC, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0086E6EC, // TrackElemType::SBendLeft - 0x0086E6FC, // TrackElemType::SBendRight - 0, - 0, - 0x0086E73C, // TrackElemType::LeftQuarterTurn3Tiles - 0x0086E74C, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0086E75C, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0086E76C, // TrackElemType::LeftReverser - 0x0086E77C, // TrackElemType::RightReverser - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00876618 */ -static constexpr const uint32_t _OldHeartlineTwisterCoasterTrackPaintFunctions[256] = { - 0x0087694C, // TrackElemType::Flat - 0x00876A1C, // TrackElemType::EndStation - 0x00876A2C, // TrackElemType::BeginStation - 0x00876A3C, // TrackElemType::MiddleStation - 0x0087695C, // TrackElemType::Up25 - 0x008769FC, // TrackElemType::Up60 - 0x0087696C, // TrackElemType::FlatToUp25 - 0x008769BC, // TrackElemType::Up25ToUp60 - 0x008769CC, // TrackElemType::Up60ToUp25 - 0x0087697C, // TrackElemType::Up25ToFlat - 0x0087698C, // TrackElemType::Down25 - 0x00876A0C, // TrackElemType::Down60 - 0x0087699C, // TrackElemType::FlatToDown25 - 0x008769DC, // TrackElemType::Down25ToDown60 - 0x008769EC, // TrackElemType::Down60ToDown25 - 0x008769AC, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00876A6C, // TrackElemType::HeartLineTransferUp - 0x00876A7C, // TrackElemType::HeartLineTransferDown - 0x00876A4C, // TrackElemType::LeftHeartLineRoll - 0x00876A5C, // TrackElemType::RightHeartLineRoll - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0087EDC4 */ -static constexpr const uint32_t _OldMiniGolfTrackPaintFunctions[256] = { - 0x0087F10C, // TrackElemType::Flat - 0x0087F17C, // TrackElemType::EndStation - 0x0087F18C, // TrackElemType::BeginStation - 0x0087F19C, // TrackElemType::MiddleStation - 0x0087F11C, // TrackElemType::Up25 - 0, - 0x0087F12C, // TrackElemType::FlatToUp25 - 0, - 0, - 0x0087F13C, // TrackElemType::Up25ToFlat - 0x0087F14C, // TrackElemType::Down25 - 0, - 0x0087F15C, // TrackElemType::FlatToDown25 - 0, - 0, - 0x0087F16C, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0087F1AC, // TrackElemType::LeftQuarterTurn1Tile - 0x0087F1BC, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0087F1CC, // TrackElemType::MinigolfHoleA - 0x0087F1DC, // TrackElemType::MinigolfHoleB - 0x0087F1EC, // TrackElemType::MinigolfHoleC - 0x0087F1FC, // TrackElemType::MinigolfHoleD - 0x0087F20C, // TrackElemType::MinigolfHoleE - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AD280 */ -static constexpr const uint32_t _OldGigaCoasterTrackPaintFunctions[256] = { - 0x008AD674, // TrackElemType::Flat - 0x008AD8C4, // TrackElemType::EndStation - 0x008AD8D4, // TrackElemType::BeginStation - 0x008AD8E4, // TrackElemType::MiddleStation - 0x008AD684, // TrackElemType::Up25 - 0x008AD694, // TrackElemType::Up60 - 0x008AD6A4, // TrackElemType::FlatToUp25 - 0x008AD6B4, // TrackElemType::Up25ToUp60 - 0x008AD6C4, // TrackElemType::Up60ToUp25 - 0x008AD6D4, // TrackElemType::Up25ToFlat - 0x008AD6E4, // TrackElemType::Down25 - 0x008AD6F4, // TrackElemType::Down60 - 0x008AD704, // TrackElemType::FlatToDown25 - 0x008AD714, // TrackElemType::Down25ToDown60 - 0x008AD724, // TrackElemType::Down60ToDown25 - 0x008AD734, // TrackElemType::Down25ToFlat - 0x008AD744, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AD754, // TrackElemType::RightQuarterTurn5Tiles - 0x008AD764, // TrackElemType::FlatToLeftBank - 0x008AD774, // TrackElemType::FlatToRightBank - 0x008AD784, // TrackElemType::LeftBankToFlat - 0x008AD794, // TrackElemType::RightBankToFlat - 0x008AD7A4, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AD7B4, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AD7C4, // TrackElemType::LeftBankToUp25 - 0x008AD7D4, // TrackElemType::RightBankToUp25 - 0x008AD7E4, // TrackElemType::Up25ToLeftBank - 0x008AD7F4, // TrackElemType::Up25ToRightBank - 0x008AD804, // TrackElemType::LeftBankToDown25 - 0x008AD814, // TrackElemType::RightBankToDown25 - 0x008AD824, // TrackElemType::Down25ToLeftBank - 0x008AD834, // TrackElemType::Down25ToRightBank - 0x008AD844, // TrackElemType::LeftBank - 0x008AD854, // TrackElemType::RightBank - 0x008AD864, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AD874, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AD884, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AD894, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AD8A4, // TrackElemType::SBendLeft - 0x008AD8B4, // TrackElemType::SBendRight - 0, - 0, - 0x008AD8F4, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AD904, // TrackElemType::RightQuarterTurn3Tiles - 0x008AD914, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AD924, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AD934, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AD944, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AD954, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AD964, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AD974, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008AD984, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008AD994, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008AD9A4, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008AD9B4, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008AD9C4, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008AD9D4, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008AD9E4, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008ADA14, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008AD9F4, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008ADA04, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008ADA24, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008ADA34, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ADC84, // TrackElemType::Up25LeftBanked - 0x008ADC94, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008ADA44, // TrackElemType::OnRidePhoto - 0x008ADCA4, // TrackElemType::Down25LeftBanked - 0x008ADCB4, // TrackElemType::Down25RightBanked - 0, - 0x008ADED4, // TrackElemType::FlatToUp60LongBase - 0x008ADEE4, // TrackElemType::Up60ToFlatLongBase - 0, - 0x008ADEF4, // TrackElemType::Down60ToFlatLongBase - 0x008ADF04, // TrackElemType::FlatToDown60LongBase - 0x008ADF14, // TrackElemType::CableLiftHill - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ADA64, // TrackElemType::LeftEighthToDiag - 0x008ADA74, // TrackElemType::RightEighthToDiag - 0x008ADA84, // TrackElemType::LeftEighthToOrthogonal - 0x008ADA94, // TrackElemType::RightEighthToOrthogonal - 0x008ADAA4, // TrackElemType::LeftEighthBankToDiag - 0x008ADAB4, // TrackElemType::RightEighthBankToDiag - 0x008ADAC4, // TrackElemType::LeftEighthBankToOrthogonal - 0x008ADAD4, // TrackElemType::RightEighthBankToOrthogonal - 0x008ADA54, // TrackElemType::DiagFlat - 0x008ADB04, // TrackElemType::DiagUp25 - 0x008ADB64, // TrackElemType::DiagUp60 - 0x008ADAE4, // TrackElemType::DiagFlatToUp25 - 0x008ADB44, // TrackElemType::DiagUp25ToUp60 - 0x008ADB54, // TrackElemType::DiagUp60ToUp25 - 0x008ADAF4, // TrackElemType::DiagUp25ToFlat - 0x008ADB34, // TrackElemType::DiagDown25 - 0x008ADB94, // TrackElemType::DiagDown60 - 0x008ADB14, // TrackElemType::DiagFlatToDown25 - 0x008ADB74, // TrackElemType::DiagDown25ToDown60 - 0x008ADB84, // TrackElemType::DiagDown60ToDown25 - 0x008ADB24, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008ADBC4, // TrackElemType::DiagFlatToLeftBank - 0x008ADBD4, // TrackElemType::DiagFlatToRightBank - 0x008ADBE4, // TrackElemType::DiagLeftBankToFlat - 0x008ADBF4, // TrackElemType::DiagRightBankToFlat - 0x008ADC24, // TrackElemType::DiagLeftBankToUp25 - 0x008ADC34, // TrackElemType::DiagRightBankToUp25 - 0x008ADC04, // TrackElemType::DiagUp25ToLeftBank - 0x008ADC14, // TrackElemType::DiagUp25ToRightBank - 0x008ADC44, // TrackElemType::DiagLeftBankToDown25 - 0x008ADC54, // TrackElemType::DiagRightBankToDown25 - 0x008ADC64, // TrackElemType::DiagDown25ToLeftBank - 0x008ADC74, // TrackElemType::DiagDown25ToRightBank - 0x008ADBA4, // TrackElemType::DiagLeftBank - 0x008ADBB4, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008ADEC4, // TrackElemType::BlockBrakes - 0x008ADCC4, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008ADCD4, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008ADCE4, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008ADCF4, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008ADD04, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008ADD14, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008ADD24, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008ADD34, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008ADD44, // TrackElemType::Up25ToLeftBankedUp25 - 0x008ADD54, // TrackElemType::Up25ToRightBankedUp25 - 0x008ADD64, // TrackElemType::LeftBankedUp25ToUp25 - 0x008ADD74, // TrackElemType::RightBankedUp25ToUp25 - 0x008ADD84, // TrackElemType::Down25ToLeftBankedDown25 - 0x008ADD94, // TrackElemType::Down25ToRightBankedDown25 - 0x008ADDA4, // TrackElemType::LeftBankedDown25ToDown25 - 0x008ADDB4, // TrackElemType::RightBankedDown25ToDown25 - 0x008ADDC4, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008ADDD4, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008ADE04, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008ADE14, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008ADE24, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008ADE34, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008ADDE4, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008ADDF4, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008ADE44, // TrackElemType::FlatToLeftBankedUp25 - 0x008ADE54, // TrackElemType::FlatToRightBankedUp25 - 0x008ADE64, // TrackElemType::LeftBankedUp25ToFlat - 0x008ADE74, // TrackElemType::RightBankedUp25ToFlat - 0x008ADE84, // TrackElemType::FlatToLeftBankedDown25 - 0x008ADE94, // TrackElemType::FlatToRightBankedDown25 - 0x008ADEA4, // TrackElemType::LeftBankedDown25ToFlat - 0x008ADEB4, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00886074 */ -static constexpr const uint32_t _OldRoToDropTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00886194, // TrackElemType::TowerBase - 0x008861A4, // TrackElemType::TowerSection - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00887208 */ -static constexpr const uint32_t _OldFlyingSaucersTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008873D8, // 111 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00889C28 */ -static constexpr const uint32_t _OldCrookedHouseTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00889E28, // 123 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0088AC88 */ -static constexpr const uint32_t _OldMonorailCyclesTrackPaintFunctions[256] = { - 0x0088AD48, // TrackElemType::Flat - 0x0088AD58, // TrackElemType::EndStation - 0x0088AD68, // TrackElemType::BeginStation - 0x0088AD78, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0088ADA8, // TrackElemType::LeftQuarterTurn5Tiles - 0x0088ADB8, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0088ADC8, // TrackElemType::SBendLeft - 0x0088ADD8, // TrackElemType::SBendRight - 0, - 0, - 0x0088AD88, // TrackElemType::LeftQuarterTurn3Tiles - 0x0088AD98, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AE36C */ -static constexpr const uint32_t _OldCompactInvertedCoasterTrackPaintFunctions[256] = { - 0x008AE6E0, // TrackElemType::Flat - 0x008AE950, // TrackElemType::EndStation - 0x008AE960, // TrackElemType::BeginStation - 0x008AE970, // TrackElemType::MiddleStation - 0x008AE6F0, // TrackElemType::Up25 - 0x008AE700, // TrackElemType::Up60 - 0x008AE710, // TrackElemType::FlatToUp25 - 0x008AE720, // TrackElemType::Up25ToUp60 - 0x008AE730, // TrackElemType::Up60ToUp25 - 0x008AE740, // TrackElemType::Up25ToFlat - 0x008AE750, // TrackElemType::Down25 - 0x008AE760, // TrackElemType::Down60 - 0x008AE770, // TrackElemType::FlatToDown25 - 0x008AE780, // TrackElemType::Down25ToDown60 - 0x008AE790, // TrackElemType::Down60ToDown25 - 0x008AE7A0, // TrackElemType::Down25ToFlat - 0x008AE7B0, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AE7C0, // TrackElemType::RightQuarterTurn5Tiles - 0x008AE7D0, // TrackElemType::FlatToLeftBank - 0x008AE7E0, // TrackElemType::FlatToRightBank - 0x008AE7F0, // TrackElemType::LeftBankToFlat - 0x008AE800, // TrackElemType::RightBankToFlat - 0x008AE810, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AE820, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AE830, // TrackElemType::LeftBankToUp25 - 0x008AE840, // TrackElemType::RightBankToUp25 - 0x008AE850, // TrackElemType::Up25ToLeftBank - 0x008AE860, // TrackElemType::Up25ToRightBank - 0x008AE870, // TrackElemType::LeftBankToDown25 - 0x008AE880, // TrackElemType::RightBankToDown25 - 0x008AE890, // TrackElemType::Down25ToLeftBank - 0x008AE8A0, // TrackElemType::Down25ToRightBank - 0x008AE8B0, // TrackElemType::LeftBank - 0x008AE8C0, // TrackElemType::RightBank - 0x008AE8D0, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AE8E0, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AE8F0, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AE900, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AE910, // TrackElemType::SBendLeft - 0x008AE920, // TrackElemType::SBendRight - 0x008AE930, // TrackElemType::LeftVerticalLoop - 0x008AE940, // TrackElemType::RightVerticalLoop - 0x008AE980, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AE990, // TrackElemType::RightQuarterTurn3Tiles - 0x008AE9A0, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AE9B0, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AE9C0, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AE9D0, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AE9E0, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AE9F0, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0x008AEA00, // TrackElemType::LeftTwistDownToUp - 0x008AEA10, // TrackElemType::RightTwistDownToUp - 0x008AEA20, // TrackElemType::LeftTwistUpToDown - 0x008AEA30, // TrackElemType::RightTwistUpToDown - 0x008AEA40, // TrackElemType::HalfLoopUp - 0x008AEA50, // TrackElemType::HalfLoopDown - 0x008AEA60, // TrackElemType::LeftCorkscrewUp - 0x008AEA70, // TrackElemType::RightCorkscrewUp - 0x008AEA80, // TrackElemType::LeftCorkscrewDown - 0x008AEA90, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AEAD0, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008AEAB0, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008AEAC0, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008AEAE0, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008AEAA0, // TrackElemType::Brakes - 0, - 0, - 0x008AEAF0, // TrackElemType::LeftQuarterBankedHelixLargeUp - 0x008AEB00, // TrackElemType::RightQuarterBankedHelixLargeUp - 0x008AEB10, // TrackElemType::LeftQuarterBankedHelixLargeDown - 0x008AEB20, // TrackElemType::RightQuarterBankedHelixLargeDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AEB30, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AEDB0, // TrackElemType::Up90 - 0x008AEDC0, // TrackElemType::Down90 - 0x008AED70, // TrackElemType::Up60ToUp90 - 0x008AED80, // TrackElemType::Down90ToDown60 - 0x008AED90, // TrackElemType::Up90ToUp60 - 0x008AEDA0, // TrackElemType::Down60ToDown90 - 0, - 0x008AEB40, // TrackElemType::LeftEighthToDiag - 0x008AEB50, // TrackElemType::RightEighthToDiag - 0x008AEB60, // TrackElemType::LeftEighthToOrthogonal - 0x008AEB70, // TrackElemType::RightEighthToOrthogonal - 0x008AED30, // TrackElemType::LeftEighthBankToDiag - 0x008AED40, // TrackElemType::RightEighthBankToDiag - 0x008AED50, // TrackElemType::LeftEighthBankToOrthogonal - 0x008AED60, // TrackElemType::RightEighthBankToOrthogonal - 0x008AEB80, // TrackElemType::DiagFlat - 0x008AEBB0, // TrackElemType::DiagUp25 - 0x008AEC10, // TrackElemType::DiagUp60 - 0x008AEB90, // TrackElemType::DiagFlatToUp25 - 0x008AEBF0, // TrackElemType::DiagUp25ToUp60 - 0x008AEC00, // TrackElemType::DiagUp60ToUp25 - 0x008AEBA0, // TrackElemType::DiagUp25ToFlat - 0x008AEBE0, // TrackElemType::DiagDown25 - 0x008AEC40, // TrackElemType::DiagDown60 - 0x008AEBC0, // TrackElemType::DiagFlatToDown25 - 0x008AEC20, // TrackElemType::DiagDown25ToDown60 - 0x008AEC30, // TrackElemType::DiagDown60ToDown25 - 0x008AEBD0, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008AEC70, // TrackElemType::DiagFlatToLeftBank - 0x008AEC80, // TrackElemType::DiagFlatToRightBank - 0x008AEC90, // TrackElemType::DiagLeftBankToFlat - 0x008AECA0, // TrackElemType::DiagRightBankToFlat - 0x008AECD0, // TrackElemType::DiagLeftBankToUp25 - 0x008AECE0, // TrackElemType::DiagRightBankToUp25 - 0x008AECB0, // TrackElemType::DiagUp25ToLeftBank - 0x008AECC0, // TrackElemType::DiagUp25ToRightBank - 0x008AECF0, // TrackElemType::DiagLeftBankToDown25 - 0x008AED00, // TrackElemType::DiagRightBankToDown25 - 0x008AED10, // TrackElemType::DiagDown25ToLeftBank - 0x008AED20, // TrackElemType::DiagDown25ToRightBank - 0x008AEC50, // TrackElemType::DiagLeftBank - 0x008AEC60, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AEAA0, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AEDE0 */ -static constexpr const uint32_t _OldWaterCoasterTrackPaintFunctions[256] = { - 0x008AF154, // TrackElemType::Flat - 0x008AF2A4, // TrackElemType::EndStation - 0x008AF2B4, // TrackElemType::BeginStation - 0x008AF2C4, // TrackElemType::MiddleStation - 0x008AF164, // TrackElemType::Up25 - 0x008AF174, // TrackElemType::Up60 - 0x008AF184, // TrackElemType::FlatToUp25 - 0x008AF194, // TrackElemType::Up25ToUp60 - 0x008AF1A4, // TrackElemType::Up60ToUp25 - 0x008AF1B4, // TrackElemType::Up25ToFlat - 0x008AF1C4, // TrackElemType::Down25 - 0x008AF1D4, // TrackElemType::Down60 - 0x008AF1E4, // TrackElemType::FlatToDown25 - 0x008AF1F4, // TrackElemType::Down25ToDown60 - 0x008AF204, // TrackElemType::Down60ToDown25 - 0x008AF214, // TrackElemType::Down25ToFlat - 0x008AF224, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AF234, // TrackElemType::RightQuarterTurn5Tiles - 0x008AF454, // TrackElemType::FlatToLeftBank - 0x008AF464, // TrackElemType::FlatToRightBank - 0x008AF474, // TrackElemType::LeftBankToFlat - 0x008AF484, // TrackElemType::RightBankToFlat - 0x008AF494, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AF4A4, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008AF4B4, // TrackElemType::LeftBankToUp25 - 0x008AF4C4, // TrackElemType::RightBankToUp25 - 0x008AF4D4, // TrackElemType::Up25ToLeftBank - 0x008AF4E4, // TrackElemType::Up25ToRightBank - 0x008AF4F4, // TrackElemType::LeftBankToDown25 - 0x008AF504, // TrackElemType::RightBankToDown25 - 0x008AF514, // TrackElemType::Down25ToLeftBank - 0x008AF524, // TrackElemType::Down25ToRightBank - 0x008AF534, // TrackElemType::LeftBank - 0x008AF544, // TrackElemType::RightBank - 0x008AF244, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008AF254, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008AF264, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008AF274, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008AF284, // TrackElemType::SBendLeft - 0x008AF294, // TrackElemType::SBendRight - 0, - 0, - 0x008AF2D4, // TrackElemType::LeftQuarterTurn3Tiles - 0x008AF2E4, // TrackElemType::RightQuarterTurn3Tiles - 0x008AF554, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008AF564, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008AF2F4, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008AF304, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008AF314, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008AF324, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AF714, // TrackElemType::FlatCovered - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AF724, // TrackElemType::LeftQuarterTurn5TilesCovered - 0x008AF734, // TrackElemType::RightQuarterTurn5TilesCovered - 0, - 0, - 0, - 0, - 0x008AF574, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008AF584, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008AF594, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008AF5A4, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008AF5B4, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008AF5C4, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008AF5D4, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008AF5E4, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0x008AF334, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AF414, // TrackElemType::LeftEighthToDiag - 0x008AF424, // TrackElemType::RightEighthToDiag - 0x008AF434, // TrackElemType::LeftEighthToOrthogonal - 0x008AF444, // TrackElemType::RightEighthToOrthogonal - 0x008AF5F4, // TrackElemType::LeftEighthBankToDiag - 0x008AF604, // TrackElemType::RightEighthBankToDiag - 0x008AF614, // TrackElemType::LeftEighthBankToOrthogonal - 0x008AF624, // TrackElemType::RightEighthBankToOrthogonal - 0x008AF344, // TrackElemType::DiagFlat - 0x008AF374, // TrackElemType::DiagUp25 - 0x008AF3A4, // TrackElemType::DiagUp60 - 0x008AF354, // TrackElemType::DiagFlatToUp25 - 0x008AF384, // TrackElemType::DiagUp25ToUp60 - 0x008AF394, // TrackElemType::DiagUp60ToUp25 - 0x008AF364, // TrackElemType::DiagUp25ToFlat - 0x008AF3D4, // TrackElemType::DiagDown25 - 0x008AF404, // TrackElemType::DiagDown60 - 0x008AF3B4, // TrackElemType::DiagFlatToDown25 - 0x008AF3E4, // TrackElemType::DiagDown25ToDown60 - 0x008AF3F4, // TrackElemType::DiagDown60ToDown25 - 0x008AF3C4, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008AF654, // TrackElemType::DiagFlatToLeftBank - 0x008AF664, // TrackElemType::DiagFlatToRightBank - 0x008AF674, // TrackElemType::DiagLeftBankToFlat - 0x008AF684, // TrackElemType::DiagRightBankToFlat - 0x008AF6B4, // TrackElemType::DiagLeftBankToUp25 - 0x008AF6C4, // TrackElemType::DiagRightBankToUp25 - 0x008AF694, // TrackElemType::DiagUp25ToLeftBank - 0x008AF6A4, // TrackElemType::DiagUp25ToRightBank - 0x008AF6D4, // TrackElemType::DiagLeftBankToDown25 - 0x008AF6E4, // TrackElemType::DiagRightBankToDown25 - 0x008AF6F4, // TrackElemType::DiagDown25ToLeftBank - 0x008AF704, // TrackElemType::DiagDown25ToRightBank - 0x008AF634, // TrackElemType::DiagLeftBank - 0x008AF644, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AF744, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008AF764 */ -static constexpr const uint32_t _OldAirPoweredVerticalCoasterTrackPaintFunctions[256] = { - 0x008AFAD4, // TrackElemType::Flat - 0x008AFAE4, // TrackElemType::EndStation - 0x008AFAF4, // TrackElemType::BeginStation - 0x008AFB04, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFB54, // TrackElemType::LeftQuarterTurn5Tiles - 0x008AFB64, // TrackElemType::RightQuarterTurn5Tiles - 0x008AFB74, // TrackElemType::FlatToLeftBank - 0x008AFB84, // TrackElemType::FlatToRightBank - 0x008AFB94, // TrackElemType::LeftBankToFlat - 0x008AFBA4, // TrackElemType::RightBankToFlat - 0x008AFBB4, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008AFBC4, // TrackElemType::BankedRightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFBD4, // TrackElemType::LeftBank - 0x008AFBE4, // TrackElemType::RightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFC04, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFB14, // TrackElemType::ReverseFreefallSlope - 0x008AFB34, // TrackElemType::ReverseFreefallVertical - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008AFBF4, // TrackElemType::AirThrustTopCap - 0x008AFB44, // TrackElemType::AirThrustVerticalDown - 0x008AFB24, // TrackElemType::AirThrustVerticalDownToLevel - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00890940 */ -static constexpr const uint32_t _OldInvertedHairpinCoasterTrackPaintFunctions[256] = { - 0x00890CB4, // TrackElemType::Flat - 0x00890D84, // TrackElemType::EndStation - 0x00890D94, // TrackElemType::BeginStation - 0x00890DA4, // TrackElemType::MiddleStation - 0x00890CC4, // TrackElemType::Up25 - 0x00890CD4, // TrackElemType::Up60 - 0x00890CE4, // TrackElemType::FlatToUp25 - 0x00890CF4, // TrackElemType::Up25ToUp60 - 0x00890D04, // TrackElemType::Up60ToUp25 - 0x00890D14, // TrackElemType::Up25ToFlat - 0x00890D24, // TrackElemType::Down25 - 0x00890D34, // TrackElemType::Down60 - 0x00890D44, // TrackElemType::FlatToDown25 - 0x00890D54, // TrackElemType::Down25ToDown60 - 0x00890D64, // TrackElemType::Down60ToDown25 - 0x00890D74, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00890DB4, // TrackElemType::LeftQuarterTurn3Tiles - 0x00890DC4, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0x00890DD4, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x00890DE4, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x00890DF4, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x00890E04, // TrackElemType::RightQuarterTurn3TilesDown25 - 0x00890E64, // TrackElemType::LeftQuarterTurn1Tile - 0x00890E74, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00890E24, // TrackElemType::FlatToUp60 - 0x00890E34, // TrackElemType::Up60ToFlat - 0x00890E44, // TrackElemType::FlatToDown60 - 0x00890E54, // TrackElemType::Down60ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00890E14, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00890E84, // TrackElemType::BlockBrakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x00898384 */ -static constexpr const uint32_t _OldMagicCarpetTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x00898514, // 95 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008995D4 */ -static constexpr const uint32_t _OldSubmarineRideTrackPaintFunctions[256] = { - 0x008996B4, // TrackElemType::Flat - 0x008996C4, // TrackElemType::EndStation - 0x008996D4, // TrackElemType::BeginStation - 0x008996E4, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008996F4, // TrackElemType::LeftQuarterTurn3Tiles - 0x00899704, // TrackElemType::RightQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0x00899714, // TrackElemType::LeftQuarterTurn1Tile - 0x00899724, // TrackElemType::RightQuarterTurn1Tile - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x0089B0C0 */ -static constexpr const uint32_t _OldRiverRaftsTrackPaintFunctions[256] = { - 0x0089B170, // TrackElemType::Flat - 0x0089B1A0, // TrackElemType::EndStation - 0x0089B1B0, // TrackElemType::BeginStation - 0x0089B1C0, // TrackElemType::MiddleStation - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0089B1D0, // TrackElemType::LeftQuarterTurn5Tiles - 0x0089B1E0, // TrackElemType::RightQuarterTurn5Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x0089B180, // TrackElemType::SBendLeft - 0x0089B190, // TrackElemType::SBendRight - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A13B4 */ -static constexpr const uint32_t _OldEnterpriseTrackPaintFunctions[256] = { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A1584, // 111 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008B005C */ -static constexpr const uint32_t _OldInvertedImpulseCoasterTrackPaintFunctions[256] = { - 0x008B0460, // TrackElemType::Flat - 0x008B0470, // TrackElemType::EndStation - 0x008B0480, // TrackElemType::BeginStation - 0x008B0490, // TrackElemType::MiddleStation - 0x008B04A0, // TrackElemType::Up25 - 0x008B04B0, // TrackElemType::Up60 - 0x008B04C0, // TrackElemType::FlatToUp25 - 0x008B04D0, // TrackElemType::Up25ToUp60 - 0x008B04E0, // TrackElemType::Up60ToUp25 - 0x008B04F0, // TrackElemType::Up25ToFlat - 0x008B0500, // TrackElemType::Down25 - 0x008B0510, // TrackElemType::Down60 - 0x008B0520, // TrackElemType::FlatToDown25 - 0x008B0530, // TrackElemType::Down25ToDown60 - 0x008B0540, // TrackElemType::Down60ToDown25 - 0x008B0550, // TrackElemType::Down25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B05A0, // TrackElemType::Up90 - 0x008B05B0, // TrackElemType::Down90 - 0x008B0560, // TrackElemType::Up60ToUp90 - 0x008B0570, // TrackElemType::Down90ToDown60 - 0x008B0580, // TrackElemType::Up90ToUp60 - 0x008B0590, // TrackElemType::Down60ToDown90 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B05C0, // TrackElemType::LeftQuarterTurn1TileUp90 - 0x008B05D0, // TrackElemType::RightQuarterTurn1TileUp90 - 0x008B05E0, // TrackElemType::LeftQuarterTurn1TileDown90 - 0x008B05F0, // TrackElemType::RightQuarterTurn1TileDown90 - 0, - 0, - 0, -}; - -/** rct2: 0x008A46D8 */ -static constexpr const uint32_t _OldMiniRollerCoasterTrackPaintFunctions[256] = { - 0x008A4ABC, // TrackElemType::Flat - 0x008A4D0C, // TrackElemType::EndStation - 0x008A4D1C, // TrackElemType::BeginStation - 0x008A4D2C, // TrackElemType::MiddleStation - 0x008A4ACC, // TrackElemType::Up25 - 0x008A4ADC, // TrackElemType::Up60 - 0x008A4AEC, // TrackElemType::FlatToUp25 - 0x008A4AFC, // TrackElemType::Up25ToUp60 - 0x008A4B0C, // TrackElemType::Up60ToUp25 - 0x008A4B1C, // TrackElemType::Up25ToFlat - 0x008A4B2C, // TrackElemType::Down25 - 0x008A4B3C, // TrackElemType::Down60 - 0x008A4B4C, // TrackElemType::FlatToDown25 - 0x008A4B5C, // TrackElemType::Down25ToDown60 - 0x008A4B6C, // TrackElemType::Down60ToDown25 - 0x008A4B7C, // TrackElemType::Down25ToFlat - 0x008A4B8C, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A4B9C, // TrackElemType::RightQuarterTurn5Tiles - 0x008A4BAC, // TrackElemType::FlatToLeftBank - 0x008A4BBC, // TrackElemType::FlatToRightBank - 0x008A4BCC, // TrackElemType::LeftBankToFlat - 0x008A4BDC, // TrackElemType::RightBankToFlat - 0x008A4BEC, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A4BFC, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A4C0C, // TrackElemType::LeftBankToUp25 - 0x008A4C1C, // TrackElemType::RightBankToUp25 - 0x008A4C2C, // TrackElemType::Up25ToLeftBank - 0x008A4C3C, // TrackElemType::Up25ToRightBank - 0x008A4C4C, // TrackElemType::LeftBankToDown25 - 0x008A4C5C, // TrackElemType::RightBankToDown25 - 0x008A4C6C, // TrackElemType::Down25ToLeftBank - 0x008A4C7C, // TrackElemType::Down25ToRightBank - 0x008A4C8C, // TrackElemType::LeftBank - 0x008A4C9C, // TrackElemType::RightBank - 0x008A4CAC, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A4CBC, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A4CCC, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A4CDC, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A4CEC, // TrackElemType::SBendLeft - 0x008A4CFC, // TrackElemType::SBendRight - 0, - 0, - 0x008A4D3C, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A4D4C, // TrackElemType::RightQuarterTurn3Tiles - 0x008A4D5C, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A4D6C, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A4D7C, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A4D8C, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A4D9C, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A4DAC, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A4DBC, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A4DCC, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A4DDC, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A4DEC, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A4DFC, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A4E0C, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A4E1C, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A4E2C, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008A4E5C, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A4E3C, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A4E4C, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A4E6C, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A4E7C, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A50CC, // TrackElemType::Up25LeftBanked - 0x008A50DC, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008A4E8C, // TrackElemType::OnRidePhoto - 0x008A50EC, // TrackElemType::Down25LeftBanked - 0x008A50FC, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A4EAC, // TrackElemType::LeftEighthToDiag - 0x008A4EBC, // TrackElemType::RightEighthToDiag - 0x008A4ECC, // TrackElemType::LeftEighthToOrthogonal - 0x008A4EDC, // TrackElemType::RightEighthToOrthogonal - 0x008A4EEC, // TrackElemType::LeftEighthBankToDiag - 0x008A4EFC, // TrackElemType::RightEighthBankToDiag - 0x008A4F0C, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A4F1C, // TrackElemType::RightEighthBankToOrthogonal - 0x008A4E9C, // TrackElemType::DiagFlat - 0x008A4F4C, // TrackElemType::DiagUp25 - 0x008A4FAC, // TrackElemType::DiagUp60 - 0x008A4F2C, // TrackElemType::DiagFlatToUp25 - 0x008A4F8C, // TrackElemType::DiagUp25ToUp60 - 0x008A4F9C, // TrackElemType::DiagUp60ToUp25 - 0x008A4F3C, // TrackElemType::DiagUp25ToFlat - 0x008A4F7C, // TrackElemType::DiagDown25 - 0x008A4FDC, // TrackElemType::DiagDown60 - 0x008A4F5C, // TrackElemType::DiagFlatToDown25 - 0x008A4FBC, // TrackElemType::DiagDown25ToDown60 - 0x008A4FCC, // TrackElemType::DiagDown60ToDown25 - 0x008A4F6C, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A500C, // TrackElemType::DiagFlatToLeftBank - 0x008A501C, // TrackElemType::DiagFlatToRightBank - 0x008A502C, // TrackElemType::DiagLeftBankToFlat - 0x008A503C, // TrackElemType::DiagRightBankToFlat - 0x008A506C, // TrackElemType::DiagLeftBankToUp25 - 0x008A507C, // TrackElemType::DiagRightBankToUp25 - 0x008A504C, // TrackElemType::DiagUp25ToLeftBank - 0x008A505C, // TrackElemType::DiagUp25ToRightBank - 0x008A508C, // TrackElemType::DiagLeftBankToDown25 - 0x008A509C, // TrackElemType::DiagRightBankToDown25 - 0x008A50AC, // TrackElemType::DiagDown25ToLeftBank - 0x008A50BC, // TrackElemType::DiagDown25ToRightBank - 0x008A4FEC, // TrackElemType::DiagLeftBank - 0x008A4FFC, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A530C, // TrackElemType::BlockBrakes - 0x008A510C, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008A511C, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008A512C, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008A513C, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008A514C, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008A515C, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008A516C, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008A517C, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008A518C, // TrackElemType::Up25ToLeftBankedUp25 - 0x008A519C, // TrackElemType::Up25ToRightBankedUp25 - 0x008A51AC, // TrackElemType::LeftBankedUp25ToUp25 - 0x008A51BC, // TrackElemType::RightBankedUp25ToUp25 - 0x008A51CC, // TrackElemType::Down25ToLeftBankedDown25 - 0x008A51DC, // TrackElemType::Down25ToRightBankedDown25 - 0x008A51EC, // TrackElemType::LeftBankedDown25ToDown25 - 0x008A51FC, // TrackElemType::RightBankedDown25ToDown25 - 0x008A520C, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008A521C, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008A524C, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008A525C, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008A526C, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008A527C, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008A522C, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008A523C, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008A528C, // TrackElemType::FlatToLeftBankedUp25 - 0x008A529C, // TrackElemType::FlatToRightBankedUp25 - 0x008A52AC, // TrackElemType::LeftBankedUp25ToFlat - 0x008A52BC, // TrackElemType::RightBankedUp25ToFlat - 0x008A52CC, // TrackElemType::FlatToLeftBankedDown25 - 0x008A52DC, // TrackElemType::FlatToRightBankedDown25 - 0x008A52EC, // TrackElemType::LeftBankedDown25ToFlat - 0x008A52FC, // TrackElemType::RightBankedDown25ToFlat - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008B0610 */ -static constexpr const uint32_t _OldMineRideTrackPaintFunctions[256] = { - 0x008B08D0, // TrackElemType::Flat - 0x008B0A80, // TrackElemType::EndStation - 0x008B0A90, // TrackElemType::BeginStation - 0x008B0AA0, // TrackElemType::MiddleStation - 0x008B08E0, // TrackElemType::Up25 - 0, - 0x008B08F0, // TrackElemType::FlatToUp25 - 0, - 0, - 0x008B0900, // TrackElemType::Up25ToFlat - 0x008B0910, // TrackElemType::Down25 - 0, - 0x008B0920, // TrackElemType::FlatToDown25 - 0, - 0, - 0x008B0930, // TrackElemType::Down25ToFlat - 0x008B0940, // TrackElemType::LeftQuarterTurn5Tiles - 0x008B0950, // TrackElemType::RightQuarterTurn5Tiles - 0x008B0960, // TrackElemType::FlatToLeftBank - 0x008B0970, // TrackElemType::FlatToRightBank - 0x008B0980, // TrackElemType::LeftBankToFlat - 0x008B0990, // TrackElemType::RightBankToFlat - 0x008B09A0, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008B09B0, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008B09C0, // TrackElemType::LeftBankToUp25 - 0x008B09D0, // TrackElemType::RightBankToUp25 - 0x008B09E0, // TrackElemType::Up25ToLeftBank - 0x008B09F0, // TrackElemType::Up25ToRightBank - 0x008B0A00, // TrackElemType::LeftBankToDown25 - 0x008B0A10, // TrackElemType::RightBankToDown25 - 0x008B0A20, // TrackElemType::Down25ToLeftBank - 0x008B0A30, // TrackElemType::Down25ToRightBank - 0x008B0A40, // TrackElemType::LeftBank - 0x008B0A50, // TrackElemType::RightBank - 0, - 0, - 0, - 0, - 0x008B0A60, // TrackElemType::SBendLeft - 0x008B0A70, // TrackElemType::SBendRight - 0, - 0, - 0x008B0AB0, // TrackElemType::LeftQuarterTurn3Tiles - 0x008B0AC0, // TrackElemType::RightQuarterTurn3Tiles - 0x008B0AD0, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008B0AE0, // TrackElemType::RightBankedQuarterTurn3Tiles - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B0AF0, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008B0B00, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008B0B10, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008B0B20, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008B0B30, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008B0B40, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008B0B50, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008B0B60, // TrackElemType::RightHalfBankedHelixDownLarge - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B0B70, // TrackElemType::OnRidePhoto - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008B0B90, // TrackElemType::LeftEighthToDiag - 0x008B0BA0, // TrackElemType::RightEighthToDiag - 0x008B0BB0, // TrackElemType::LeftEighthToOrthogonal - 0x008B0BC0, // TrackElemType::RightEighthToOrthogonal - 0x008B0BD0, // TrackElemType::LeftEighthBankToDiag - 0x008B0BE0, // TrackElemType::RightEighthBankToDiag - 0x008B0BF0, // TrackElemType::LeftEighthBankToOrthogonal - 0x008B0C00, // TrackElemType::RightEighthBankToOrthogonal - 0x008B0B80, // TrackElemType::DiagFlat - 0x008B0C30, // TrackElemType::DiagUp25 - 0, - 0x008B0C10, // TrackElemType::DiagFlatToUp25 - 0, - 0, - 0x008B0C20, // TrackElemType::DiagUp25ToFlat - 0x008B0C60, // TrackElemType::DiagDown25 - 0, - 0x008B0C40, // TrackElemType::DiagFlatToDown25 - 0, - 0, - 0x008B0C50, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008B0C90, // TrackElemType::DiagFlatToLeftBank - 0x008B0CA0, // TrackElemType::DiagFlatToRightBank - 0x008B0CB0, // TrackElemType::DiagLeftBankToFlat - 0x008B0CC0, // TrackElemType::DiagRightBankToFlat - 0x008B0CF0, // TrackElemType::DiagLeftBankToUp25 - 0x008B0D00, // TrackElemType::DiagRightBankToUp25 - 0x008B0CD0, // TrackElemType::DiagUp25ToLeftBank - 0x008B0CE0, // TrackElemType::DiagUp25ToRightBank - 0x008B0D10, // TrackElemType::DiagLeftBankToDown25 - 0x008B0D20, // TrackElemType::DiagRightBankToDown25 - 0x008B0D30, // TrackElemType::DiagDown25ToLeftBank - 0x008B0D40, // TrackElemType::DiagDown25ToRightBank - 0x008B0C70, // TrackElemType::DiagLeftBank - 0x008B0C80, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -}; - -/** rct2: 0x008A5F6C */ -static constexpr const uint32_t _OldLimLaunchedRollerCoasterTrackPaintFunctions[256] = { - 0x008A6370, // TrackElemType::Flat - 0x008A6D50, // TrackElemType::EndStation - 0x008A6D60, // TrackElemType::BeginStation - 0x008A6D70, // TrackElemType::MiddleStation - 0x008A6380, // TrackElemType::Up25 - 0x008A6390, // TrackElemType::Up60 - 0x008A63A0, // TrackElemType::FlatToUp25 - 0x008A63B0, // TrackElemType::Up25ToUp60 - 0x008A63C0, // TrackElemType::Up60ToUp25 - 0x008A63D0, // TrackElemType::Up25ToFlat - 0x008A63E0, // TrackElemType::Down25 - 0x008A63F0, // TrackElemType::Down60 - 0x008A6400, // TrackElemType::FlatToDown25 - 0x008A6410, // TrackElemType::Down25ToDown60 - 0x008A6420, // TrackElemType::Down60ToDown25 - 0x008A6430, // TrackElemType::Down25ToFlat - 0x008A6440, // TrackElemType::LeftQuarterTurn5Tiles - 0x008A6450, // TrackElemType::RightQuarterTurn5Tiles - 0x008A6460, // TrackElemType::FlatToLeftBank - 0x008A6470, // TrackElemType::FlatToRightBank - 0x008A6480, // TrackElemType::LeftBankToFlat - 0x008A6490, // TrackElemType::RightBankToFlat - 0x008A64A0, // TrackElemType::BankedLeftQuarterTurn5Tiles - 0x008A64B0, // TrackElemType::BankedRightQuarterTurn5Tiles - 0x008A64C0, // TrackElemType::LeftBankToUp25 - 0x008A64D0, // TrackElemType::RightBankToUp25 - 0x008A64E0, // TrackElemType::Up25ToLeftBank - 0x008A64F0, // TrackElemType::Up25ToRightBank - 0x008A6500, // TrackElemType::LeftBankToDown25 - 0x008A6510, // TrackElemType::RightBankToDown25 - 0x008A6520, // TrackElemType::Down25ToLeftBank - 0x008A6530, // TrackElemType::Down25ToRightBank - 0x008A6540, // TrackElemType::LeftBank - 0x008A6550, // TrackElemType::RightBank - 0x008A6560, // TrackElemType::LeftQuarterTurn5TilesUp25 - 0x008A6570, // TrackElemType::RightQuarterTurn5TilesUp25 - 0x008A6580, // TrackElemType::LeftQuarterTurn5TilesDown25 - 0x008A6590, // TrackElemType::RightQuarterTurn5TilesDown25 - 0x008A65A0, // TrackElemType::SBendLeft - 0x008A65B0, // TrackElemType::SBendRight - 0x008A65E0, // TrackElemType::LeftVerticalLoop - 0x008A65F0, // TrackElemType::RightVerticalLoop - 0x008A6630, // TrackElemType::LeftQuarterTurn3Tiles - 0x008A6640, // TrackElemType::RightQuarterTurn3Tiles - 0x008A6650, // TrackElemType::LeftBankedQuarterTurn3Tiles - 0x008A6660, // TrackElemType::RightBankedQuarterTurn3Tiles - 0x008A6670, // TrackElemType::LeftQuarterTurn3TilesUp25 - 0x008A6680, // TrackElemType::RightQuarterTurn3TilesUp25 - 0x008A6690, // TrackElemType::LeftQuarterTurn3TilesDown25 - 0x008A66A0, // TrackElemType::RightQuarterTurn3TilesDown25 - 0, - 0, - 0x008A6D10, // TrackElemType::LeftTwistDownToUp - 0x008A6D20, // TrackElemType::RightTwistDownToUp - 0x008A6D30, // TrackElemType::LeftTwistUpToDown - 0x008A6D40, // TrackElemType::RightTwistUpToDown - 0, - 0, - 0x008A6CD0, // TrackElemType::LeftCorkscrewUp - 0x008A6CE0, // TrackElemType::RightCorkscrewUp - 0x008A6CF0, // TrackElemType::LeftCorkscrewDown - 0x008A6D00, // TrackElemType::RightCorkscrewDown - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A66B0, // TrackElemType::LeftHalfBankedHelixUpSmall - 0x008A66C0, // TrackElemType::RightHalfBankedHelixUpSmall - 0x008A66D0, // TrackElemType::LeftHalfBankedHelixDownSmall - 0x008A66E0, // TrackElemType::RightHalfBankedHelixDownSmall - 0x008A66F0, // TrackElemType::LeftHalfBankedHelixUpLarge - 0x008A6700, // TrackElemType::RightHalfBankedHelixUpLarge - 0x008A6710, // TrackElemType::LeftHalfBankedHelixDownLarge - 0x008A6720, // TrackElemType::RightHalfBankedHelixDownLarge - 0x008A6750, // TrackElemType::LeftQuarterTurn1TileUp60 - 0x008A6730, // TrackElemType::RightQuarterTurn1TileUp60 - 0x008A6740, // TrackElemType::LeftQuarterTurn1TileDown60 - 0x008A6760, // TrackElemType::RightQuarterTurn1TileDown60 - 0x008A6D80, // TrackElemType::Brakes - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6A40, // TrackElemType::Up25LeftBanked - 0x008A6A50, // TrackElemType::Up25RightBanked - 0, - 0, - 0x008A6780, // TrackElemType::OnRidePhoto - 0x008A6A60, // TrackElemType::Down25LeftBanked - 0x008A6A70, // TrackElemType::Down25RightBanked - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6C10, // TrackElemType::Up90 - 0x008A6C20, // TrackElemType::Down90 - 0x008A6C30, // TrackElemType::Up60ToUp90 - 0x008A6C40, // TrackElemType::Down90ToDown60 - 0x008A6C50, // TrackElemType::Up90ToUp60 - 0x008A6C60, // TrackElemType::Down60ToDown90 - 0, - 0x008A6860, // TrackElemType::LeftEighthToDiag - 0x008A6870, // TrackElemType::RightEighthToDiag - 0x008A6880, // TrackElemType::LeftEighthToOrthogonal - 0x008A6890, // TrackElemType::RightEighthToOrthogonal - 0x008A68A0, // TrackElemType::LeftEighthBankToDiag - 0x008A68B0, // TrackElemType::RightEighthBankToDiag - 0x008A68C0, // TrackElemType::LeftEighthBankToOrthogonal - 0x008A68D0, // TrackElemType::RightEighthBankToOrthogonal - 0x008A6790, // TrackElemType::DiagFlat - 0x008A67C0, // TrackElemType::DiagUp25 - 0x008A67F0, // TrackElemType::DiagUp60 - 0x008A67A0, // TrackElemType::DiagFlatToUp25 - 0x008A67D0, // TrackElemType::DiagUp25ToUp60 - 0x008A67E0, // TrackElemType::DiagUp60ToUp25 - 0x008A67B0, // TrackElemType::DiagUp25ToFlat - 0x008A6820, // TrackElemType::DiagDown25 - 0x008A6850, // TrackElemType::DiagDown60 - 0x008A6800, // TrackElemType::DiagFlatToDown25 - 0x008A6830, // TrackElemType::DiagDown25ToDown60 - 0x008A6840, // TrackElemType::DiagDown60ToDown25 - 0x008A6810, // TrackElemType::DiagDown25ToFlat - 0, - 0, - 0, - 0, - 0x008A6900, // TrackElemType::DiagFlatToLeftBank - 0x008A6910, // TrackElemType::DiagFlatToRightBank - 0x008A6920, // TrackElemType::DiagLeftBankToFlat - 0x008A6930, // TrackElemType::DiagRightBankToFlat - 0x008A6960, // TrackElemType::DiagLeftBankToUp25 - 0x008A6970, // TrackElemType::DiagRightBankToUp25 - 0x008A6940, // TrackElemType::DiagUp25ToLeftBank - 0x008A6950, // TrackElemType::DiagUp25ToRightBank - 0x008A6980, // TrackElemType::DiagLeftBankToDown25 - 0x008A6990, // TrackElemType::DiagRightBankToDown25 - 0x008A69A0, // TrackElemType::DiagDown25ToLeftBank - 0x008A69B0, // TrackElemType::DiagDown25ToRightBank - 0x008A68E0, // TrackElemType::DiagLeftBank - 0x008A68F0, // TrackElemType::DiagRightBank - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6C70, // TrackElemType::Up90ToInvertedFlatQuarterLoop - 0x008A6C80, // TrackElemType::InvertedFlatToDown90QuarterLoop - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0x008A6D90, // TrackElemType::BlockBrakes - 0x008A6BC0, // TrackElemType::LeftBankedQuarterTurn3TileUp25 - 0x008A6BD0, // TrackElemType::RightBankedQuarterTurn3TileUp25 - 0x008A6BE0, // TrackElemType::LeftBankedQuarterTurn3TileDown25 - 0x008A6BF0, // TrackElemType::RightBankedQuarterTurn3TileDown25 - 0x008A6B80, // TrackElemType::LeftBankedQuarterTurn5TileUp25 - 0x008A6B90, // TrackElemType::RightBankedQuarterTurn5TileUp25 - 0x008A6BA0, // TrackElemType::LeftBankedQuarterTurn5TileDown25 - 0x008A6BB0, // TrackElemType::RightBankedQuarterTurn5TileDown25 - 0x008A6A80, // TrackElemType::Up25ToLeftBankedUp25 - 0x008A6A90, // TrackElemType::Up25ToRightBankedUp25 - 0x008A6AA0, // TrackElemType::LeftBankedUp25ToUp25 - 0x008A6AB0, // TrackElemType::RightBankedUp25ToUp25 - 0x008A6AC0, // TrackElemType::Down25ToLeftBankedDown25 - 0x008A6AD0, // TrackElemType::Down25ToRightBankedDown25 - 0x008A6AE0, // TrackElemType::LeftBankedDown25ToDown25 - 0x008A6AF0, // TrackElemType::RightBankedDown25ToDown25 - 0x008A6B00, // TrackElemType::LeftBankedFlatToLeftBankedUp25 - 0x008A6B10, // TrackElemType::RightBankedFlatToRightBankedUp25 - 0x008A6B40, // TrackElemType::LeftBankedUp25ToLeftBankedFlat - 0x008A6B50, // TrackElemType::RightBankedUp25ToRightBankedFlat - 0x008A6B60, // TrackElemType::LeftBankedFlatToLeftBankedDown25 - 0x008A6B70, // TrackElemType::RightBankedFlatToRightBankedDown25 - 0x008A6B20, // TrackElemType::LeftBankedDown25ToLeftBankedFlat - 0x008A6B30, // TrackElemType::RightBankedDown25ToRightBankedFlat - 0x008A69C0, // TrackElemType::FlatToLeftBankedUp25 - 0x008A69D0, // TrackElemType::FlatToRightBankedUp25 - 0x008A69E0, // TrackElemType::LeftBankedUp25ToFlat - 0x008A69F0, // TrackElemType::RightBankedUp25ToFlat - 0x008A6A00, // TrackElemType::FlatToLeftBankedDown25 - 0x008A6A10, // TrackElemType::FlatToRightBankedDown25 - 0x008A6A20, // TrackElemType::LeftBankedDown25ToFlat - 0x008A6A30, // TrackElemType::RightBankedDown25ToFlat - 0x008A6C90, // TrackElemType::LeftQuarterTurn1TileUp90 - 0x008A6CA0, // TrackElemType::RightQuarterTurn1TileUp90 - 0x008A6CB0, // TrackElemType::LeftQuarterTurn1TileDown90 - 0x008A6CC0, // TrackElemType::RightQuarterTurn1TileDown90 - 0, - 0, - 0, -}; - -static constexpr const uint32_t _null[256] = {0}; - -const uint32_t * RideTypeTrackPaintFunctionsOld[RCT2_RIDE_TYPE_COUNT] = { - _OldSpiralRollerCoasterTrackPaintFunctions, // RIDE_TYPE_SPIRAL_ROLLER_COASTER - _OldStandUpRollerCoasterTrackPaintFunctions, // RIDE_TYPE_STAND_UP_ROLLER_COASTER - _OldSuspendedSwingingCoasterTrackPaintFunctions, // RIDE_TYPE_SUSPENDED_SWINGING_COASTER - _OldInvertedRollerCoasterTrackPaintFunctions, // RIDE_TYPE_INVERTED_ROLLER_COASTER - _OldJuniorRollerCoasterTrackPaintFunctions, // RIDE_TYPE_JUNIOR_ROLLER_COASTER - _OldMiniatureRailwayTrackPaintFunctions, // RIDE_TYPE_MINIATURE_RAILWAY - _OldMonorailTrackPaintFunctions, // RIDE_TYPE_MONORAIL - _OldMiniSuspendedCoasterTrackPaintFunctions, // RIDE_TYPE_MINI_SUSPENDED_COASTER - _OldBoatHireTrackPaintFunctions, // RIDE_TYPE_BOAT_HIRE - _OldWoodenWildMouseTrackPaintFunctions, // RIDE_TYPE_WOODEN_WILD_MOUSE - _OldSteeplechaseTrackPaintFunctions, // RIDE_TYPE_STEEPLECHASE - _OldCarRideTrackPaintFunctions, // RIDE_TYPE_CAR_RIDE - _OldLaunchedFreefallTrackPaintFunctions, // RIDE_TYPE_LAUNCHED_FREEFALL - _OldBobsleighCoasterTrackPaintFunctions, // RIDE_TYPE_BOBSLEIGH_COASTER - _OldObservationTowerTrackPaintFunctions, // RIDE_TYPE_OBSERVATION_TOWER - _OldLoopingRollerCoasterTrackPaintFunctions, // RIDE_TYPE_LOOPING_ROLLER_COASTER - _OldDinghySlideTrackPaintFunctions, // RIDE_TYPE_DINGHY_SLIDE - _OldMineTrainCoasterTrackPaintFunctions, // RIDE_TYPE_MINE_TRAIN_COASTER - _OldChairliftTrackPaintFunctions, // RIDE_TYPE_CHAIRLIFT - _OldCorkscrewRollerCoasterTrackPaintFunctions, // RIDE_TYPE_CORKSCREW_ROLLER_COASTER - _OldMazeTrackPaintFunctions, // RIDE_TYPE_MAZE - _OldSpiralSlideTrackPaintFunctions, // RIDE_TYPE_SPIRAL_SLIDE - _OldGoKartsTrackPaintFunctions, // RIDE_TYPE_GO_KARTS - _OldLogFlumeTrackPaintFunctions, // RIDE_TYPE_LOG_FLUME - _OldRiverRapidsTrackPaintFunctions, // RIDE_TYPE_RIVER_RAPIDS - _OldDodgemsTrackPaintFunctions, // RIDE_TYPE_DODGEMS - _OldSwingingShipTrackPaintFunctions, // RIDE_TYPE_SWINGING_SHIP - _OldSwingingInverterShipTrackPaintFunctions, // RIDE_TYPE_SWINGING_INVERTER_SHIP - _OldShopTrackPaintFunctions, // RIDE_TYPE_FOOD_STALL - _OldShopTrackPaintFunctions, // RIDE_TYPE_1D - _OldShopTrackPaintFunctions, // RIDE_TYPE_DRINK_STALL - _OldShopTrackPaintFunctions, // RIDE_TYPE_1F - _OldShopTrackPaintFunctions, // RIDE_TYPE_SHOP - _OldMerryGoRoundTrackPaintFunctions, // RIDE_TYPE_MERRY_GO_ROUND - _OldShopTrackPaintFunctions, // RIDE_TYPE_22 - _OldShopTrackPaintFunctions, // RIDE_TYPE_INFORMATION_KIOSK - _OldFacilityTrackPaintFunctions, // RIDE_TYPE_TOILETS - _OldFerrisWheelTrackPaintFunctions, // RIDE_TYPE_FERRIS_WHEEL - _OldMotionSimulatorTrackPaintFunctions, // RIDE_TYPE_MOTION_SIMULATOR - _Old3DCinemaTrackPaintFunctions, // RIDE_TYPE_3D_CINEMA - _OldTopSpinTrackPaintFunctions, // RIDE_TYPE_TOP_SPIN - _OldSpaceRingsTrackPaintFunctions, // RIDE_TYPE_SPACE_RINGS - _OldReverseFreefallCoasterTrackPaintFunctions, // RIDE_TYPE_REVERSE_FREEFALL_COASTER - _OldLiftTrackPaintFunctions, // RIDE_TYPE_LIFT - _OldVerticalDropRollerCoasterTrackPaintFunctions, // RIDE_TYPE_VERTICAL_DROP_ROLLER_COASTER - _OldShopTrackPaintFunctions, // RIDE_TYPE_CASH_MACHINE - _OldTwistTrackPaintFunctions, // RIDE_TYPE_TWIST - _OldHauntedHouseTrackPaintFunctions, // RIDE_TYPE_HAUNTED_HOUSE - _OldFacilityTrackPaintFunctions, // RIDE_TYPE_FIRST_AID - _OldCircusTrackPaintFunctions, // RIDE_TYPE_CIRCUS - _OldGhostTrainTrackPaintFunctions, // RIDE_TYPE_GHOST_TRAIN - _OldTwisterRollerCoasterTrackPaintFunctions, // RIDE_TYPE_TWISTER_ROLLER_COASTER - _OldWoodenRollerCoasterTrackPaintFunctions, // RIDE_TYPE_WOODEN_ROLLER_COASTER - _OldSideFrictionRollerCoasterTrackPaintFunctions, // RIDE_TYPE_SIDE_FRICTION_ROLLER_COASTER - _OldWildMouseTrackPaintFunctions, // RIDE_TYPE_STEEL_WILD_MOUSE - _OldMultiDimensionRollerCoasterTrackPaintFunctions, // RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER - _OldMultiDimensionRollerCoasterTrackPaintFunctions, // RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER_ALT - _OldFlyingRollerCoasterTrackPaintFunctions, // RIDE_TYPE_FLYING_ROLLER_COASTER - _OldFlyingRollerCoasterTrackPaintFunctions, // RIDE_TYPE_FLYING_ROLLER_COASTER_ALT - _OldVirginiaReelTrackPaintFunctions, // RIDE_TYPE_VIRGINIA_REEL - _OldSplashBoatsTrackPaintFunctions, // RIDE_TYPE_SPLASH_BOATS - _OldMiniHelicoptersTrackPaintFunctions, // RIDE_TYPE_MINI_HELICOPTERS - _OldLayDownRollerCoasterTrackPaintFunctions, // RIDE_TYPE_LAY_DOWN_ROLLER_COASTER - _OldSuspendedMonorailTrackPaintFunctions, // RIDE_TYPE_SUSPENDED_MONORAIL - _OldLayDownRollerCoasterTrackPaintFunctions, // RIDE_TYPE_LAY_DOWN_ROLLER_COASTER_ALT - _OldReverserRollerCoasterTrackPaintFunctions, // RIDE_TYPE_REVERSER_ROLLER_COASTER - _OldHeartlineTwisterCoasterTrackPaintFunctions, // RIDE_TYPE_HEARTLINE_TWISTER_COASTER - _OldMiniGolfTrackPaintFunctions, // RIDE_TYPE_MINI_GOLF - _OldGigaCoasterTrackPaintFunctions, // RIDE_TYPE_GIGA_COASTER - _OldRoToDropTrackPaintFunctions, // RIDE_TYPE_ROTO_DROP - _OldFlyingSaucersTrackPaintFunctions, // RIDE_TYPE_FLYING_SAUCERS - _OldCrookedHouseTrackPaintFunctions, // RIDE_TYPE_CROOKED_HOUSE - _OldMonorailCyclesTrackPaintFunctions, // RIDE_TYPE_MONORAIL_CYCLES - _OldCompactInvertedCoasterTrackPaintFunctions, // RIDE_TYPE_COMPACT_INVERTED_COASTER - _OldWaterCoasterTrackPaintFunctions, // RIDE_TYPE_WATER_COASTER - _OldAirPoweredVerticalCoasterTrackPaintFunctions, // RIDE_TYPE_AIR_POWERED_VERTICAL_COASTER - _OldInvertedHairpinCoasterTrackPaintFunctions, // RIDE_TYPE_INVERTED_HAIRPIN_COASTER - _OldMagicCarpetTrackPaintFunctions, // RIDE_TYPE_MAGIC_CARPET - _OldSubmarineRideTrackPaintFunctions, // RIDE_TYPE_SUBMARINE_RIDE - _OldRiverRaftsTrackPaintFunctions, // RIDE_TYPE_RIVER_RAFTS - _OldShopTrackPaintFunctions, // RIDE_TYPE_50 - _OldEnterpriseTrackPaintFunctions, // RIDE_TYPE_ENTERPRISE - _OldShopTrackPaintFunctions, // RIDE_TYPE_52 - _OldShopTrackPaintFunctions, // RIDE_TYPE_53 - _OldShopTrackPaintFunctions, // RIDE_TYPE_54 - _null, // RIDE_TYPE_55 - _OldInvertedImpulseCoasterTrackPaintFunctions, // RIDE_TYPE_INVERTED_IMPULSE_COASTER - _OldMiniRollerCoasterTrackPaintFunctions, // RIDE_TYPE_MINI_ROLLER_COASTER - _OldMineRideTrackPaintFunctions, // RIDE_TYPE_MINE_RIDE - _null, // RIDE_TYPE_59 - _OldLimLaunchedRollerCoasterTrackPaintFunctions, // RIDE_TYPE_LIM_LAUNCHED_ROLLER_COASTER -}; -//clang-format on diff --git a/test/testpaint/Utils.cpp b/test/testpaint/Utils.cpp deleted file mode 100644 index 2a5a16e402..0000000000 --- a/test/testpaint/Utils.cpp +++ /dev/null @@ -1,65 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "Utils.hpp" - -#include "Data.h" - -#include -#include -#include -#include - -namespace Utils -{ - int getTrackSequenceCount(uint8_t rideType, uint8_t trackType) - { - int sequenceCount = 0; - - for (int i = 0; i < 256; i++) - { - if (TrackBlocks[trackType][i].index == 0xFF) - { - break; - } - - sequenceCount++; - } - - return sequenceCount; - } - - bool rideSupportsTrackType(uint8_t rideType, uint8_t trackType) - { - TRACK_PAINT_FUNCTION_GETTER newPaintGetter = GetRideTypeDescriptor(rideType).TrackPaintFunction; - - if (newPaintGetter == nullptr) - { - return false; - } - - if (newPaintGetter(trackType) == nullptr) - { - return false; - } - - if (RideTypeTrackPaintFunctionsOld[rideType][trackType] == 0) - { - return false; - } - - return true; - } - - bool rideIsImplemented(uint8_t rideType) - { - TRACK_PAINT_FUNCTION_GETTER newPaintGetter = GetRideTypeDescriptor(rideType).TrackPaintFunction; - return (newPaintGetter != 0); - } -} // namespace Utils diff --git a/test/testpaint/Utils.hpp b/test/testpaint/Utils.hpp deleted file mode 100644 index 80797948bd..0000000000 --- a/test/testpaint/Utils.hpp +++ /dev/null @@ -1,19 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include - -namespace Utils -{ - int getTrackSequenceCount(uint8_t rideType, uint8_t trackType); - bool rideSupportsTrackType(uint8_t rideType, uint8_t trackType); - bool rideIsImplemented(uint8_t rideType); -} // namespace Utils diff --git a/test/testpaint/VerticalTunnelCall.cpp b/test/testpaint/VerticalTunnelCall.cpp deleted file mode 100644 index 030b3ee87c..0000000000 --- a/test/testpaint/VerticalTunnelCall.cpp +++ /dev/null @@ -1,44 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "VerticalTunnelCall.hpp" - -uint16_t VerticalTunnelCall::GetTunnelHeight(uint16_t baseHeight, uint8_t* calls) -{ - if (calls[0] == 0 && calls[1] == 0 && calls[2] == 0) - { - return 0; - } - - for (int16_t offset = 0; offset <= 256; offset += 8) - { - if (calls[0] != (baseHeight - 8 + offset) / 16) - continue; - if (calls[1] != (baseHeight + 0 + offset) / 16) - continue; - if (calls[2] != (baseHeight + 8 + offset) / 16) - continue; - - return baseHeight + offset; - } - - log_error("Unknown tunnel height. (%d, %d, %d)", calls[0], calls[1], calls[2]); - return 0; -} - -bool VerticalTunnelCall::HeightIsConsistent(uint16_t* heights) -{ - for (int i = 1; i < 4; ++i) - { - if (heights[i] != heights[0]) - return false; - } - - return true; -} diff --git a/test/testpaint/VerticalTunnelCall.hpp b/test/testpaint/VerticalTunnelCall.hpp deleted file mode 100644 index a035576d6e..0000000000 --- a/test/testpaint/VerticalTunnelCall.hpp +++ /dev/null @@ -1,18 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#pragma once - -#include - -namespace VerticalTunnelCall -{ - uint16_t GetTunnelHeight(uint16_t baseHeight, uint8_t* calls); - bool HeightIsConsistent(uint16_t* heights); -}; // namespace VerticalTunnelCall diff --git a/test/testpaint/generate.cpp b/test/testpaint/generate.cpp deleted file mode 100644 index 3284b08aec..0000000000 --- a/test/testpaint/generate.cpp +++ /dev/null @@ -1,1173 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include "Data.h" -#include "FunctionCall.hpp" -#include "PaintIntercept.hpp" -#include "SegmentSupportHeightCall.hpp" -#include "SideTunnelCall.hpp" -#include "String.hpp" -#include "Utils.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -class PaintCodeGenerator -{ -public: - int Generate(uint8_t rideType) - { - auto filename = "paint_" + std::to_string(rideType) + ".c"; - FILE* file = fopen(filename.c_str(), "w"); - if (file == nullptr) - { - fprintf(stderr, "Unable to save to ./%s\n", filename.c_str()); - return 1; - } - - _file = file; - _rideType = rideType; - _rideName = std::string(RideCodeNames[rideType]); - Generate(); - - fclose(file); - return 0; - } - -private: - std::string _rideName; - uint8_t _rideType; - FILE* _file; - - bool _conditionalSupports; - bool _invertedTrack; - - void Generate() - { - GenerateCopyrightHeader(); - GenerateIncludes(); - GenerateTrackFunctions(); - GenerateMainFunction(); - } - - void GenerateCopyrightHeader() - { - const char* copyrights[] = { - "/*****************************************************************************", - " * Copyright (c) 2014-2018 OpenRCT2 developers", - " *", - " * For a complete list of all authors, please refer to contributors.md", - " * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2", - " *", - " * OpenRCT2 is licensed under the GNU General Public License version 3.", - " *****************************************************************************/", - }; - - for (const auto copyright : copyrights) - { - WriteLine(0, copyright); - } - WriteLine(); - } - - void GenerateIncludes() - { - const char* includes[] = { - "../../drawing/Drawing.h", - "../../paint/supports.h", - "../../interface/Viewport.h", - "../../paint/tile_element/tile_element.h", - "../../paint/paint.h", - "../../sprites.h", - "../../world/Map.h", - "../../world/Sprite.h", - "../ride_data.h", - "../TrackData.h", - "../track_paint.h", - }; - for (auto include : includes) - { - WriteLine(0, "#include \"%s\"", include); - } - WriteLine(); - } - - void GenerateTrackFunctions() - { - for (int trackType = 0; trackType < 256; trackType++) - { - if (IsTrackTypeSupported(trackType)) - { - GenerateTrackFunction(trackType); - WriteLine(); - } - - if (trackType == TrackElemType::EndStation) - { - const uint32_t* paintFunctionList = RideTypeTrackPaintFunctionsOld[_rideType]; - WriteLine( - 0, "/** rct2: 0x%08X, 0x%08X, 0x%08X */", paintFunctionList[TrackElemType::EndStation], - paintFunctionList[TrackElemType::BeginStation], paintFunctionList[TrackElemType::MiddleStation]); - WriteLine( - 0, - "static void " + _rideName - + "_track_station(uint8_t rideIndex, uint8_t trackSequence, uint8_t direction, int height, " - "TileElement * tileElement)"); - WriteLine(0, "{"); - WriteLine(0, "}"); - WriteLine(); - } - } - } - - void GenerateTrackFunction(int trackType) - { - WriteLine(0, "/** rct2: 0x%08X */", RideTypeTrackPaintFunctionsOld[_rideType][trackType]); - WriteLine( - 0, - "static void " + GetTrackFunctionName(trackType) - + "(uint8_t rideIndex, uint8_t trackSequence, uint8_t direction, int height, TileElement * tileElement)"); - WriteLine(0, "{"); - if (!GenerateMirrorCall(1, trackType)) - { - if (_rideType == RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER || _rideType == RIDE_TYPE_FLYING_ROLLER_COASTER - || _rideType == RIDE_TYPE_LAY_DOWN_ROLLER_COASTER) - { - WriteLine(1, "if (!tileElement->AsTrack()->IsInverted()) {"); - _invertedTrack = false; - GenerateTrackFunctionBody(2, trackType); - WriteLine(1, "} else {"); - _invertedTrack = true; - GenerateTrackFunctionBody(2, trackType); - WriteLine(1, "}"); - } - else - { - _invertedTrack = false; - GenerateTrackFunctionBody(1, trackType); - } - } - WriteLine(0, "}"); - } - - void GenerateTrackFunctionBody(int tabs, int trackType) - { - int numSequences = Utils::getTrackSequenceCount(_rideType, trackType); - if (numSequences > 1) - { - WriteLine(tabs, "switch (trackSequence) {"); - for (int trackSequence = 0; trackSequence < numSequences; trackSequence++) - { - WriteLine(tabs, "case %d:", trackSequence); - GenerateTrackSequence(tabs + 1, trackType, trackSequence); - WriteLine(tabs + 1, "break;"); - } - WriteLine(tabs, "}"); - } - else - { - GenerateTrackSequence(tabs, trackType, 0); - } - } - - bool GenerateMirrorCall(int tabs, int trackType) - { - uint8_t mirrorTable[][3] = { - { 0, TrackElemType::Down25, TrackElemType::Up25 }, - { 0, TrackElemType::Down60, TrackElemType::Up60 }, - { 0, TrackElemType::FlatToDown25, TrackElemType::Up25ToFlat }, - { 0, TrackElemType::Down25ToDown60, TrackElemType::Up60ToUp25 }, - { 0, TrackElemType::Down60ToDown25, TrackElemType::Up25ToUp60 }, - { 0, TrackElemType::Down25ToFlat, TrackElemType::FlatToUp25 }, - { 0, TrackElemType::LeftBankToDown25, TrackElemType::Up25ToRightBank }, - { 0, TrackElemType::RightBankToDown25, TrackElemType::Up25ToLeftBank }, - { 0, TrackElemType::Down25ToLeftBank, TrackElemType::RightBankToUp25 }, - { 0, TrackElemType::Down25ToRightBank, TrackElemType::LeftBankToUp25 }, - { 0, TrackElemType::RightBank, TrackElemType::LeftBank }, - { 0, TrackElemType::Down60ToFlat, TrackElemType::FlatToUp60 }, - { 0, TrackElemType::FlatToDown60, TrackElemType::Up60ToFlat }, - { 0, TrackElemType::Down25Covered, TrackElemType::Up25Covered }, - { 0, TrackElemType::Down60Covered, TrackElemType::Up60Covered }, - { 0, TrackElemType::FlatToDown25Covered, TrackElemType::Up25ToFlatCovered }, - { 0, TrackElemType::Down25ToDown60Covered, TrackElemType::Up60ToUp25Covered }, - { 0, TrackElemType::Down60ToDown25Covered, TrackElemType::Up25ToUp60Covered }, - { 0, TrackElemType::Down25ToFlatCovered, TrackElemType::FlatToUp25Covered }, - { 0, TrackElemType::Down25LeftBanked, TrackElemType::Up25RightBanked }, - { 0, TrackElemType::Down25RightBanked, TrackElemType::Up25LeftBanked }, - { 0, TrackElemType::Down90, TrackElemType::Up90 }, - { 0, TrackElemType::Down90ToDown60, TrackElemType::Up60ToUp90 }, - // { 0, TrackElemType::Down60ToDown90, TrackElemType::Up90ToUp60 }, - { 0, TrackElemType::RightBankedDown25ToDown25, TrackElemType::Up25ToLeftBankedUp25 }, - { 0, TrackElemType::LeftBankedDown25ToDown25, TrackElemType::Up25ToRightBankedUp25 }, - { 0, TrackElemType::Down25ToRightBankedDown25, TrackElemType::LeftBankedUp25ToUp25 }, - { 0, TrackElemType::Down25ToLeftBankedDown25, TrackElemType::RightBankedUp25ToUp25 }, - { 0, TrackElemType::RightBankedDown25ToRightBankedFlat, TrackElemType::LeftBankedFlatToLeftBankedUp25 }, - { 0, TrackElemType::LeftBankedDown25ToLeftBankedFlat, TrackElemType::RightBankedFlatToRightBankedUp25 }, - { 0, TrackElemType::RightBankedFlatToRightBankedDown25, TrackElemType::LeftBankedUp25ToLeftBankedFlat }, - { 0, TrackElemType::LeftBankedFlatToLeftBankedDown25, TrackElemType::RightBankedUp25ToRightBankedFlat }, - { 0, TrackElemType::RightBankedDown25ToFlat, TrackElemType::FlatToLeftBankedUp25 }, - { 0, TrackElemType::LeftBankedDown25ToFlat, TrackElemType::FlatToRightBankedUp25 }, - { 0, TrackElemType::FlatToRightBankedDown25, TrackElemType::LeftBankedUp25ToFlat }, - { 0, TrackElemType::FlatToLeftBankedDown25, TrackElemType::RightBankedUp25ToFlat }, - - { 1, TrackElemType::RightQuarterTurn5Tiles, TrackElemType::LeftQuarterTurn5Tiles }, - { 1, TrackElemType::BankedRightQuarterTurn5Tiles, TrackElemType::BankedLeftQuarterTurn5Tiles }, - { 1, TrackElemType::RightQuarterTurn5TilesDown25, TrackElemType::LeftQuarterTurn5TilesUp25 }, - { 1, TrackElemType::RightQuarterTurn5TilesCovered, TrackElemType::LeftQuarterTurn5TilesCovered }, - { 1, TrackElemType::RightBankedQuarterTurn5TileDown25, TrackElemType::LeftBankedQuarterTurn5TileUp25 }, - { 2, TrackElemType::LeftQuarterTurn5TilesDown25, TrackElemType::RightQuarterTurn5TilesUp25 }, - { 2, TrackElemType::LeftBankedQuarterTurn5TileDown25, TrackElemType::RightBankedQuarterTurn5TileUp25 }, - - { 3, TrackElemType::RightQuarterTurn3Tiles, TrackElemType::LeftQuarterTurn3Tiles }, - { 3, TrackElemType::RightBankedQuarterTurn3Tiles, TrackElemType::LeftBankedQuarterTurn3Tiles }, - { 3, TrackElemType::RightQuarterTurn3TilesDown25, TrackElemType::LeftQuarterTurn3TilesUp25 }, - { 3, TrackElemType::RightQuarterTurn3TilesCovered, TrackElemType::LeftQuarterTurn3TilesCovered }, - { 3, TrackElemType::RightBankedQuarterTurn3TileDown25, TrackElemType::LeftBankedQuarterTurn3TileUp25 }, - { 4, TrackElemType::LeftQuarterTurn3TilesDown25, TrackElemType::RightQuarterTurn3TilesUp25 }, - { 4, TrackElemType::LeftBankedQuarterTurn3TileDown25, TrackElemType::RightBankedQuarterTurn3TileUp25 }, - - { 5, TrackElemType::RightQuarterTurn1Tile, TrackElemType::LeftQuarterTurn1Tile }, - { 5, TrackElemType::RightQuarterTurn1TileDown60, TrackElemType::LeftQuarterTurn1TileUp60 }, - { 5, TrackElemType::RightQuarterTurn1TileDown90, TrackElemType::LeftQuarterTurn1TileUp90 }, - { 6, TrackElemType::LeftQuarterTurn1TileDown60, TrackElemType::RightQuarterTurn1TileUp60 }, - { 6, TrackElemType::LeftQuarterTurn1TileDown90, TrackElemType::RightQuarterTurn1TileUp90 }, - - { 7, TrackElemType::RightEighthToOrthogonal, TrackElemType::LeftEighthToDiag }, - { 7, TrackElemType::RightEighthBankToOrthogonal, TrackElemType::LeftEighthBankToDiag }, - { 8, TrackElemType::LeftEighthToOrthogonal, TrackElemType::RightEighthToDiag }, - { 8, TrackElemType::LeftEighthBankToOrthogonal, TrackElemType::RightEighthBankToDiag }, - - { 9, TrackElemType::RightHalfBankedHelixDownSmall, TrackElemType::LeftHalfBankedHelixUpSmall }, - { 10, TrackElemType::LeftHalfBankedHelixDownSmall, TrackElemType::RightHalfBankedHelixUpSmall }, - { 11, TrackElemType::RightHalfBankedHelixDownLarge, TrackElemType::LeftHalfBankedHelixUpLarge }, - { 12, TrackElemType::LeftHalfBankedHelixDownLarge, TrackElemType::RightHalfBankedHelixUpLarge }, - - { 13, TrackElemType::Down60ToFlatLongBase, TrackElemType::FlatToUp60LongBase }, - { 13, TrackElemType::FlatToDown60LongBase, TrackElemType::Up60ToFlatLongBase }, - - { 14, TrackElemType::RightCorkscrewDown, TrackElemType::LeftCorkscrewUp }, - { 15, TrackElemType::LeftCorkscrewDown, TrackElemType::RightCorkscrewUp }, - - { 16, TrackElemType::HalfLoopDown, TrackElemType::HalfLoopUp }, - - { 17, TrackElemType::InvertedFlatToDown90QuarterLoop, TrackElemType::Up90ToInvertedFlatQuarterLoop }, - - { 18, TrackElemType::LeftBarrelRollDownToUp, TrackElemType::LeftBarrelRollUpToDown }, - { 18, TrackElemType::RightBarrelRollDownToUp, TrackElemType::RightBarrelRollUpToDown }, - - { 19, TrackElemType::LeftLargeHalfLoopDown, TrackElemType::LeftLargeHalfLoopUp }, - { 19, TrackElemType::RightLargeHalfLoopDown, TrackElemType::RightLargeHalfLoopUp }, - }; - - for (size_t i = 0; i < (sizeof(mirrorTable) / sizeof(mirrorTable[0])); i++) - { - if (mirrorTable[i][1] == trackType) - { - std::string destFuncName = GetTrackFunctionName(mirrorTable[i][2]); - switch (mirrorTable[i][0]) - { - case 0: - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 1: - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 2: - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 3: - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 4: - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 5: - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 6: - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 7: - WriteLine(tabs, "trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 3) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 8: - WriteLine(tabs, "trackSequence = mapLeftEighthTurnToOrthogonal[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 2) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 9: - WriteLine(tabs, "if (trackSequence >= 4) {"); - WriteLine(tabs + 1, "trackSequence -= 4;"); - WriteLine(tabs + 1, "direction = (direction + 1) & 3;"); - WriteLine(tabs, "}"); - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 10: - WriteLine(tabs, "if (trackSequence >= 4) {"); - WriteLine(tabs + 1, "trackSequence -= 4;"); - WriteLine(tabs + 1, "direction = (direction - 1) & 3;"); - WriteLine(tabs, "}"); - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn3TilesToRightQuarterTurn3Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 11: - WriteLine(tabs, "if (trackSequence >= 7) {"); - WriteLine(tabs + 1, "trackSequence -= 7;"); - WriteLine(tabs + 1, "direction = (direction + 1) & 3;"); - WriteLine(tabs, "}"); - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 12: - WriteLine(tabs, "if (trackSequence >= 7) {"); - WriteLine(tabs + 1, "trackSequence -= 7;"); - WriteLine(tabs + 1, "direction = (direction - 1) & 3;"); - WriteLine(tabs, "}"); - WriteLine(tabs, "trackSequence = mapLeftQuarterTurn5TilesToRightQuarterTurn5Tiles[trackSequence];"); - WriteLine( - tabs, "%s(rideIndex, trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 13: - WriteLine( - tabs, "%s(rideIndex, 3 - trackSequence, (direction + 2) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 14: - WriteLine( - tabs, "%s(rideIndex, 2 - trackSequence, (direction - 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 15: - WriteLine( - tabs, "%s(rideIndex, 2 - trackSequence, (direction + 1) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 16: - WriteLine( - tabs, "%s(rideIndex, 3 - trackSequence, direction, height, tileElement);", destFuncName.c_str()); - break; - case 17: - WriteLine( - tabs, "%s(rideIndex, 2 - trackSequence, direction, height, tileElement);", destFuncName.c_str()); - break; - case 18: - WriteLine( - tabs, "%s(rideIndex, 2 - trackSequence, (direction + 2) & 3, height, tileElement);", - destFuncName.c_str()); - break; - case 19: - WriteLine( - tabs, "%s(rideIndex, 6 - trackSequence, direction, height, tileElement);", destFuncName.c_str()); - break; - } - return true; - } - } - return false; - } - - void ExtractMetalSupportCalls(std::vector calls[4], std::vector output[4]) - { - for (int direction = 0; direction < 4; direction++) - { - auto cutPoint = std::find_if(calls[direction].begin(), calls[direction].end(), [](function_call call) { - return (call.function == SUPPORTS_METAL_A || call.function == SUPPORTS_METAL_B); - }); - output[direction].insert(output[direction].begin(), cutPoint, calls[direction].end()); - calls[direction].erase(cutPoint, calls[direction].end()); - } - } - - void GenerateTrackSequence(int tabs, int trackType, int trackSequence) - { - int height = 48; - _conditionalSupports = false; - bool blockSegmentsBeforeSupports = false; - - std::vector calls[4], chainLiftCalls[4], cableLiftCalls[4]; - TunnelCall tileTunnelCalls[4][4]; - int16_t verticalTunnelHeights[4]; - std::vector segmentSupportCalls[4]; - support_height generalSupports[4] = {}; - for (int direction = 0; direction < 4; direction++) - { - TileElement tileElement = {}; - tileElement.SetType(TileElementType::Track); - tileElement.SetLastForTile(true); - tileElement.AsTrack()->SetTrackType(trackType); - tileElement.base_height = 3; - if (_invertedTrack) - { - tileElement.AsTrack()->SetInverted(true); - } - g_currently_drawn_item = &tileElement; - - // Set position - RCT2_GLOBAL(0x009DE56A, int16_t) = 64; - RCT2_GLOBAL(0x009DE56E, int16_t) = 64; - - function_call callBuffer[256] = {}; - PaintIntercept::ClearCalls(); - CallOriginal(trackType, direction, trackSequence, height, &tileElement); - int numCalls = PaintIntercept::GetCalls(callBuffer); - calls[direction].insert(calls[direction].begin(), callBuffer, callBuffer + numCalls); - - for (auto&& call : calls[direction]) - { - if (call.function == SET_SEGMENT_HEIGHT) - { - blockSegmentsBeforeSupports = true; - break; - } - } - - segmentSupportCalls[direction] = SegmentSupportHeightCall::getSegmentCalls(gSupportSegments, direction); - generalSupports[direction] = gSupport; - if (gSupport.slope != 0xFF && gSupport.height != 0) - { - generalSupports[direction].height -= height; - } - - // Get chain lift calls - tileElement.AsTrack()->SetHasChain(true); - PaintIntercept::ClearCalls(); - CallOriginal(trackType, direction, trackSequence, height, &tileElement); - numCalls = PaintIntercept::GetCalls(callBuffer); - chainLiftCalls[direction].insert(chainLiftCalls[direction].begin(), callBuffer, callBuffer + numCalls); - - // Get cable lift calls (giga coaster only) - if (_rideType == RIDE_TYPE_GIGA_COASTER) - { - tileElement.type = 0; - tileElement.AsTrack()->SetHasCableLift(true); - PaintIntercept::ClearCalls(); - CallOriginal(trackType, direction, trackSequence, height, &tileElement); - numCalls = PaintIntercept::GetCalls(callBuffer); - cableLiftCalls[direction].insert(cableLiftCalls[direction].begin(), callBuffer, callBuffer + numCalls); - } - - // Check a different position for direction 0 to see if supports are different - if (direction == 0) - { - RCT2_GLOBAL(0x009DE56A, int16_t) = 64 + 32; - RCT2_GLOBAL(0x009DE56E, int16_t) = 64; - tileElement.type = 0; - tileElement.AsTrack()->SetHasCableLift(false); - PaintIntercept::ClearCalls(); - CallOriginal(trackType, direction, trackSequence, height, &tileElement); - numCalls = PaintIntercept::GetCalls(callBuffer); - std::vector checkCalls = std::vector(callBuffer, callBuffer + numCalls); - if (!CompareFunctionCalls(checkCalls, calls[direction])) - { - _conditionalSupports = true; - } - } - - GetTunnelCalls(trackType, direction, trackSequence, height, &tileElement, tileTunnelCalls, verticalTunnelHeights); - } - - std::vector supportCalls[4], chainLiftSupportCalls[4], cableLiftSupportCalls[4]; - if (blockSegmentsBeforeSupports) - { - ExtractMetalSupportCalls(calls, supportCalls); - ExtractMetalSupportCalls(cableLiftCalls, cableLiftSupportCalls); - ExtractMetalSupportCalls(chainLiftCalls, chainLiftSupportCalls); - } - - if (_rideType == RIDE_TYPE_GIGA_COASTER && !CompareFunctionCalls(calls, cableLiftCalls)) - { - WriteLine(tabs, "if (tileElement->AsTrack()->HasCableLift()) {"); - GenerateCalls(tabs + 1, cableLiftCalls, height); - - if (!CompareFunctionCalls(calls, chainLiftCalls)) - { - WriteLine(tabs, "} else if (tileElement->AsTrack()->HasChain()) {"); - GenerateCalls(tabs + 1, chainLiftCalls, height); - } - - WriteLine(tabs, "} else {"); - GenerateCalls(tabs + 1, calls, height); - WriteLine(tabs, "}"); - } - else if (!CompareFunctionCalls(calls, chainLiftCalls)) - { - WriteLine(tabs, "if (tileElement->AsTrack()->HasChain()) {"); - GenerateCalls(tabs + 1, chainLiftCalls, height); - WriteLine(tabs, "} else {"); - GenerateCalls(tabs + 1, calls, height); - WriteLine(tabs, "}"); - } - else - { - GenerateCalls(tabs, calls, height); - } - - if (blockSegmentsBeforeSupports) - { - if (_rideType == RIDE_TYPE_GIGA_COASTER && !CompareFunctionCalls(supportCalls, cableLiftSupportCalls)) - { - printf("Error: Supports differ for cable lift.\n"); - } - else if (!CompareFunctionCalls(supportCalls, chainLiftSupportCalls)) - { - printf("Error: Supports differ for chain lift\n"); - } - WriteLine(); - GenerateSegmentSupportCall(tabs, segmentSupportCalls); - - bool conditionalSupports = _conditionalSupports; - _conditionalSupports = false; - if (conditionalSupports) - { - WriteLine(tabs, "if (track_paint_util_should_paint_supports(gPaintMapPosition)) {"); - tabs++; - } - GenerateCalls(tabs, supportCalls, height); - if (conditionalSupports) - { - tabs--; - WriteLine(tabs, "}"); - } - WriteLine(); - } - - GenerateTunnelCall(tabs, tileTunnelCalls, verticalTunnelHeights); - if (!blockSegmentsBeforeSupports) - { - GenerateSegmentSupportCall(tabs, segmentSupportCalls); - } - GenerateGeneralSupportCall(tabs, generalSupports); - } - - void GenerateCalls(int tabs, std::vector calls[4], int height) - { - std::vector commonCalls = TrimCommonCallsEnd(calls); - - int totalCalls = 0; - for (int direction = 0; direction < 4; direction++) - { - totalCalls += calls[direction].size(); - } - if (totalCalls != 0) - { - WriteLine(tabs, "switch (direction) {"); - for (int direction = 0; direction < 4; direction++) - { - if (calls[direction].empty()) - continue; - - WriteLine(tabs, "case %d:", direction); - for (int d2 = direction + 1; d2 < 4; d2++) - { - if (CompareFunctionCalls(calls[direction], calls[d2])) - { - // Clear identical other direction calls and add case for it - calls[d2].clear(); - WriteLine(tabs, "case %d:", d2); - } - } - - for (auto call : calls[direction]) - { - GenerateCalls(tabs + 1, call, height, direction); - } - WriteLine(tabs + 1, "break;"); - } - WriteLine(tabs, "}"); - } - - for (auto call : commonCalls) - { - GenerateCalls(tabs, call, height, 0); - } - } - - void GenerateCalls(int tabs, const function_call& call, int height, int direction) - { - switch (call.function) - { - case PAINT_98196C: - case PAINT_98197C: - case PAINT_98198C: - case PAINT_98199C: - GeneratePaintCall(tabs, call, height, direction); - break; - case SUPPORTS_METAL_A: - case SUPPORTS_METAL_B: - { - int callTabs = tabs; - if (_conditionalSupports) - { - WriteLine(tabs, "if (track_paint_util_should_paint_supports(gPaintMapPosition)) {"); - callTabs++; - } - - WriteLine( - callTabs, "%s(%d, %d, %d, height%s, %s);", GetFunctionCallName(call.function), call.supports.type, - call.supports.segment, call.supports.special, - GetOffsetExpressionString(call.supports.height - height).c_str(), - GetImageIdString(call.supports.colour_flags).c_str()); - - if (_conditionalSupports) - { - WriteLine(tabs, "}"); - } - break; - } - case SUPPORTS_WOOD_A: - case SUPPORTS_WOOD_B: - WriteLine( - tabs, "%s(%d, %d, height%s, %s, NULL);", GetFunctionCallName(call.function), call.supports.type, - call.supports.special, GetOffsetExpressionString(call.supports.height - height).c_str(), - GetImageIdString(call.supports.colour_flags).c_str()); - break; - } - } - - void GeneratePaintCall(int tabs, const function_call& call, int height, int direction) - { - const char* funcName = GetFunctionCallName(call.function); - std::string imageId = GetImageIdString(call.paint.image_id); - std::string s = String::Format("%s_rotated(direction, %s, ", funcName, imageId.c_str()); - s += FormatXYSwap(call.paint.offset.x, call.paint.offset.y, direction); - s += ", "; - s += FormatXYSwap(call.paint.bound_box_length.x, call.paint.bound_box_length.y, direction); - s += String::Format( - ", %d, height%s", call.paint.bound_box_length.z, GetOffsetExpressionString(call.paint.z_offset - height).c_str()); - - if (call.function != PAINT_98196C) - { - s += ", "; - s += FormatXYSwap(call.paint.bound_box_offset.x, call.paint.bound_box_offset.y, direction); - s += String::Format(", height%s", GetOffsetExpressionString(call.paint.bound_box_offset.z - height).c_str()); - } - - s += ");"; - WriteLine(tabs, s); - } - - std::string FormatXYSwap(int16_t x, int16_t y, int direction) - { - if (direction & 1) - { - return String::Format("%d, %d", y, x); - } - else - { - return String::Format("%d, %d", x, y); - } - } - - std::vector TrimCommonCallsEnd(std::vector calls[4]) - { - std::vector commonCalls; - - while (calls[0].size() != 0) - { - function_call lastCall = calls[0].back(); - for (int i = 0; i < 4; i++) - { - if (calls[i].empty() || !CompareFunctionCall(calls[i].back(), lastCall)) - { - goto finished; - } - } - for (int i = 0; i < 4; i++) - { - calls[i].pop_back(); - } - commonCalls.push_back(lastCall); - } - - finished: - return commonCalls; - } - - bool CompareFunctionCalls(const std::vector a[4], const std::vector b[4]) - { - for (size_t i = 0; i < 4; i++) - { - if (!CompareFunctionCalls(a[i], b[i])) - { - return false; - } - } - return true; - } - - bool CompareFunctionCalls(const std::vector& a, const std::vector& b) - { - if (a.size() != b.size()) - return false; - for (size_t i = 0; i < a.size(); i++) - { - if (!CompareFunctionCall(a[i], b[i])) - { - return false; - } - } - return true; - } - - bool CompareFunctionCall(const function_call a, const function_call& b) - { - return FunctionCall::AssertsEquals(a, b); - } - - const char* GetFunctionCallName(int function) - { - const char* functionNames[] = { - "sub_98196C", - "sub_98197C", - "sub_98198C", - "sub_98199C", - "metal_a_supports_paint_setup", - "metal_b_supports_paint_setup", - "wooden_a_supports_paint_setup", - "wooden_b_supports_paint_setup", - }; - return functionNames[function]; - } - - bool GetTunnelCalls( - int trackType, int direction, int trackSequence, int height, TileElement* tileElement, TunnelCall tileTunnelCalls[4][4], - int16_t verticalTunnelHeights[4]) - { - TestPaint::ResetTunnels(); - - for (int offset = -8; offset <= 8; offset += 8) - { - CallOriginal(trackType, direction, trackSequence, height + offset, tileElement); - } - - uint8_t rightIndex = (4 - direction) % 4; - uint8_t leftIndex = (rightIndex + 1) % 4; - - for (int i = 0; i < 4; ++i) - { - tileTunnelCalls[direction][i].call = TUNNELCALL_SKIPPED; - } - if (gRightTunnelCount == 0) - { - tileTunnelCalls[direction][rightIndex].call = TUNNELCALL_NONE; - } - else if (gRightTunnelCount == 3) - { - tileTunnelCalls[direction][rightIndex].call = TUNNELCALL_CALL; - tileTunnelCalls[direction][rightIndex].offset = SideTunnelCall::GetTunnelOffset(height, gRightTunnels); - tileTunnelCalls[direction][rightIndex].type = gRightTunnels[0].type; - } - else - { - printf("Multiple tunnels on one side aren't supported.\n"); - return false; - } - - if (gLeftTunnelCount == 0) - { - tileTunnelCalls[direction][leftIndex].call = TUNNELCALL_NONE; - } - else if (gLeftTunnelCount == 3) - { - tileTunnelCalls[direction][leftIndex].call = TUNNELCALL_CALL; - tileTunnelCalls[direction][leftIndex].offset = SideTunnelCall::GetTunnelOffset(height, gLeftTunnels); - tileTunnelCalls[direction][leftIndex].type = gLeftTunnels[0].type; - } - else - { - printf("Multiple tunnels on one side aren't supported.\n"); - return false; - } - - // Vertical tunnel - gVerticalTunnelHeight = 0; - CallOriginal(trackType, direction, trackSequence, height, tileElement); - - int verticalTunnelHeight = gVerticalTunnelHeight; - if (verticalTunnelHeight != 0) - { - verticalTunnelHeight = (verticalTunnelHeight * 16) - height; - } - verticalTunnelHeights[direction] = verticalTunnelHeight; - return true; - } - - void GenerateTunnelCall(int tabs, TunnelCall tileTunnelCalls[4][4], int16_t verticalTunnelHeights[4]) - { - constexpr uint8_t TunnelLeft = 0; - constexpr uint8_t TunnelRight = 1; - constexpr uint8_t TunnelNA = 255; - static const uint8_t dsToWay[4][4] = { - { TunnelRight, TunnelLeft, TunnelNA, TunnelNA }, - { TunnelLeft, TunnelNA, TunnelNA, TunnelRight }, - { TunnelNA, TunnelNA, TunnelRight, TunnelLeft }, - { TunnelNA, TunnelRight, TunnelLeft, TunnelNA }, - }; - - int16_t tunnelOffset[4] = { 0 }; - uint8_t tunnelType[4] = { 0xFF, 0xFF, 0xFF, 0xFF }; - for (int direction = 0; direction < 4; direction++) - { - for (int side = 0; side < 4; side++) - { - auto tunnel = tileTunnelCalls[direction][side]; - if (tunnel.call == TUNNELCALL_CALL) - { - tunnelOffset[direction] = tunnel.offset; - tunnelType[direction] = tunnel.type; - break; - } - } - } - - if (AllMatch(tunnelOffset, 4) && AllMatch(tunnelType, 4)) - { - if (tunnelType[0] != 0xFF) - { - GenerateTunnelCall(tabs, tunnelOffset[0], tunnelType[0]); - } - } - else if ( - tunnelOffset[0] == tunnelOffset[3] && tunnelType[0] == tunnelType[3] && tunnelOffset[1] == tunnelOffset[2] - && tunnelType[1] == tunnelType[2] && tunnelType[0] != 0xFF) - { - if (tunnelType[0] != 0xFF) - { - WriteLine(tabs, "if (direction == 0 || direction == 3) {"); - GenerateTunnelCall(tabs + 1, tunnelOffset[0], tunnelType[0]); - if (tunnelType[1] != 0xFF) - { - WriteLine(tabs, "} else {"); - GenerateTunnelCall(tabs + 1, tunnelOffset[1], tunnelType[1]); - } - WriteLine(tabs, "}"); - } - else - { - WriteLine(tabs, "if (direction == 1 || direction == 2) {"); - GenerateTunnelCall(tabs + 1, tunnelOffset[1], tunnelType[1]); - WriteLine(tabs, "}"); - } - } - else - { - WriteLine(tabs, "switch (direction) {"); - for (int i = 0; i < 4; i++) - { - if (tunnelType[i] != 0xFF) - { - WriteLine(tabs, "case %d:", i); - for (int side = 0; side < 4; side++) - { - if (tileTunnelCalls[i][side].call == TUNNELCALL_CALL) - { - GenerateTunnelCall( - tabs + 1, tileTunnelCalls[i][side].offset, tileTunnelCalls[i][side].type, dsToWay[i][side]); - } - } - WriteLine(tabs + 1, "break;"); - } - } - WriteLine(tabs, "}"); - } - - if (AllMatch(verticalTunnelHeights, 4)) - { - int tunnelHeight = verticalTunnelHeights[0]; - if (tunnelHeight != 0) - { - WriteLine( - tabs, "paint_util_set_vertical_tunnel(session, height%s);", - GetOffsetExpressionString(tunnelHeight).c_str()); - } - } - } - - void GenerateTunnelCall(int tabs, int offset, int type, int way) - { - switch (way) - { - case 0: - WriteLine( - tabs, "paint_util_push_tunnel_left(session, height%s, TUNNEL_%d);", - GetOffsetExpressionString(offset).c_str(), type); - break; - case 1: - WriteLine( - tabs, "paint_util_push_tunnel_right(session, height%s, TUNNEL_%d);", - GetOffsetExpressionString(offset).c_str(), type); - break; - } - } - - void GenerateTunnelCall(int tabs, int offset, int type) - { - WriteLine( - tabs, "paint_util_push_tunnel_rotated(session, direction, height%s, TUNNEL_%d);", - GetOffsetExpressionString(offset).c_str(), type); - } - - void GenerateSegmentSupportCall(int tabs, std::vector segmentSupportCalls[4]) - { - for (size_t i = 0; i < segmentSupportCalls[0].size(); i++) - { - auto ssh = segmentSupportCalls[0][i]; - std::string szCall = "paint_util_set_segment_support_height(session, "; - if (ssh.segments == SEGMENTS_ALL) - { - szCall += "SEGMENTS_ALL"; - } - else - { - szCall += "paint_util_rotate_segments("; - szCall += GetORedSegments(ssh.segments); - szCall += ", direction)"; - } - szCall += ", "; - if (ssh.height == 0xFFFF) - { - szCall += "0xFFFF"; - szCall += String::Format(", 0);", ssh.slope); - } - else - { - szCall += std::to_string(ssh.height); - szCall += String::Format(", 0x%02X);", ssh.slope); - } - WriteLine(tabs, szCall); - } - } - - void GenerateGeneralSupportCall(int tabs, support_height generalSupports[4]) - { - if (generalSupports[0].height == 0 && generalSupports[0].slope == 0xFF) - { - return; - } - - WriteLine( - tabs, "paint_util_set_general_support_height(session, height%s, 0x%02X);", - GetOffsetExpressionString((int16_t)generalSupports[0].height).c_str(), generalSupports[0].slope); - if (!AllMatch(generalSupports, 4)) - { - // WriteLine(tabs, "#error Unsupported: different directional general supports"); - } - } - - std::string GetImageIdString(uint32_t imageId) - { - std::string result; - - uint32_t image = imageId & 0x7FFFF; - uint32_t palette = imageId & ~0x7FFFF; - - std::string paletteName; - if (palette == TestPaint::DEFAULT_SCHEME_TRACK) - paletteName = "gTrackColours[SCHEME_TRACK]"; - else if (palette == TestPaint::DEFAULT_SCHEME_SUPPORTS) - paletteName = "gTrackColours[SCHEME_SUPPORTS]"; - else if (palette == TestPaint::DEFAULT_SCHEME_MISC) - paletteName = "gTrackColours[SCHEME_MISC]"; - else if (palette == TestPaint::DEFAULT_SCHEME_3) - paletteName = "gTrackColours[SCHEME_3]"; - else - { - paletteName = String::Format("0x%08X", palette); - } - - if (image == 0) - { - result = paletteName; - } - else if (image & 0x70000) - { - result = String::Format("%s | vehicle.base_image_id + %d", paletteName.c_str(), image & ~0x70000); - } - else - { - result = String::Format("%s | %d", paletteName.c_str(), image); - } - return result; - } - - std::string GetOffsetExpressionString(int offset) - { - if (offset < 0) - return std::string(" - ") + std::to_string(-offset); - if (offset > 0) - return std::string(" + ") + std::to_string(offset); - return std::string(); - } - - std::string GetORedSegments(int segments) - { - std::string s; - int segmentsPrinted = 0; - for (int i = 0; i < 9; i++) - { - if (segments & segment_offsets[i]) - { - if (segmentsPrinted > 0) - { - s += " | "; - } - s += String::Format("SEGMENT_%02X", 0xB4 + 4 * i); - segmentsPrinted++; - } - } - return s; - } - - template bool AllMatch(T* arr, size_t count) - { - for (size_t i = 1; i < count; i++) - { - if (memcmp((const void*)&arr[i], (const void*)&arr[0], sizeof(T)) != 0) - { - return false; - } - } - return true; - } - - void CallOriginal(int trackType, int direction, int trackSequence, int height, TileElement* tileElement) - { - TestPaint::ResetEnvironment(); - TestPaint::ResetSupportHeights(); - - uint32_t* trackDirectionList = (uint32_t*)RideTypeTrackPaintFunctionsOld[_rideType][trackType]; - // Have to call from this point as it pushes esi and expects callee to pop it - RCT2_CALLPROC_X( - 0x006C4934, _rideType, (int)trackDirectionList, direction, height, (int)tileElement, 0 * sizeof(Ride), - trackSequence); - } - - void GenerateMainFunction() - { - WriteLine(0, "TRACK_PAINT_FUNCTION get_track_paint_function_" + _rideName + "(int trackType, int direction)"); - WriteLine(0, "{"); - WriteLine(1, "switch (trackType) {"); - for (int trackType = 0; trackType < 256; trackType++) - { - if (trackType == TrackElemType::EndStation) - { - WriteLine(1, "case " + std::string(TrackElemNames[TrackElemType::EndStation]) + ":"); - WriteLine(1, "case " + std::string(TrackElemNames[TrackElemType::BeginStation]) + ":"); - WriteLine(1, "case " + std::string(TrackElemNames[TrackElemType::MiddleStation]) + ":"); - WriteLine(2, "return %s_track_station;", _rideName.c_str()); - continue; - } - - if (IsTrackTypeSupported(trackType)) - { - WriteLine(1, "case " + std::string(TrackElemNames[trackType]) + ":"); - WriteLine(2, "return %s;", GetTrackFunctionName(trackType).c_str()); - } - } - WriteLine(1, "}"); - WriteLine(1, "return nullptr;"); - WriteLine(0, "}"); - } - - std::string GetTrackFunctionName(int trackType) - { - std::string trackName = TrackCodeNames[trackType]; - return _rideName + "_track_" + trackName; - } - - bool IsTrackTypeSupported(int trackType) - { - if (trackType == TrackElemType::BeginStation || trackType == TrackElemType::MiddleStation - || trackType == TrackElemType::EndStation) - { - return false; - } - if (RideTypeTrackPaintFunctionsOld[_rideType][trackType] != 0) - { - return true; - } - return false; - } - - void WriteLine() - { - WriteLine(0, ""); - } - - void WriteLine(int tabs, const char* format, ...) - { - va_list args; - char buffer[512]; - - va_start(args, format); - vsnprintf(buffer, sizeof(buffer), format, args); - va_end(args); - - WriteLine(tabs, std::string(buffer)); - } - - void WriteLine(int tabs, std::string s) - { - for (int i = 0; i < tabs; i++) - { - fprintf(_file, "\t"); - } - fprintf(_file, "%s\n", s.c_str()); - } -}; - -int generatePaintCode(uint8_t rideType) -{ - if (GetRideTypeDescriptor(rideType).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)) - { - fprintf(stderr, "Flat rides not supported.\n"); - } - - auto pcg = PaintCodeGenerator(); - return pcg.Generate(rideType); -} diff --git a/test/testpaint/main.cpp b/test/testpaint/main.cpp deleted file mode 100644 index b3b7dbcfa3..0000000000 --- a/test/testpaint/main.cpp +++ /dev/null @@ -1,644 +0,0 @@ -/***************************************************************************** - * Copyright (c) 2014-2018 OpenRCT2 developers - * - * For a complete list of all authors, please refer to contributors.md - * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2 - * - * OpenRCT2 is licensed under the GNU General Public License version 3. - *****************************************************************************/ - -#include -#include -#include -#include -#include -#include - -#if defined(__unix__) -# include -# include -#endif // defined(__unix__) - -#include "Data.h" -#include "PaintIntercept.hpp" -#include "TestTrack.hpp" -#include "Utils.hpp" - -#include -#include -#include -#include -#include - -struct TestCase -{ - uint8_t rideType; - std::vector trackTypes; -}; - -enum CLIColour -{ - DEFAULT, - RED, - YELLOW, - GREEN, -}; - -bool gTestColor = true; -Verbosity _verbosity = NORMAL; - -static bool CStringEquals(const char* lhs, const char* rhs) -{ - if (lhs == nullptr) - return rhs == nullptr; - - if (rhs == nullptr) - return false; - - return strcmp(lhs, rhs) == 0; -} - -enum COLOUR_METHOD -{ - COLOUR_METHOD_NONE, - COLOUR_METHOD_ANSI, - COLOUR_METHOD_WINDOWS, -}; - -static COLOUR_METHOD GetColourMethod() -{ - if (!gTestColor) - { - return COLOUR_METHOD_NONE; - } - - const char* const term = getenv("TERM"); - const bool term_supports_color = CStringEquals(term, "xterm") || CStringEquals(term, "xterm-color") - || CStringEquals(term, "xterm-256color") || CStringEquals(term, "screen") || CStringEquals(term, "screen-256color") - || CStringEquals(term, "tmux") || CStringEquals(term, "tmux-256color") || CStringEquals(term, "rxvt-unicode") - || CStringEquals(term, "rxvt-unicode-256color") || CStringEquals(term, "linux") || CStringEquals(term, "cygwin"); - - if (term_supports_color) - { - return COLOUR_METHOD_ANSI; - } - -#ifdef __WINDOWS__ - return COLOUR_METHOD_WINDOWS; -#else - return COLOUR_METHOD_NONE; -#endif -} - -static const char* GetAnsiColorCode(CLIColour color) -{ - switch (color) - { - case RED: - return "1"; - case GREEN: - return "2"; - case YELLOW: - return "3"; - default: - return nullptr; - }; -} - -#ifdef __WINDOWS__ - -static WORD GetCurrentWindowsConsoleAttribute(HANDLE hConsoleOutput) -{ - CONSOLE_SCREEN_BUFFER_INFO csbi; - GetConsoleScreenBufferInfo(hConsoleOutput, &csbi); - return csbi.wAttributes; -} - -static WORD GetWindowsConsoleAttribute(CLIColour color, WORD defaultAttr) -{ - switch (color) - { - case RED: - return FOREGROUND_RED; - case GREEN: - return FOREGROUND_GREEN; - case YELLOW: - return FOREGROUND_RED | FOREGROUND_GREEN; - default: - return defaultAttr; - }; -} - -#endif - -static void Write_VA(Verbosity verbosity, CLIColour colour, const char* fmt, va_list args) -{ - if (_verbosity < verbosity) - return; - - COLOUR_METHOD colourMethod = GetColourMethod(); - - if (colour == CLIColour::DEFAULT || colourMethod == COLOUR_METHOD_NONE) - { - vprintf(fmt, args); - } - else if (colourMethod == COLOUR_METHOD_ANSI) - { - printf("\033[0;3%sm", GetAnsiColorCode(colour)); - vprintf(fmt, args); - printf("\033[m"); - } - else if (colourMethod == COLOUR_METHOD_WINDOWS) - { -#ifdef __WINDOWS__ - HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); - WORD defaultAttr = GetCurrentWindowsConsoleAttribute(hStdOut); - SetConsoleTextAttribute(hStdOut, GetWindowsConsoleAttribute(colour, defaultAttr)); - vprintf(fmt, args); - SetConsoleTextAttribute(hStdOut, defaultAttr); -#endif - } -} - -static void Write(Verbosity verbosity, CLIColour colour, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - Write_VA(verbosity, colour, fmt, args); - va_end(args); -} - -static void Write(Verbosity verbosity, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - Write_VA(verbosity, DEFAULT, fmt, args); - va_end(args); -} - -static void Write(CLIColour colour, const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - Write_VA(NORMAL, colour, fmt, args); - va_end(args); -} - -static void Write(const char* fmt, ...) -{ - va_list args; - va_start(args, fmt); - Write_VA(NORMAL, DEFAULT, fmt, args); - va_end(args); -} - -#if defined(__WINDOWS__) - -# include - -int main(int argc, char* argv[]); - -# define OPENRCT2_DLL_MODULE_NAME "openrct2.dll" - -static HMODULE _dllModule = nullptr; - -utf8* utf8_write_codepoint(utf8* dst, uint32_t codepoint) -{ - if (codepoint <= 0x7F) - { - dst[0] = (utf8)codepoint; - return dst + 1; - } - else if (codepoint <= 0x7FF) - { - dst[0] = 0xC0 | ((codepoint >> 6) & 0x1F); - dst[1] = 0x80 | (codepoint & 0x3F); - return dst + 2; - } - else if (codepoint <= 0xFFFF) - { - dst[0] = 0xE0 | ((codepoint >> 12) & 0x0F); - dst[1] = 0x80 | ((codepoint >> 6) & 0x3F); - dst[2] = 0x80 | (codepoint & 0x3F); - return dst + 3; - } - else - { - dst[0] = 0xF0 | ((codepoint >> 18) & 0x07); - dst[1] = 0x80 | ((codepoint >> 12) & 0x3F); - dst[2] = 0x80 | ((codepoint >> 6) & 0x3F); - dst[3] = 0x80 | (codepoint & 0x3F); - return dst + 4; - } -} - -utf8* widechar_to_utf8(const wchar_t* src) -{ - utf8* result = (utf8*)malloc((wcslen(src) * 4) + 1); - utf8* dst = result; - - for (; *src != 0; src++) - { - dst = utf8_write_codepoint(dst, *src); - } - *dst++ = 0; - - size_t size = (size_t)(dst - result); - return (utf8*)realloc(result, size); -} - -utf8** windows_get_command_line_args(int* outNumArgs) -{ - int argc; - - // Get command line arguments as widechar - LPWSTR commandLine = GetCommandLineW(); - LPWSTR* argvW = CommandLineToArgvW(commandLine, &argc); - - // Convert to UTF-8 - utf8** argvUtf8 = (utf8**)malloc(argc * sizeof(utf8*)); - for (int i = 0; i < argc; i++) - { - argvUtf8[i] = widechar_to_utf8(argvW[i]); - } - LocalFree(argvW); - - *outNumArgs = argc; - return argvUtf8; -} - -BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved) -{ - _dllModule = (HMODULE)hModule; - return TRUE; -} - -__declspec(dllexport) int StartOpenRCT2(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) -{ - if (_dllModule == nullptr) - { - _dllModule = GetModuleHandleA(OPENRCT2_DLL_MODULE_NAME); - } - - int argc; - char** argv = (char**)windows_get_command_line_args(&argc); - - int gExitCode = main(argc, argv); - - // Free argv - for (int i = 0; i < argc; i++) - { - free(argv[i]); - } - free(argv); - - exit(gExitCode); - return gExitCode; -} - -#endif - -char* segments = (char*)(GOOD_PLACE_FOR_DATA_SEGMENT); - -static uint32_t sawyercoding_calculate_checksum(const uint8_t* buffer, size_t length) -{ - size_t i; - uint32_t checksum = 0; - for (i = 0; i < length; i++) - checksum += buffer[i]; - - return checksum; -} - -/** - * Loads RCT2's data model and remaps the addresses. - * @returns true if the data integrity check succeeded, otherwise false. - */ -static bool openrct2_setup_rct2_segment() -{ - // OpenRCT2 on Linux and macOS is wired to have the original Windows PE sections loaded - // necessary. Windows does not need to do this as OpenRCT2 runs as a DLL loaded from the Windows PE. - // in some configurations err and len may be unused - [[maybe_unused]] int len = 0x01429000 - 0x8a4000; // 0xB85000, 12079104 bytes or around 11.5MB - [[maybe_unused]] int err = 0; -#if defined(__unix__) - int pageSize = getpagesize(); - int numPages = (len + pageSize - 1) / pageSize; - unsigned char* dummy = (unsigned char*)malloc(numPages); - - err = mincore((void*)segments, len, dummy); - bool pagesMissing = false; - if (err != 0) - { - err = errno; -# ifdef __LINUX__ - // On Linux ENOMEM means all requested range is unmapped - if (err != ENOMEM) - { - pagesMissing = true; - perror("mincore"); - } -# else - pagesMissing = true; - perror("mincore"); -# endif // __LINUX__ - } - else - { - for (int i = 0; i < numPages; i++) - { - if (dummy[i] != 1) - { - pagesMissing = true; - void* start = (void*)(segments + i * pageSize); - void* end = (void*)(segments + (i + 1) * pageSize - 1); - log_warning("required page %p - %p is not in memory!", start, end); - } - } - } - free(dummy); - if (pagesMissing) - { - log_error("At least one of required pages was not found in memory. This can cause segfaults later on."); - } - - // section: text - err = mprotect((void*)0x401000, 0x8a4000 - 0x401000, PROT_READ | PROT_EXEC | PROT_WRITE); - if (err != 0) - { - perror("mprotect"); - } - - // section: rw data - err = mprotect((void*)segments, 0x01429000 - 0x8a4000, PROT_READ | PROT_WRITE); - if (err != 0) - { - perror("mprotect"); - } -#endif // defined(__unix__) - - // Check that the expected data is at various addresses. - // Start at 0x9a6000, which is start of .data, to skip the region containing addresses to DLL - // calls, which can be changed by windows/wine loader. - const uint32_t c1 = sawyercoding_calculate_checksum( - (const uint8_t*)(segments + (uintptr_t)(0x009A6000 - 0x8a4000)), 0x009E0000 - 0x009A6000); - const uint32_t c2 = sawyercoding_calculate_checksum( - (const uint8_t*)(segments + (uintptr_t)(0x01428000 - 0x8a4000)), 0x014282BC - 0x01428000); - const uint32_t exp_c1 = 10114815; - const uint32_t exp_c2 = 23564; - if (c1 != exp_c1 || c2 != exp_c2) - { - log_warning("c1 = %u, expected %u, match %d", c1, exp_c1, c1 == exp_c1); - log_warning("c2 = %u, expected %u, match %d", c2, exp_c2, c2 == exp_c2); - return false; - } - - return true; -} - -static void PrintRideTypes() -{ - for (uint8_t rideType = 0; rideType < RCT2_RIDE_TYPE_COUNT; rideType++) - { - CLIColour colour = CLIColour::DEFAULT; - bool implemented = Utils::rideIsImplemented(rideType); - const char* rideName = RideNames[rideType]; - const char* status = ""; - if (implemented) - { - status = " [IMPLEMENTED]"; - colour = CLIColour::GREEN; - } - - Write(colour, "%2d: %-30s%s\n", rideType, rideName, status); - } -} - -#include "GeneralSupportHeightCall.hpp" - -static void TestGeneralSupportHeightCall() -{ - SupportCall callA = { 16, 0x20 }; - SupportCall callB = { 32, 0x20 }; - SupportCall callC = { 48, 0x20 }; - SupportCall callD = { 48, 0x1F }; - - SupportCall out = { 0, 0 }; - bool success; - - SupportCall groupA[4] = { callA, callA, callA, callA }; - success = GeneralSupportHeightCall::FindMostCommonSupportCall(groupA, &out); - assert(success); - assert(out == callA); - - SupportCall groupB[4] = { callB, callA, callA, callA }; - success = GeneralSupportHeightCall::FindMostCommonSupportCall(groupB, &out); - assert(success); - assert(out == callA); - - SupportCall groupC[4] = { callB, callA, callB, callA }; - success = GeneralSupportHeightCall::FindMostCommonSupportCall(groupC, &out); - assert(!success); - - SupportCall groupD[4] = { callB, callC, callB, callA }; - success = GeneralSupportHeightCall::FindMostCommonSupportCall(groupD, &out); - assert(!success); - - SupportCall groupE[4] = { callD, callC, callB, callA }; - success = GeneralSupportHeightCall::FindMostCommonSupportCall(groupE, &out); - assert(!success); -} - -int main(int argc, char* argv[]) -{ -#if !defined(__i386__) - fprintf(stderr, "Testpaint can only be properly executed on x86\n"); - return 1; -#else - TestGeneralSupportHeightCall(); - - std::vector testCases; - - bool generate = false; - uint8_t specificRideType = 0xFF; - for (int i = 0; i < argc; ++i) - { - char* arg = argv[i]; - if (strcmp(arg, "--gtest_color=no") == 0) - { - gTestColor = false; - } - else if (strcmp(arg, "--quiet") == 0) - { - _verbosity = Verbosity::QUIET; - } - else if (strcmp(arg, "--ride-type") == 0) - { - if (i + 1 < argc) - { - i++; - specificRideType = atoi(argv[i]); - } - else - { - PrintRideTypes(); - return 2; - } - } - else if (strcmp(arg, "--generate") == 0) - { - generate = true; - } - } - - if (generate) - { - if (specificRideType > 90) - { - fprintf(stderr, "No ride or invalid ride specified.\n"); - return 1; - } - - openrct2_setup_rct2_segment(); - PaintIntercept::InitHooks(); - - return generatePaintCode(specificRideType); - } - - for (uint8_t rideType = 0; rideType < RCT2_RIDE_TYPE_COUNT; rideType++) - { - if (specificRideType != RIDE_TYPE_NULL && rideType != specificRideType) - { - continue; - } - - if (!Utils::rideIsImplemented(rideType)) - { - continue; - } - - TestCase testCase = {}; - testCase.rideType = rideType; - - if (GetRideTypeDescriptor(rideType).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)) - { - testCase.trackTypes.push_back(GetRideTypeDescriptor(rideType).StartTrackPiece); - } - else - { - for (int trackType = 0; trackType < 256; trackType++) - { - if (Utils::rideSupportsTrackType(rideType, trackType)) - { - testCase.trackTypes.push_back(trackType); - } - } - } - - testCases.push_back(testCase); - } - - int testCaseCount = (int)testCases.size(); - int testCount = 0; - for (auto&& tc : testCases) - { - testCount += tc.trackTypes.size(); - } - - Write(CLIColour::GREEN, "[==========] "); - Write("Running %d tests from %d test cases.\n", testCount, testCaseCount); - - Write(CLIColour::GREEN, "[----------] "); - Write("Global test environment set-up.\n"); - openrct2_setup_rct2_segment(); - PaintIntercept::InitHooks(); - - int successCount = 0; - std::vector failures; - for (auto&& tc : testCases) - { - const utf8string rideTypeName = RideNames[tc.rideType]; - Write(CLIColour::GREEN, "[----------] "); - Write("%d tests from %s\n", (int)tc.trackTypes.size(), rideTypeName); - - for (auto&& trackType : tc.trackTypes) - { - utf8string trackTypeName; - if (GetRideTypeDescriptor(tc.rideType).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)) - { - trackTypeName = FlatTrackNames[trackType]; - } - else - { - trackTypeName = TrackNames[trackType]; - } - - Write(CLIColour::GREEN, "[ RUN ] "); - Write("%s.%s\n", rideTypeName, trackTypeName); - - std::string out; - int retVal = TestTrack::TestPaintTrackElement(tc.rideType, trackType, &out); - Write("%s", out.c_str()); - switch (retVal) - { - case TEST_SUCCESS: - Write(CLIColour::GREEN, "[ OK ] "); - Write("%s.%s (0 ms)\n", rideTypeName, trackTypeName); - successCount++; - break; - - case TEST_SKIPPED: - Write("Skipped\n"); - // Outputting this as OK because CLion only allows FAILED or OK - Write(CLIColour::YELLOW, "[ OK ] "); - Write("%s.%s (0 ms)\n", rideTypeName, trackTypeName); - successCount++; - break; - - case TEST_FAILED: - utf8string testCaseName = new utf8[64]; - snprintf(testCaseName, 64, "%s.%s", rideTypeName, trackTypeName); - - Write(CLIColour::RED, "[ FAILED ] "); - Write("%s (0 ms)\n", testCaseName); - failures.push_back(testCaseName); - break; - } - } - - Write(CLIColour::GREEN, "[----------] "); - Write("%d tests from %s (0 ms total)\n", (int)tc.trackTypes.size(), rideTypeName); - } - Write("\n"); - - Write(CLIColour::GREEN, "[----------] "); - Write("Global test environment tear-down\n"); - - Write(CLIColour::GREEN, "[==========] "); - Write("%d tests from %d test cases ran. (0 ms total).\n", testCount, testCaseCount); - - Write(Verbosity::QUIET, CLIColour::GREEN, "[ PASSED ] "); - Write(Verbosity::QUIET, "%d tests.\n", successCount); - - if (!failures.empty()) - { - Write(Verbosity::QUIET, CLIColour::RED, "[ FAILED ] "); - Write(Verbosity::QUIET, "%d tests, listed below:\n", (int)failures.size()); - - for (auto&& failure : failures) - { - Write(Verbosity::QUIET, CLIColour::RED, "[ FAILED ] "); - Write(Verbosity::QUIET, "%s\n", failure); - delete[] failure; - } - - Write(Verbosity::QUIET, "\n"); - - Write(Verbosity::QUIET, "%d FAILED TESTS\n", (int)failures.size()); - - return 1; - } - - return 0; -#endif -}