mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #9892 from IntelOrca/fix/4927-giant-screenshot-cropped 

Fix #4927: Giant screenshot cut off at bottom and top
This commit is contained in:
Michael Steenbeek 2019-08-21 22:14:08 +02:00 committed by GitHub
parent 066e6cc619 2dda23d82e
commit f56ec6776b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 322 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
distribution/changelog.txt
View File

@ -1,5 +1,6 @@
0.2.3+ (in development)
------------------------------------------------------------------------
- Fix: [#4927] Giant screenshot cut off at bottom and top.
- Fix: [#7690] Problem with guests freezing on certain tiles of path.
- Fix: [#7883] Headless server log is stored incorrectly if server name contains CJK in Ubuntu
- Fix: [#8136] Excessive lateral G penalty is too excessive.

593
src/openrct2/interface/Screenshot.cpp
View File

@ -92,12 +92,14 @@ void screenshot_check()
}
}
static void screenshot_get_rendered_palette(rct_palette* palette)
static rct_palette screenshot_get_rendered_palette()
{
rct_palette palette;
for (int32_t i = 0; i < 256; i++)
{
palette->entries[i] = gPalette[i];
palette.entries[i] = gPalette[i];
}
return palette;
}
static std::string screenshot_get_park_name()
@ -176,9 +178,7 @@ std::string screenshot_dump_png(rct_drawpixelinfo* dpi)
return "";
}
rct_palette renderedPalette;
screenshot_get_rendered_palette(&renderedPalette);
auto renderedPalette = screenshot_get_rendered_palette();
if (WriteDpiToFile(path->c_str(), dpi, renderedPalette))
{
return *path;
@ -219,90 +219,186 @@ std::string screenshot_dump_png_32bpp(int32_t width, int32_t height, const void*
}
}
void screenshot_giant()
enum class EdgeType
{
int32_t originalRotation = get_current_rotation();
int32_t originalZoom = 0;
LEFT,
TOP,
RIGHT,
BOTTOM
};
rct_window* mainWindow = window_get_main();
rct_viewport* vp = window_get_viewport(mainWindow);
if (mainWindow != nullptr && vp != nullptr)
originalZoom = vp->zoom;
static CoordsXY GetEdgeTile(int32_t mapSize, int32_t rotation, EdgeType edgeType, bool visible)
{
int32_t lower = (visible ? 1 : 0) * 32;
int32_t upper = (visible ? mapSize - 2 : mapSize - 1) * 32;
switch (edgeType)
{
default:
case EdgeType::LEFT:
switch (rotation)
{
default:
case 0:
return { upper, lower };
case 1:
return { upper, upper };
case 2:
return { lower, upper };
case 3:
return { lower, lower };
}
case EdgeType::TOP:
switch (rotation)
{
default:
case 0:
return { lower, lower };
case 1:
return { upper, lower };
case 2:
return { upper, upper };
case 3:
return { lower, upper };
}
case EdgeType::RIGHT:
switch (rotation)
{
default:
case 0:
return { lower, upper };
case 1:
return { lower, lower };
case 2:
return { upper, lower };
case 3:
return { upper, upper };
}
case EdgeType::BOTTOM:
switch (rotation)
{
default:
case 0:
return { upper, upper };
case 1:
return { lower, upper };
case 2:
return { lower, lower };
case 3:
return { upper, lower };
}
}
}
int32_t rotation = originalRotation;
int32_t zoom = originalZoom;
int32_t mapSize = gMapSize;
int32_t resolutionWidth = (mapSize * 32 * 2) >> zoom;
int32_t resolutionHeight = (mapSize * 32 * 1) >> zoom;
static rct_viewport GetGiantViewport(int32_t mapSize, int32_t rotation, int32_t zoom)
{
// Get the tile coordinates of each corner
auto leftTileCoords = GetEdgeTile(mapSize, rotation, EdgeType::LEFT, false);
auto topTileCoords = GetEdgeTile(mapSize, rotation, EdgeType::TOP, true);
auto rightTileCoords = GetEdgeTile(mapSize, rotation, EdgeType::RIGHT, false);
auto bottomTileCoords = GetEdgeTile(mapSize, rotation, EdgeType::BOTTOM, false);
resolutionWidth += 8;
resolutionHeight += 128;
// Centre the coordinates so we don't have a hard crop at the edge of the visible tile
leftTileCoords += CoordsXY(16, 16);
topTileCoords += CoordsXY(16, 16);
rightTileCoords += CoordsXY(16, 16);
bottomTileCoords += CoordsXY(16, 16);
rct_viewport viewport;
viewport.x = 0;
viewport.y = 0;
viewport.width = resolutionWidth;
viewport.height = resolutionHeight;
viewport.view_width = viewport.width;
viewport.view_height = viewport.height;
viewport.var_11 = 0;
viewport.flags = vp->flags;
// For the top tile we want to add a certain amount to account for any tall elements
auto topTileHeight = tile_element_height(topTileCoords) + 128;
int32_t centreX = (mapSize / 2) * 32 + 16;
int32_t centreY = (mapSize / 2) * 32 + 16;
// Calculate the viewport bounds
int32_t left = translate_3d_to_2d_with_z(rotation, CoordsXYZ(leftTileCoords, 0)).x;
int32_t top = translate_3d_to_2d_with_z(rotation, CoordsXYZ(topTileCoords, topTileHeight)).y;
int32_t right = translate_3d_to_2d_with_z(rotation, CoordsXYZ(rightTileCoords, 0)).x;
int32_t bottom = translate_3d_to_2d_with_z(rotation, CoordsXYZ(bottomTileCoords, 0)).y;
int32_t z = tile_element_height({ centreX, centreY });
CoordsXYZ centreCoords3d = { centreX, centreY, z };
auto centreCoords2d = translate_3d_to_2d_with_z(rotation, centreCoords3d);
viewport.view_x = centreCoords2d.x - ((viewport.view_width << zoom) / 2);
viewport.view_y = centreCoords2d.y - ((viewport.view_height << zoom) / 2);
rct_viewport viewport{};
viewport.view_x = left;
viewport.view_y = top;
viewport.view_width = right - left;
viewport.view_height = bottom - top;
viewport.width = viewport.view_width >> zoom;
viewport.height = viewport.view_height >> zoom;
viewport.zoom = zoom;
gCurrentRotation = rotation;
return viewport;
}
static rct_drawpixelinfo RenderViewport(IDrawingEngine* drawingEngine, const rct_viewport& viewport)
{
// Ensure sprites appear regardless of rotation
reset_all_sprite_quadrant_placements();
rct_drawpixelinfo dpi;
dpi.x = 0;
dpi.y = 0;
dpi.width = resolutionWidth;
dpi.height = resolutionHeight;
dpi.pitch = 0;
dpi.zoom_level = 0;
dpi.bits = (uint8_t*)malloc(dpi.width * dpi.height);
if (gConfigGeneral.transparent_screenshot)
dpi.width = viewport.width;
dpi.height = viewport.height;
dpi.bits = (uint8_t*)malloc((size_t)dpi.width * dpi.height);
if (dpi.bits == nullptr)
{
std::memset(dpi.bits, PALETTE_INDEX_0, dpi.width * dpi.height);
viewport.flags |= VIEWPORT_FLAG_TRANSPARENT_BACKGROUND;
throw std::runtime_error("Giant screenshot failed, unable to allocate memory for image.");
}
auto drawingEngine = std::make_unique<X8DrawingEngine>(GetContext()->GetUiContext());
dpi.DrawingEngine = drawingEngine.get();
if (viewport.flags & VIEWPORT_FLAG_TRANSPARENT_BACKGROUND)
{
std::memset(dpi.bits, PALETTE_INDEX_0, (size_t)dpi.width * dpi.height);
}
std::unique_ptr<X8DrawingEngine> tempDrawingEngine;
if (drawingEngine == nullptr)
{
tempDrawingEngine = std::make_unique<X8DrawingEngine>(GetContext()->GetUiContext());
drawingEngine = tempDrawingEngine.get();
}
dpi.DrawingEngine = drawingEngine;
viewport_render(&dpi, &viewport, 0, 0, viewport.width, viewport.height);
return dpi;
}
auto path = screenshot_get_next_path();
if (path == opt::nullopt)
void screenshot_giant()
{
rct_drawpixelinfo dpi;
try
{
log_error("Giant screenshot failed, unable to find a suitable destination path.");
context_show_error(STR_SCREENSHOT_FAILED, STR_NONE);
return;
auto path = screenshot_get_next_path();
if (path == opt::nullopt)
{
throw std::runtime_error("Giant screenshot failed, unable to find a suitable destination path.");
}
int32_t rotation = get_current_rotation();
int32_t zoom = 0;
auto mainWindow = window_get_main();
auto vp = window_get_viewport(mainWindow);
if (mainWindow != nullptr && vp != nullptr)
{
zoom = vp->zoom;
}
auto viewport = GetGiantViewport(gMapSize, rotation, zoom);
if (vp != nullptr)
{
viewport.flags = vp->flags;
}
if (gConfigGeneral.transparent_screenshot)
{
viewport.flags |= VIEWPORT_FLAG_TRANSPARENT_BACKGROUND;
}
dpi = RenderViewport(nullptr, viewport);
auto renderedPalette = screenshot_get_rendered_palette();
WriteDpiToFile(path->c_str(), &dpi, renderedPalette);
// Show user that screenshot saved successfully
set_format_arg(0, rct_string_id, STR_STRING);
set_format_arg(2, char*, path_get_filename(path->c_str()));
context_show_error(STR_SCREENSHOT_SAVED_AS, STR_NONE);
}
catch (const std::exception& e)
{
log_error("%s", e.what());
context_show_error(STR_SCREENSHOT_FAILED, STR_NONE);
}
rct_palette renderedPalette;
screenshot_get_rendered_palette(&renderedPalette);
WriteDpiToFile(path->c_str(), &dpi, renderedPalette);
free(dpi.bits);
// Show user that screenshot saved successfully
set_format_arg(0, rct_string_id, STR_STRING);
set_format_arg(2, char*, path_get_filename(path->c_str()));
context_show_error(STR_SCREENSHOT_SAVED_AS, STR_NONE);
}
static void benchgfx_render_screenshots(const char* inputPath, std::unique_ptr<IContext>& context, uint32_t iterationCount)
@ -315,62 +411,32 @@ static void benchgfx_render_screenshots(const char* inputPath, std::unique_ptr<I
gIntroState = INTRO_STATE_NONE;
gScreenFlags = SCREEN_FLAGS_PLAYING;
int32_t mapSize = gMapSize;
int32_t resolutionWidth = (mapSize * 32 * 2);
int32_t resolutionHeight = (mapSize * 32 * 1);
resolutionWidth += 8;
resolutionHeight += 128;
rct_viewport viewport;
viewport.x = 0;
viewport.y = 0;
viewport.width = resolutionWidth;
viewport.height = resolutionHeight;
viewport.view_width = viewport.width;
viewport.view_height = viewport.height;
viewport.var_11 = 0;
viewport.flags = 0;
int32_t customX = (gMapSize / 2) * 32 + 16;
int32_t customY = (gMapSize / 2) * 32 + 16;
int32_t x = 0, y = 0;
int32_t z = tile_element_height({ customX, customY });
x = customY - customX;
y = ((customX + customY) / 2) - z;
viewport.view_x = x - ((viewport.view_width) / 2);
viewport.view_y = y - ((viewport.view_height) / 2);
viewport.zoom = 0;
gCurrentRotation = 0;
// Ensure sprites appear regardless of rotation
reset_all_sprite_quadrant_placements();
rct_drawpixelinfo dpi;
dpi.x = 0;
dpi.y = 0;
dpi.width = resolutionWidth;
dpi.height = resolutionHeight;
dpi.pitch = 0;
dpi.bits = (uint8_t*)malloc(dpi.width * dpi.height);
auto startTime = std::chrono::high_resolution_clock::now();
for (uint32_t i = 0; i < iterationCount; i++)
try
{
// Render at various zoom levels
dpi.zoom_level = i & 3;
viewport_render(&dpi, &viewport, 0, 0, viewport.width, viewport.height);
}
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<float> duration = endTime - startTime;
char engine_name[128];
rct_string_id engine_id = DrawingEngineStringIds[drawing_engine_get_type()];
format_string(engine_name, sizeof(engine_name), engine_id, nullptr);
Console::WriteLine(
"Rendering %d times with drawing engine %s took %.2f seconds.", iterationCount, engine_name, duration.count());
auto startTime = std::chrono::high_resolution_clock::now();
for (uint32_t i = 0; i < iterationCount; i++)
{
// Render at various zoom levels
auto viewport = GetGiantViewport(gMapSize, get_current_rotation(), 0);
viewport.zoom = i & 3;
dpi = RenderViewport(nullptr, viewport);
free(dpi.bits);
dpi.bits = nullptr;
}
auto endTime = std::chrono::high_resolution_clock::now();
std::chrono::duration<float> duration = endTime - startTime;
auto engineStringId = DrawingEngineStringIds[DRAWING_ENGINE_SOFTWARE];
auto engineName = format_string(engineStringId, nullptr);
std::printf(
"Rendering %u times with drawing engine %s took %.2f seconds.", iterationCount, engineName.c_str(),
duration.count());
}
catch (const std::exception& e)
{
std::fprintf(stderr, "%s", e.what());
}
free(dpi.bits);
}
@ -406,168 +472,19 @@ int32_t cmdline_for_gfxbench(const char** argv, int32_t argc)
return 1;
}
int32_t cmdline_for_screenshot(const char** argv, int32_t argc, ScreenshotOptions* options)
static void ApplyOptions(const ScreenshotOptions* options, rct_viewport& viewport)
{
// Don't include options in the count (they have been handled by CommandLine::ParseOptions already)
for (int32_t i = 0; i < argc; i++)
{
if (argv[i][0] == '-')
{
// Setting argc to i works, because options can only be at the end of the command
argc = i;
break;
}
}
bool giantScreenshot = (argc == 5) && _stricmp(argv[2], "giant") == 0;
if (argc != 4 && argc != 8 && !giantScreenshot)
{
std::printf("Usage: openrct2 screenshot <file> <output_image> <width> <height> [<x> <y> <zoom> <rotation>]\n");
std::printf("Usage: openrct2 screenshot <file> <output_image> giant <zoom> <rotation>\n");
return -1;
}
core_init();
bool customLocation = false;
bool centreMapX = false;
bool centreMapY = false;
int32_t resolutionWidth, resolutionHeight, customX = 0, customY = 0, customZoom, customRotation = 0;
const char* inputPath = argv[0];
const char* outputPath = argv[1];
if (giantScreenshot)
{
resolutionWidth = 0;
resolutionHeight = 0;
customLocation = true;
centreMapX = true;
centreMapY = true;
customZoom = std::atoi(argv[3]);
customRotation = std::atoi(argv[4]) & 3;
}
else
{
resolutionWidth = std::atoi(argv[2]);
resolutionHeight = std::atoi(argv[3]);
if (argc == 8)
{
customLocation = true;
if (argv[4][0] == 'c')
centreMapX = true;
else
customX = std::atoi(argv[4]);
if (argv[5][0] == 'c')
centreMapY = true;
else
customY = std::atoi(argv[5]);
customZoom = std::atoi(argv[6]);
customRotation = std::atoi(argv[7]) & 3;
}
else
{
customZoom = 0;
}
}
gOpenRCT2Headless = true;
auto context = CreateContext();
if (!context->Initialise())
{
std::puts("Failed to initialize context.");
return -1;
}
drawing_engine_init();
try
{
context->LoadParkFromFile(inputPath);
}
catch (const std::exception& e)
{
std::printf("%s\n", e.what());
drawing_engine_dispose();
return -1;
}
gIntroState = INTRO_STATE_NONE;
gScreenFlags = SCREEN_FLAGS_PLAYING;
int32_t mapSize = gMapSize;
if (resolutionWidth == 0 || resolutionHeight == 0)
{
resolutionWidth = (mapSize * 32 * 2) >> customZoom;
resolutionHeight = (mapSize * 32 * 1) >> customZoom;
resolutionWidth += 8;
resolutionHeight += 128;
}
rct_viewport viewport;
viewport.x = 0;
viewport.y = 0;
viewport.width = resolutionWidth;
viewport.height = resolutionHeight;
viewport.view_width = viewport.width;
viewport.view_height = viewport.height;
viewport.var_11 = 0;
viewport.flags = 0;
if (customLocation)
{
if (centreMapX)
customX = (mapSize / 2) * 32 + 16;
if (centreMapY)
customY = (mapSize / 2) * 32 + 16;
int32_t z = tile_element_height({ customX, customY });
CoordsXYZ coords3d = { customX, customY, z };
auto coords2d = translate_3d_to_2d_with_z(customRotation, coords3d);
viewport.view_x = coords2d.x - ((viewport.view_width << customZoom) / 2);
viewport.view_y = coords2d.y - ((viewport.view_height << customZoom) / 2);
viewport.zoom = customZoom;
gCurrentRotation = customRotation;
}
else
{
viewport.view_x = gSavedViewX - (viewport.view_width / 2);
viewport.view_y = gSavedViewY - (viewport.view_height / 2);
viewport.zoom = gSavedViewZoom;
gCurrentRotation = gSavedViewRotation;
}
if (options->weather != 0)
{
if (options->weather < 1 || options->weather > 6)
{
std::printf("Weather can only be set to an integer value from 1 till 6.");
drawing_engine_dispose();
return -1;
throw std::runtime_error("Weather can only be set to an integer value from 1 till 6.");
}
uint8_t customWeather = options->weather - 1;
climate_force_weather(customWeather);
}
// Ensure sprites appear regardless of rotation
reset_all_sprite_quadrant_placements();
rct_drawpixelinfo dpi;
dpi.x = 0;
dpi.y = 0;
dpi.width = resolutionWidth;
dpi.height = resolutionHeight;
dpi.pitch = 0;
dpi.zoom_level = 0;
dpi.bits = (uint8_t*)malloc(dpi.width * dpi.height);
dpi.DrawingEngine = context->GetDrawingEngine();
std::memset(dpi.bits, PALETTE_INDEX_0, dpi.width * dpi.height);
if (options->hide_guests)
{
viewport.flags |= VIEWPORT_FLAG_INVISIBLE_PEEPS;
@ -607,16 +524,140 @@ int32_t cmdline_for_screenshot(const char** argv, int32_t argc, ScreenshotOption
{
viewport.flags |= VIEWPORT_FLAG_TRANSPARENT_BACKGROUND;
}
}
viewport_render(&dpi, &viewport, 0, 0, viewport.width, viewport.height);
int32_t cmdline_for_screenshot(const char** argv, int32_t argc, ScreenshotOptions* options)
{
// Don't include options in the count (they have been handled by CommandLine::ParseOptions already)
for (int32_t i = 0; i < argc; i++)
{
if (argv[i][0] == '-')
{
// Setting argc to i works, because options can only be at the end of the command
argc = i;
break;
}
}
rct_palette renderedPalette;
screenshot_get_rendered_palette(&renderedPalette);
bool giantScreenshot = (argc == 5) && _stricmp(argv[2], "giant") == 0;
if (argc != 4 && argc != 8 && !giantScreenshot)
{
std::printf("Usage: openrct2 screenshot <file> <output_image> <width> <height> [<x> <y> <zoom> <rotation>]\n");
std::printf("Usage: openrct2 screenshot <file> <output_image> giant <zoom> <rotation>\n");
return -1;
}
WriteDpiToFile(outputPath, &dpi, renderedPalette);
int32_t exitCode = 1;
rct_drawpixelinfo dpi;
try
{
core_init();
bool customLocation = false;
bool centreMapX = false;
bool centreMapY = false;
const char* inputPath = argv[0];
const char* outputPath = argv[1];
gOpenRCT2Headless = true;
auto context = CreateContext();
if (!context->Initialise())
{
throw std::runtime_error("Failed to initialize context.");
}
drawing_engine_init();
context->LoadParkFromFile(inputPath);
gIntroState = INTRO_STATE_NONE;
gScreenFlags = SCREEN_FLAGS_PLAYING;
rct_viewport viewport{};
if (giantScreenshot)
{
auto zoom = std::atoi(argv[3]);
auto rotation = std::atoi(argv[4]) & 3;
viewport = GetGiantViewport(gMapSize, rotation, zoom);
}
else
{
int32_t resolutionWidth = std::atoi(argv[2]);
int32_t resolutionHeight = std::atoi(argv[3]);
int32_t customX = 0;
int32_t customY = 0;
int32_t customZoom = 0;
int32_t customRotation = 0;
if (argc == 8)
{
customLocation = true;
if (argv[4][0] == 'c')
centreMapX = true;
else
customX = std::atoi(argv[4]);
if (argv[5][0] == 'c')
centreMapY = true;
else
customY = std::atoi(argv[5]);
customZoom = std::atoi(argv[6]);
customRotation = std::atoi(argv[7]) & 3;
}
int32_t mapSize = gMapSize;
if (resolutionWidth == 0 || resolutionHeight == 0)
{
resolutionWidth = (mapSize * 32 * 2) >> customZoom;
resolutionHeight = (mapSize * 32 * 1) >> customZoom;
resolutionWidth += 8;
resolutionHeight += 128;
}
viewport.width = resolutionWidth;
viewport.height = resolutionHeight;
viewport.view_width = viewport.width;
viewport.view_height = viewport.height;
if (customLocation)
{
if (centreMapX)
customX = (mapSize / 2) * 32 + 16;
if (centreMapY)
customY = (mapSize / 2) * 32 + 16;
int32_t z = tile_element_height({ customX, customY });
CoordsXYZ coords3d = { customX, customY, z };
auto coords2d = translate_3d_to_2d_with_z(customRotation, coords3d);
viewport.view_x = coords2d.x - ((viewport.view_width << customZoom) / 2);
viewport.view_y = coords2d.y - ((viewport.view_height << customZoom) / 2);
viewport.zoom = customZoom;
gCurrentRotation = customRotation;
}
else
{
viewport.view_x = gSavedViewX - (viewport.view_width / 2);
viewport.view_y = gSavedViewY - (viewport.view_height / 2);
viewport.zoom = gSavedViewZoom;
gCurrentRotation = gSavedViewRotation;
}
}
ApplyOptions(options, viewport);
dpi = RenderViewport(nullptr, viewport);
auto renderedPalette = screenshot_get_rendered_palette();
WriteDpiToFile(outputPath, &dpi, renderedPalette);
}
catch (const std::exception& e)
{
std::printf("%s\n", e.what());
exitCode = -1;
}
free(dpi.bits);
drawing_engine_dispose();
return 1;
return exitCode;
}

4
src/openrct2/interface/Viewport.cpp
View File

@ -795,7 +795,7 @@ void viewport_update_smart_vehicle_follow(rct_window* window)
* ebp: bottom
*/
void viewport_render(
rct_drawpixelinfo* dpi, rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom,
rct_drawpixelinfo* dpi, const rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom,
std::vector<paint_session>* sessions)
{
if (right <= viewport->x)
@ -885,7 +885,7 @@ static void viewport_paint_column(paint_session* session)
* ebp: bottom
*/
void viewport_paint(
rct_viewport* viewport, rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom,
const rct_viewport* viewport, rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom,
std::vector<paint_session>* sessions)
{
uint32_t viewFlags = viewport->flags;

4
src/openrct2/interface/Viewport.h
View File

@ -131,10 +131,10 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
void viewport_update_smart_staff_follow(rct_window* window, Peep* peep);
void viewport_update_smart_vehicle_follow(rct_window* window);
void viewport_render(
rct_drawpixelinfo* dpi, rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom,
rct_drawpixelinfo* dpi, const rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom,
std::vector<paint_session>* sessions = nullptr);
void viewport_paint(
rct_viewport* viewport, rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom,
const rct_viewport* viewport, rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom,
std::vector<paint_session>* sessions = nullptr);
void viewport_adjust_for_map_height(int16_t* x, int16_t* y, int16_t* z);