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

Using dpi refs in most remaining window defs

This commit is contained in:
Gymnasiast 2023-04-03 21:21:52 +02:00 committed by duncanspumpkin
parent 9c2d5b9fef
commit 96d77ed8f7
42 changed files with 431 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/openrct2-ui/drawing/engines/opengl/OpenGLDrawingEngine.cpp
View File

@ -325,7 +325,7 @@ public:
_drawingContext->CalculcateClipping(&_bitsDPI); _drawingContext->CalculcateClipping(&_bitsDPI);
WindowUpdateAllViewports(); WindowUpdateAllViewports();
WindowDrawAll(&_bitsDPI, 0, 0, _width, _height); WindowDrawAll(_bitsDPI, 0, 0, _width, _height);
} }
void PaintWeather() override void PaintWeather() override

2
src/openrct2-ui/interface/Widget.cpp
View File

@ -722,7 +722,7 @@ static void WidgetScrollDraw(DrawPixelInfo* dpi, WindowBase& w, WidgetIndex widg
// Draw the scroll contents // Draw the scroll contents
if (scroll_dpi.width > 0 && scroll_dpi.height > 0) if (scroll_dpi.width > 0 && scroll_dpi.height > 0)
WindowEventScrollPaintCall(&w, &scroll_dpi, scrollIndex); WindowEventScrollPaintCall(&w, scroll_dpi, scrollIndex);
} }
static void WidgetHScrollbarDraw( static void WidgetHScrollbarDraw(

18
src/openrct2-ui/interface/Window.cpp
View File

@ -629,14 +629,14 @@ void WindowInitScrollWidgets(WindowBase& w)
* *
* rct2: 0x006EB15C * rct2: 0x006EB15C
*/ */
void WindowDrawWidgets(WindowBase& w, DrawPixelInfo* dpi) void WindowDrawWidgets(WindowBase& w, DrawPixelInfo& dpi)
{ {
Widget* widget; Widget* widget;
WidgetIndex widgetIndex; WidgetIndex widgetIndex;
if ((w.flags & WF_TRANSPARENT) && !(w.flags & WF_NO_BACKGROUND)) if ((w.flags & WF_TRANSPARENT) && !(w.flags & WF_NO_BACKGROUND))
GfxFilterRect( GfxFilterRect(
dpi, { w.windowPos, w.windowPos + ScreenCoordsXY{ w.width - 1, w.height - 1 } }, FilterPaletteID::Palette51); &dpi, { w.windowPos, w.windowPos + ScreenCoordsXY{ w.width - 1, w.height - 1 } }, FilterPaletteID::Palette51);
// todo: some code missing here? Between 006EB18C and 006EB260 // todo: some code missing here? Between 006EB18C and 006EB260
@ -646,14 +646,14 @@ void WindowDrawWidgets(WindowBase& w, DrawPixelInfo* dpi)
if (widget->IsVisible()) if (widget->IsVisible())
{ {
// Check if widget is outside the draw region // Check if widget is outside the draw region
if (w.windowPos.x + widget->left < dpi->x + dpi->width && w.windowPos.x + widget->right >= dpi->x) if (w.windowPos.x + widget->left < dpi.x + dpi.width && w.windowPos.x + widget->right >= dpi.x)
{ {
if (w.windowPos.y + widget->top < dpi->y + dpi->height && w.windowPos.y + widget->bottom >= dpi->y) if (w.windowPos.y + widget->top < dpi.y + dpi.height && w.windowPos.y + widget->bottom >= dpi.y)
{ {
if (w.IsLegacy()) if (w.IsLegacy())
WidgetDraw(dpi, w, widgetIndex); WidgetDraw(&dpi, w, widgetIndex);
else else
w.OnDrawWidget(widgetIndex, *dpi); w.OnDrawWidget(widgetIndex, dpi);
} }
} }
} }
@ -665,7 +665,7 @@ void WindowDrawWidgets(WindowBase& w, DrawPixelInfo* dpi)
if (w.flags & WF_WHITE_BORDER_MASK) if (w.flags & WF_WHITE_BORDER_MASK)
{ {
GfxFillRectInset( GfxFillRectInset(
dpi, { w.windowPos, w.windowPos + ScreenCoordsXY{ w.width - 1, w.height - 1 } }, COLOUR_WHITE, &dpi, { w.windowPos, w.windowPos + ScreenCoordsXY{ w.width - 1, w.height - 1 } }, COLOUR_WHITE,
INSET_RECT_FLAG_FILL_NONE); INSET_RECT_FLAG_FILL_NONE);
} }
} }
@ -710,7 +710,7 @@ bool Window::IsLegacy()
void Window::OnDraw(DrawPixelInfo& dpi) void Window::OnDraw(DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
} }
void Window::OnDrawWidget(WidgetIndex widgetIndex, DrawPixelInfo& dpi) void Window::OnDrawWidget(WidgetIndex widgetIndex, DrawPixelInfo& dpi)
@ -760,7 +760,7 @@ void Window::SetCheckboxValue(WidgetIndex widgetIndex, bool value)
void Window::DrawWidgets(DrawPixelInfo& dpi) void Window::DrawWidgets(DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
} }
void Window::Close() void Window::Close()

4
src/openrct2-ui/scripting/CustomWindow.cpp
View File

@ -530,14 +530,14 @@ namespace OpenRCT2::Ui::Windows
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
if (viewport != nullptr) if (viewport != nullptr)
{ {
auto widgetIndex = GetViewportWidgetIndex(); auto widgetIndex = GetViewportWidgetIndex();
if (WidgetIsVisible(*this, widgetIndex.value_or(false))) if (WidgetIsVisible(*this, widgetIndex.value_or(false)))
{ {
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
} }
} }
} }

2
src/openrct2-ui/windows/Banner.cpp
View File

@ -262,7 +262,7 @@ public:
if (viewport != nullptr) if (viewport != nullptr)
{ {
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
} }
} }

2
src/openrct2-ui/windows/DemolishRidePrompt.cpp
View File

@ -76,7 +76,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
auto currentRide = GetRide(rideId); auto currentRide = GetRide(rideId);
if (currentRide != nullptr) if (currentRide != nullptr)

30
src/openrct2-ui/windows/EditorObjectSelection.cpp
View File

@ -1073,8 +1073,8 @@ public:
DrawTextEllipsised(dpi, screenPos, _width, STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::CENTRE }); DrawTextEllipsised(dpi, screenPos, _width, STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::CENTRE });
} }
DrawDescriptions(&dpi); DrawDescriptions(dpi);
DrawDebugData(&dpi); DrawDebugData(dpi);
} }
private: private:
@ -1185,7 +1185,7 @@ private:
_listItems.shrink_to_fit(); _listItems.shrink_to_fit();
} }
void DrawDescriptions(DrawPixelInfo* dpi) void DrawDescriptions(DrawPixelInfo& dpi)
{ {
const auto& widget = widgets[WIDX_PREVIEW]; const auto& widget = widgets[WIDX_PREVIEW];
auto screenPos = windowPos + ScreenCoordsXY{ widgets[WIDX_LIST].right + 4, widget.bottom + 23 }; auto screenPos = windowPos + ScreenCoordsXY{ widgets[WIDX_LIST].right + 4, widget.bottom + 23 };
@ -1194,7 +1194,7 @@ private:
if (_loadedObject->IsCompatibilityObject()) if (_loadedObject->IsCompatibilityObject())
{ {
screenPos.y += DrawTextWrapped( screenPos.y += DrawTextWrapped(
*dpi, screenPos, _width2, STR_OBJECT_SELECTION_COMPAT_OBJECT_DESCRIPTION, {}, dpi, screenPos, _width2, STR_OBJECT_SELECTION_COMPAT_OBJECT_DESCRIPTION, {},
{ COLOUR_BRIGHT_RED }) { COLOUR_BRIGHT_RED })
+ LIST_ROW_HEIGHT; + LIST_ROW_HEIGHT;
} }
@ -1206,7 +1206,7 @@ private:
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const char*>(description.c_str()); ft.Add<const char*>(description.c_str());
screenPos.y += DrawTextWrapped(*dpi, screenPos, _width2, STR_WINDOW_COLOUR_2_STRINGID, ft) + LIST_ROW_HEIGHT; screenPos.y += DrawTextWrapped(dpi, screenPos, _width2, STR_WINDOW_COLOUR_2_STRINGID, ft) + LIST_ROW_HEIGHT;
} }
if (GetSelectedObjectType() == ObjectType::Ride) if (GetSelectedObjectType() == ObjectType::Ride)
{ {
@ -1227,7 +1227,7 @@ private:
} }
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(sells.c_str()); ft.Add<const char*>(sells.c_str());
screenPos.y += DrawTextWrapped(*dpi, screenPos, _width2, STR_RIDE_OBJECT_SHOP_SELLS, ft) + 2; screenPos.y += DrawTextWrapped(dpi, screenPos, _width2, STR_RIDE_OBJECT_SHOP_SELLS, ft) + 2;
} }
} }
else if (GetSelectedObjectType() == ObjectType::SceneryGroup) else if (GetSelectedObjectType() == ObjectType::SceneryGroup)
@ -1235,11 +1235,11 @@ private:
const auto* sceneryGroupObject = reinterpret_cast<SceneryGroupObject*>(_loadedObject.get()); const auto* sceneryGroupObject = reinterpret_cast<SceneryGroupObject*>(_loadedObject.get());
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint16_t>(sceneryGroupObject->GetNumIncludedObjects()); ft.Add<uint16_t>(sceneryGroupObject->GetNumIncludedObjects());
screenPos.y += DrawTextWrapped(*dpi, screenPos, _width2, STR_INCLUDES_X_OBJECTS, ft) + 2; screenPos.y += DrawTextWrapped(dpi, screenPos, _width2, STR_INCLUDES_X_OBJECTS, ft) + 2;
} }
else if (GetSelectedObjectType() == ObjectType::Music) else if (GetSelectedObjectType() == ObjectType::Music)
{ {
screenPos.y += DrawTextWrapped(*dpi, screenPos, _width2, STR_MUSIC_OBJECT_TRACK_HEADER) + 2; screenPos.y += DrawTextWrapped(dpi, screenPos, _width2, STR_MUSIC_OBJECT_TRACK_HEADER) + 2;
const auto* musicObject = reinterpret_cast<MusicObject*>(_loadedObject.get()); const auto* musicObject = reinterpret_cast<MusicObject*>(_loadedObject.get());
for (size_t i = 0; i < musicObject->GetTrackCount(); i++) for (size_t i = 0; i < musicObject->GetTrackCount(); i++)
{ {
@ -1252,12 +1252,12 @@ private:
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(track->Name.c_str()); ft.Add<const char*>(track->Name.c_str());
ft.Add<const char*>(track->Composer.c_str()); ft.Add<const char*>(track->Composer.c_str());
screenPos.y += DrawTextWrapped(*dpi, screenPos + ScreenCoordsXY{ 10, 0 }, _width2, stringId, ft); screenPos.y += DrawTextWrapped(dpi, screenPos + ScreenCoordsXY{ 10, 0 }, _width2, stringId, ft);
} }
} }
} }
void DrawDebugData(DrawPixelInfo* dpi) void DrawDebugData(DrawPixelInfo& dpi)
{ {
ObjectListItem* listItem = &_listItems[selected_list_item]; ObjectListItem* listItem = &_listItems[selected_list_item];
auto screenPos = windowPos + ScreenCoordsXY{ width - 5, height - (LIST_ROW_HEIGHT * 6) }; auto screenPos = windowPos + ScreenCoordsXY{ width - 5, height - (LIST_ROW_HEIGHT * 6) };
@ -1265,7 +1265,7 @@ private:
// Draw fallback image warning // Draw fallback image warning
if (_loadedObject && _loadedObject->UsesFallbackImages()) if (_loadedObject && _loadedObject->UsesFallbackImages())
{ {
DrawTextBasic(*dpi, screenPos, STR_OBJECT_USES_FALLBACK_IMAGES, {}, { COLOUR_WHITE, TextAlignment::RIGHT }); DrawTextBasic(dpi, screenPos, STR_OBJECT_USES_FALLBACK_IMAGES, {}, { COLOUR_WHITE, TextAlignment::RIGHT });
} }
screenPos.y += LIST_ROW_HEIGHT; screenPos.y += LIST_ROW_HEIGHT;
@ -1273,14 +1273,14 @@ private:
if (GetSelectedObjectType() == ObjectType::Ride) if (GetSelectedObjectType() == ObjectType::Ride)
{ {
auto stringId = GetRideTypeStringId(listItem->repositoryItem); auto stringId = GetRideTypeStringId(listItem->repositoryItem);
DrawTextBasic(*dpi, screenPos, stringId, {}, { COLOUR_WHITE, TextAlignment::RIGHT }); DrawTextBasic(dpi, screenPos, stringId, {}, { COLOUR_WHITE, TextAlignment::RIGHT });
} }
screenPos.y += LIST_ROW_HEIGHT; screenPos.y += LIST_ROW_HEIGHT;
// Draw object source // Draw object source
auto stringId = ObjectManagerGetSourceGameString(listItem->repositoryItem->GetFirstSourceGame()); auto stringId = ObjectManagerGetSourceGameString(listItem->repositoryItem->GetFirstSourceGame());
DrawTextBasic(*dpi, screenPos, stringId, {}, { COLOUR_WHITE, TextAlignment::RIGHT }); DrawTextBasic(dpi, screenPos, stringId, {}, { COLOUR_WHITE, TextAlignment::RIGHT });
screenPos.y += LIST_ROW_HEIGHT; screenPos.y += LIST_ROW_HEIGHT;
// Draw object filename // Draw object filename
@ -1290,7 +1290,7 @@ private:
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const utf8*>(path.c_str()); ft.Add<const utf8*>(path.c_str());
DrawTextBasic( DrawTextBasic(
*dpi, { windowPos.x + this->width - 5, screenPos.y }, STR_WINDOW_COLOUR_2_STRINGID, ft, dpi, { windowPos.x + this->width - 5, screenPos.y }, STR_WINDOW_COLOUR_2_STRINGID, ft,
{ COLOUR_BLACK, TextAlignment::RIGHT }); { COLOUR_BLACK, TextAlignment::RIGHT });
screenPos.y += LIST_ROW_HEIGHT; screenPos.y += LIST_ROW_HEIGHT;
} }
@ -1310,7 +1310,7 @@ private:
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const char*>(authorsString.c_str()); ft.Add<const char*>(authorsString.c_str());
DrawTextEllipsised( DrawTextEllipsised(
*dpi, { windowPos.x + width - 5, screenPos.y }, width - widgets[WIDX_LIST].right - 4, dpi, { windowPos.x + width - 5, screenPos.y }, width - widgets[WIDX_LIST].right - 4,
STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::RIGHT }); STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::RIGHT });
} }
} }

58
src/openrct2-ui/windows/EditorObjectiveOptions.cpp
View File

@ -210,10 +210,10 @@ public:
switch (page) switch (page)
{ {
case WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_MAIN: case WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_MAIN:
OnDrawMain(&dpi); OnDrawMain(dpi);
break; break;
case WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_RIDES: case WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_RIDES:
OnDrawRides(&dpi); OnDrawRides(dpi);
break; break;
} }
} }
@ -332,7 +332,7 @@ private:
ResizeFrameWithPage(); ResizeFrameWithPage();
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
Widget* widget; Widget* widget;
int32_t spriteIndex; int32_t spriteIndex;
@ -344,7 +344,7 @@ private:
if (page == WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_MAIN) if (page == WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_MAIN)
spriteIndex += (frame_no / 4) % 16; spriteIndex += (frame_no / 4) % 16;
GfxDrawSprite(*dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget->left, widget->top }); GfxDrawSprite(dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget->left, widget->top });
// Tab 2 // Tab 2
if (!IsWidgetDisabled(WIDX_TAB_2)) if (!IsWidgetDisabled(WIDX_TAB_2))
@ -354,7 +354,7 @@ private:
if (page == WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_RIDES) if (page == WINDOW_EDITOR_OBJECTIVE_OPTIONS_PAGE_RIDES)
spriteIndex += (frame_no / 4) % 16; spriteIndex += (frame_no / 4) % 16;
GfxDrawSprite(*dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget->left, widget->top }); GfxDrawSprite(dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget->left, widget->top });
} }
} }
@ -835,23 +835,23 @@ private:
* *
* rct2: 0x0067161C * rct2: 0x0067161C
*/ */
void OnDrawMain(DrawPixelInfo* dpi) void OnDrawMain(DrawPixelInfo& dpi)
{ {
int32_t widthToSet; int32_t widthToSet;
StringId stringId; StringId stringId;
DrawWidgets(*dpi); DrawWidgets(dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
// Objective label // Objective label
auto screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_OBJECTIVE].top }; auto screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_OBJECTIVE].top };
DrawTextBasic(*dpi, screenCoords, STR_OBJECTIVE_WINDOW); DrawTextBasic(dpi, screenCoords, STR_OBJECTIVE_WINDOW);
// Objective value // Objective value
screenCoords = windowPos + ScreenCoordsXY{ widgets[WIDX_OBJECTIVE].left + 1, widgets[WIDX_OBJECTIVE].top }; screenCoords = windowPos + ScreenCoordsXY{ widgets[WIDX_OBJECTIVE].left + 1, widgets[WIDX_OBJECTIVE].top };
auto ft = Formatter(); auto ft = Formatter();
ft.Add<StringId>(ObjectiveDropdownOptionNames[gScenarioObjective.Type]); ft.Add<StringId>(ObjectiveDropdownOptionNames[gScenarioObjective.Type]);
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft); DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft);
if (widgets[WIDX_OBJECTIVE_ARG_1].type != WindowWidgetType::Empty) if (widgets[WIDX_OBJECTIVE_ARG_1].type != WindowWidgetType::Empty)
{ {
@ -880,7 +880,7 @@ private:
stringId = STR_WINDOW_OBJECTIVE_EXCITEMENT_RATING; stringId = STR_WINDOW_OBJECTIVE_EXCITEMENT_RATING;
break; break;
} }
DrawTextBasic(*dpi, screenCoords, stringId); DrawTextBasic(dpi, screenCoords, stringId);
// Objective argument 1 value // Objective argument 1 value
screenCoords = windowPos screenCoords = windowPos
@ -913,21 +913,21 @@ private:
ft.Add<money64>(gScenarioObjective.Currency); ft.Add<money64>(gScenarioObjective.Currency);
break; break;
} }
DrawTextBasic(*dpi, screenCoords, stringId, ft, COLOUR_BLACK); DrawTextBasic(dpi, screenCoords, stringId, ft, COLOUR_BLACK);
} }
if (widgets[WIDX_OBJECTIVE_ARG_2].type != WindowWidgetType::Empty) if (widgets[WIDX_OBJECTIVE_ARG_2].type != WindowWidgetType::Empty)
{ {
// Objective argument 2 label // Objective argument 2 label
screenCoords = windowPos + ScreenCoordsXY{ 28, widgets[WIDX_OBJECTIVE_ARG_2].top }; screenCoords = windowPos + ScreenCoordsXY{ 28, widgets[WIDX_OBJECTIVE_ARG_2].top };
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_OBJECTIVE_DATE); DrawTextBasic(dpi, screenCoords, STR_WINDOW_OBJECTIVE_DATE);
// Objective argument 2 value // Objective argument 2 value
screenCoords = windowPos screenCoords = windowPos
+ ScreenCoordsXY{ widgets[WIDX_OBJECTIVE_ARG_2].left + 1, widgets[WIDX_OBJECTIVE_ARG_2].top }; + ScreenCoordsXY{ widgets[WIDX_OBJECTIVE_ARG_2].left + 1, widgets[WIDX_OBJECTIVE_ARG_2].top };
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>((gScenarioObjective.Year * MONTH_COUNT) - 1); ft.Add<uint16_t>((gScenarioObjective.Year * MONTH_COUNT) - 1);
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_OBJECTIVE_VALUE_DATE, ft); DrawTextBasic(dpi, screenCoords, STR_WINDOW_OBJECTIVE_VALUE_DATE, ft);
} }
// Park name // Park name
@ -941,7 +941,7 @@ private:
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const char*>(parkName); ft.Add<const char*>(parkName);
DrawTextEllipsised(*dpi, screenCoords, widthToSet, STR_WINDOW_PARK_NAME, ft); DrawTextEllipsised(dpi, screenCoords, widthToSet, STR_WINDOW_PARK_NAME, ft);
} }
// Scenario name // Scenario name
@ -951,11 +951,11 @@ private:
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const char*>(gScenarioName.c_str()); ft.Add<const char*>(gScenarioName.c_str());
DrawTextEllipsised(*dpi, screenCoords, widthToSet, STR_WINDOW_SCENARIO_NAME, ft); DrawTextEllipsised(dpi, screenCoords, widthToSet, STR_WINDOW_SCENARIO_NAME, ft);
// Scenario details label // Scenario details label
screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_DETAILS].top }; screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_DETAILS].top };
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_PARK_DETAILS); DrawTextBasic(dpi, screenCoords, STR_WINDOW_PARK_DETAILS);
// Scenario details value // Scenario details value
screenCoords = windowPos + ScreenCoordsXY{ 16, widgets[WIDX_DETAILS].top + 10 }; screenCoords = windowPos + ScreenCoordsXY{ 16, widgets[WIDX_DETAILS].top + 10 };
@ -964,17 +964,17 @@ private:
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(STR_STRING); ft.Add<StringId>(STR_STRING);
ft.Add<const char*>(gScenarioDetails.c_str()); ft.Add<const char*>(gScenarioDetails.c_str());
DrawTextWrapped(*dpi, screenCoords, widthToSet, STR_BLACK_STRING, ft); DrawTextWrapped(dpi, screenCoords, widthToSet, STR_BLACK_STRING, ft);
// Scenario category label // Scenario category label
screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_CATEGORY].top }; screenCoords = windowPos + ScreenCoordsXY{ 8, widgets[WIDX_CATEGORY].top };
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_SCENARIO_GROUP); DrawTextBasic(dpi, screenCoords, STR_WINDOW_SCENARIO_GROUP);
// Scenario category value // Scenario category value
screenCoords = windowPos + ScreenCoordsXY{ widgets[WIDX_CATEGORY].left + 1, widgets[WIDX_CATEGORY].top }; screenCoords = windowPos + ScreenCoordsXY{ widgets[WIDX_CATEGORY].left + 1, widgets[WIDX_CATEGORY].top };
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(ScenarioCategoryStringIds[gScenarioCategory]); ft.Add<StringId>(ScenarioCategoryStringIds[gScenarioCategory]);
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft); DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft);
} }
#pragma endregion #pragma endregion
@ -1094,40 +1094,40 @@ private:
* *
* rct2: 0x00672340 * rct2: 0x00672340
*/ */
void OnDrawRides(DrawPixelInfo* dpi) void OnDrawRides(DrawPixelInfo& dpi)
{ {
DrawWidgets(*dpi); DrawWidgets(dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
DrawTextBasic( DrawTextBasic(
*dpi, windowPos + ScreenCoordsXY{ 6, widgets[WIDX_PAGE_BACKGROUND].top + 3 }, STR_WINDOW_PRESERVATION_ORDER); dpi, windowPos + ScreenCoordsXY{ 6, widgets[WIDX_PAGE_BACKGROUND].top + 3 }, STR_WINDOW_PRESERVATION_ORDER);
} }
/** /**
* *
* rct2: 0x0067236F * rct2: 0x0067236F
*/ */
void OnScrollDrawRides(DrawPixelInfo* dpi, int32_t scrollIndex) void OnScrollDrawRides(DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
int32_t colour = ColourMapA[colours[1]].mid_light; int32_t colour = ColourMapA[colours[1]].mid_light;
GfxFillRect(dpi, { { dpi->x, dpi->y }, { dpi->x + dpi->width - 1, dpi->y + dpi->height - 1 } }, colour); GfxFillRect(&dpi, { { dpi.x, dpi.y }, { dpi.x + dpi.width - 1, dpi.y + dpi.height - 1 } }, colour);
for (int32_t i = 0; i < no_list_items; i++) for (int32_t i = 0; i < no_list_items; i++)
{ {
int32_t y = i * 12; int32_t y = i * 12;
if (y + 12 < dpi->y || y >= dpi->y + dpi->height) if (y + 12 < dpi.y || y >= dpi.y + dpi.height)
continue; continue;
// Checkbox // Checkbox
GfxFillRectInset(dpi, { { 2, y }, { 11, y + 10 } }, colours[1], INSET_RECT_F_E0); GfxFillRectInset(&dpi, { { 2, y }, { 11, y + 10 } }, colours[1], INSET_RECT_F_E0);
// Highlighted // Highlighted
auto stringId = STR_BLACK_STRING; auto stringId = STR_BLACK_STRING;
if (i == selected_list_item) if (i == selected_list_item)
{ {
stringId = STR_WINDOW_COLOUR_2_STRINGID; stringId = STR_WINDOW_COLOUR_2_STRINGID;
GfxFilterRect(dpi, { 0, y, width, y + 11 }, FilterPaletteID::PaletteDarken1); GfxFilterRect(&dpi, { 0, y, width, y + 11 }, FilterPaletteID::PaletteDarken1);
} }
// Checkbox mark // Checkbox mark
@ -1139,7 +1139,7 @@ private:
{ {
auto darkness = stringId == STR_WINDOW_COLOUR_2_STRINGID ? TextDarkness::ExtraDark : TextDarkness::Dark; auto darkness = stringId == STR_WINDOW_COLOUR_2_STRINGID ? TextDarkness::ExtraDark : TextDarkness::Dark;
GfxDrawString( GfxDrawString(
*dpi, { 2, y }, static_cast<const char*>(CheckBoxMarkString), dpi, { 2, y }, static_cast<const char*>(CheckBoxMarkString),
{ static_cast<colour_t>(colours[1] & 0x7F), FontStyle::Medium, darkness }); { static_cast<colour_t>(colours[1] & 0x7F), FontStyle::Medium, darkness });
} }
@ -1147,7 +1147,7 @@ private:
Formatter ft; Formatter ft;
currentRide->FormatNameTo(ft); currentRide->FormatNameTo(ft);
DrawTextBasic(*dpi, { 15, y }, stringId, ft); DrawTextBasic(dpi, { 15, y }, stringId, ft);
} }
} }
} }

6
src/openrct2-ui/windows/EditorScenarioOptions.cpp
View File

@ -613,7 +613,7 @@ private:
{ {
ScreenCoordsXY screenCoords{}; ScreenCoordsXY screenCoords{};
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
const auto& initialCashWidget = widgets[WIDX_INITIAL_CASH]; const auto& initialCashWidget = widgets[WIDX_INITIAL_CASH];
@ -861,7 +861,7 @@ private:
{ {
ScreenCoordsXY screenCoords{}; ScreenCoordsXY screenCoords{};
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
const auto& cashPerGuestWidget = widgets[WIDX_CASH_PER_GUEST]; const auto& cashPerGuestWidget = widgets[WIDX_CASH_PER_GUEST];
@ -1180,7 +1180,7 @@ private:
{ {
ScreenCoordsXY screenCoords{}; ScreenCoordsXY screenCoords{};
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
const auto& landCostWidget = widgets[WIDX_LAND_COST]; const auto& landCostWidget = widgets[WIDX_LAND_COST];

2
src/openrct2-ui/windows/Finances.cpp
View File

@ -988,7 +988,7 @@ public:
void OnDrawResearch(DrawPixelInfo& dpi) void OnDrawResearch(DrawPixelInfo& dpi)
{ {
WindowResearchFundingPagePaint(this, &dpi, WIDX_RESEARCH_FUNDING); WindowResearchFundingPagePaint(this, dpi, WIDX_RESEARCH_FUNDING);
} }
#pragma endregion #pragma endregion

10
src/openrct2-ui/windows/Footpath.cpp
View File

@ -432,8 +432,8 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
ScreenCoordsXY screenCoords; ScreenCoordsXY screenCoords;
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
WindowFootpathDrawDropdownButtons(&dpi); WindowFootpathDrawDropdownButtons(dpi);
if (!IsWidgetDisabled(WIDX_CONSTRUCT)) if (!IsWidgetDisabled(WIDX_CONSTRUCT))
{ {
@ -568,7 +568,7 @@ private:
} }
} }
void WindowFootpathDrawDropdownButtons(DrawPixelInfo* dpi) void WindowFootpathDrawDropdownButtons(DrawPixelInfo& dpi)
{ {
if (gFootpathSelection.LegacyPath == OBJECT_ENTRY_INDEX_NULL) if (gFootpathSelection.LegacyPath == OBJECT_ENTRY_INDEX_NULL)
{ {
@ -620,10 +620,10 @@ private:
} }
} }
void WindowFootpathDrawDropdownButton(DrawPixelInfo* dpi, WidgetIndex widgetIndex, ImageIndex image) void WindowFootpathDrawDropdownButton(DrawPixelInfo& dpi, WidgetIndex widgetIndex, ImageIndex image)
{ {
const auto& widget = widgets[widgetIndex]; const auto& widget = widgets[widgetIndex];
GfxDrawSprite(*dpi, ImageId(image), { windowPos.x + widget.left, windowPos.y + widget.top }); GfxDrawSprite(dpi, ImageId(image), { windowPos.x + widget.left, windowPos.y + widget.top });
} }
/** /**

80
src/openrct2-ui/windows/GameBottomToolbar.cpp
View File

@ -72,16 +72,16 @@ uint8_t gToolbarDirtyFlags;
static void WindowGameBottomToolbarMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowGameBottomToolbarMouseup(WindowBase *w, WidgetIndex widgetIndex);
static OpenRCT2String WindowGameBottomToolbarTooltip(WindowBase* w, const WidgetIndex widgetIndex, const StringId fallback); static OpenRCT2String WindowGameBottomToolbarTooltip(WindowBase* w, const WidgetIndex widgetIndex, const StringId fallback);
static void WindowGameBottomToolbarInvalidate(WindowBase *w); static void WindowGameBottomToolbarInvalidate(WindowBase *w);
static void WindowGameBottomToolbarPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowGameBottomToolbarPaint(WindowBase *w, DrawPixelInfo& dpi);
static void WindowGameBottomToolbarUpdate(WindowBase* w); static void WindowGameBottomToolbarUpdate(WindowBase* w);
static void WindowGameBottomToolbarCursor(WindowBase *w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords, CursorID *cursorId); static void WindowGameBottomToolbarCursor(WindowBase *w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords, CursorID *cursorId);
static void WindowGameBottomToolbarUnknown05(WindowBase *w); static void WindowGameBottomToolbarUnknown05(WindowBase *w);
static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo *dpi, WindowBase *w); static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo& dpi, WindowBase *w);
static void WindowGameBottomToolbarDrawParkRating(DrawPixelInfo *dpi, WindowBase *w, int32_t colour, const ScreenCoordsXY& coords, uint8_t factor); static void WindowGameBottomToolbarDrawParkRating(DrawPixelInfo& dpi, WindowBase *w, int32_t colour, const ScreenCoordsXY& coords, uint8_t factor);
static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo *dpi, WindowBase *w); static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo& dpi, WindowBase *w);
static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo *dpi, WindowBase *w); static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo& dpi, WindowBase *w);
static void WindowGameBottomToolbarDrawMiddlePanel(DrawPixelInfo *dpi, WindowBase *w); static void WindowGameBottomToolbarDrawMiddlePanel(DrawPixelInfo& dpi, WindowBase *w);
/** /**
* *
@ -338,7 +338,7 @@ void WindowGameBottomToolbarInvalidateNewsItem()
* *
* rct2: 0x0066BC87 * rct2: 0x0066BC87
*/ */
static void WindowGameBottomToolbarPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowGameBottomToolbarPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
auto leftWidget = window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET]; auto leftWidget = window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET];
auto rightWidget = window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET]; auto rightWidget = window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET];
@ -347,18 +347,18 @@ static void WindowGameBottomToolbarPaint(WindowBase* w, DrawPixelInfo* dpi)
// Draw panel grey backgrounds // Draw panel grey backgrounds
auto leftTop = w->windowPos + ScreenCoordsXY{ leftWidget.left, leftWidget.top }; auto leftTop = w->windowPos + ScreenCoordsXY{ leftWidget.left, leftWidget.top };
auto rightBottom = w->windowPos + ScreenCoordsXY{ leftWidget.right, leftWidget.bottom }; auto rightBottom = w->windowPos + ScreenCoordsXY{ leftWidget.right, leftWidget.bottom };
GfxFilterRect(dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51); GfxFilterRect(&dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51);
leftTop = w->windowPos + ScreenCoordsXY{ rightWidget.left, rightWidget.top }; leftTop = w->windowPos + ScreenCoordsXY{ rightWidget.left, rightWidget.top };
rightBottom = w->windowPos + ScreenCoordsXY{ rightWidget.right, rightWidget.bottom }; rightBottom = w->windowPos + ScreenCoordsXY{ rightWidget.right, rightWidget.bottom };
GfxFilterRect(dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51); GfxFilterRect(&dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51);
if (ThemeGetFlags() & UITHEME_FLAG_USE_FULL_BOTTOM_TOOLBAR) if (ThemeGetFlags() & UITHEME_FLAG_USE_FULL_BOTTOM_TOOLBAR)
{ {
// Draw grey background // Draw grey background
leftTop = w->windowPos + ScreenCoordsXY{ middleWidget.left, middleWidget.top }; leftTop = w->windowPos + ScreenCoordsXY{ middleWidget.left, middleWidget.top };
rightBottom = w->windowPos + ScreenCoordsXY{ middleWidget.right, middleWidget.bottom }; rightBottom = w->windowPos + ScreenCoordsXY{ middleWidget.right, middleWidget.bottom };
GfxFilterRect(dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51); GfxFilterRect(&dpi, { leftTop, rightBottom }, FilterPaletteID::Palette51);
} }
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
@ -376,7 +376,7 @@ static void WindowGameBottomToolbarPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
} }
static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo* dpi, WindowBase* w) static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo& dpi, WindowBase* w)
{ {
const auto topLeft = w->windowPos const auto topLeft = w->windowPos
+ ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].left + 1, + ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].left + 1,
@ -385,7 +385,7 @@ static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo* dpi, WindowBase*
+ ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].right - 1, + ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].right - 1,
window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].bottom - 1 }; window_game_bottom_toolbar_widgets[WIDX_LEFT_OUTSET].bottom - 1 };
// Draw green inset rectangle on panel // Draw green inset rectangle on panel
GfxFillRectInset(dpi, { topLeft, bottomRight }, w->colours[1], INSET_RECT_F_30); GfxFillRectInset(&dpi, { topLeft, bottomRight }, w->colours[1], INSET_RECT_F_30);
// Figure out how much line height we have to work with. // Figure out how much line height we have to work with.
uint32_t line_height = FontGetLineHeight(FontStyle::Medium); uint32_t line_height = FontGetLineHeight(FontStyle::Medium);
@ -404,7 +404,7 @@ static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo* dpi, WindowBase*
StringId stringId = gCash < 0 ? STR_BOTTOM_TOOLBAR_CASH_NEGATIVE : STR_BOTTOM_TOOLBAR_CASH; StringId stringId = gCash < 0 ? STR_BOTTOM_TOOLBAR_CASH_NEGATIVE : STR_BOTTOM_TOOLBAR_CASH;
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(gCash); ft.Add<money64>(gCash);
DrawTextBasic(*dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE }); DrawTextBasic(dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE });
} }
static constexpr const StringId _guestCountFormats[] = { static constexpr const StringId _guestCountFormats[] = {
@ -432,7 +432,7 @@ static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo* dpi, WindowBase*
: NOT_TRANSLUCENT(w->colours[0])); : NOT_TRANSLUCENT(w->colours[0]));
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint32_t>(gNumGuestsInPark); ft.Add<uint32_t>(gNumGuestsInPark);
DrawTextBasic(*dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE }); DrawTextBasic(dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE });
} }
// Draw park rating // Draw park rating
@ -450,27 +450,27 @@ static void WindowGameBottomToolbarDrawLeftPanel(DrawPixelInfo* dpi, WindowBase*
* rct2: 0x0066C76C * rct2: 0x0066C76C
*/ */
static void WindowGameBottomToolbarDrawParkRating( static void WindowGameBottomToolbarDrawParkRating(
DrawPixelInfo* dpi, WindowBase* w, int32_t colour, const ScreenCoordsXY& coords, uint8_t factor) DrawPixelInfo& dpi, WindowBase* w, int32_t colour, const ScreenCoordsXY& coords, uint8_t factor)
{ {
int16_t bar_width; int16_t bar_width;
bar_width = (factor * 114) / 255; bar_width = (factor * 114) / 255;
GfxFillRectInset( GfxFillRectInset(
dpi, { coords + ScreenCoordsXY{ 1, 1 }, coords + ScreenCoordsXY{ 114, 9 } }, w->colours[1], INSET_RECT_F_30); &dpi, { coords + ScreenCoordsXY{ 1, 1 }, coords + ScreenCoordsXY{ 114, 9 } }, w->colours[1], INSET_RECT_F_30);
if (!(colour & BAR_BLINK) || GameIsPaused() || (gCurrentRealTimeTicks & 8)) if (!(colour & BAR_BLINK) || GameIsPaused() || (gCurrentRealTimeTicks & 8))
{ {
if (bar_width > 2) if (bar_width > 2)
{ {
GfxFillRectInset(dpi, { coords + ScreenCoordsXY{ 2, 2 }, coords + ScreenCoordsXY{ bar_width - 1, 8 } }, colour, 0); GfxFillRectInset(&dpi, { coords + ScreenCoordsXY{ 2, 2 }, coords + ScreenCoordsXY{ bar_width - 1, 8 } }, colour, 0);
} }
} }
// Draw thumbs on the sides // Draw thumbs on the sides
GfxDrawSprite(*dpi, ImageId(SPR_RATING_LOW), coords - ScreenCoordsXY{ 14, 0 }); GfxDrawSprite(dpi, ImageId(SPR_RATING_LOW), coords - ScreenCoordsXY{ 14, 0 });
GfxDrawSprite(*dpi, ImageId(SPR_RATING_HIGH), coords + ScreenCoordsXY{ 114, 0 }); GfxDrawSprite(dpi, ImageId(SPR_RATING_HIGH), coords + ScreenCoordsXY{ 114, 0 });
} }
static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase* w) static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo& dpi, WindowBase* w)
{ {
const auto topLeft = w->windowPos const auto topLeft = w->windowPos
+ ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].left + 1, + ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].left + 1,
@ -479,7 +479,7 @@ static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase
+ ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].right - 1, + ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].right - 1,
window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].bottom - 1 }; window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].bottom - 1 };
// Draw green inset rectangle on panel // Draw green inset rectangle on panel
GfxFillRectInset(dpi, { topLeft, bottomRight }, w->colours[1], INSET_RECT_F_30); GfxFillRectInset(&dpi, { topLeft, bottomRight }, w->colours[1], INSET_RECT_F_30);
auto screenCoords = ScreenCoordsXY{ (window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].left auto screenCoords = ScreenCoordsXY{ (window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].left
+ window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].right) + window_game_bottom_toolbar_widgets[WIDX_RIGHT_OUTSET].right)
@ -502,7 +502,7 @@ static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase
ft.Add<StringId>(DateDayNames[day]); ft.Add<StringId>(DateDayNames[day]);
ft.Add<int16_t>(month); ft.Add<int16_t>(month);
ft.Add<int16_t>(year); ft.Add<int16_t>(year);
DrawTextBasic(*dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE }); DrawTextBasic(dpi, screenCoords, stringId, ft, { colour, TextAlignment::CENTRE });
// Figure out how much line height we have to work with. // Figure out how much line height we have to work with.
uint32_t line_height = FontGetLineHeight(FontStyle::Medium); uint32_t line_height = FontGetLineHeight(FontStyle::Medium);
@ -520,12 +520,12 @@ static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase
} }
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(temperature); ft.Add<int16_t>(temperature);
DrawTextBasic(*dpi, screenCoords + ScreenCoordsXY{ 0, 6 }, format, ft); DrawTextBasic(dpi, screenCoords + ScreenCoordsXY{ 0, 6 }, format, ft);
screenCoords.x += 30; screenCoords.x += 30;
// Current weather // Current weather
auto currentWeatherSpriteId = ClimateGetWeatherSpriteId(gClimateCurrent); auto currentWeatherSpriteId = ClimateGetWeatherSpriteId(gClimateCurrent);
GfxDrawSprite(*dpi, ImageId(currentWeatherSpriteId), screenCoords); GfxDrawSprite(dpi, ImageId(currentWeatherSpriteId), screenCoords);
// Next weather // Next weather
auto nextWeatherSpriteId = ClimateGetWeatherSpriteId(gClimateNext); auto nextWeatherSpriteId = ClimateGetWeatherSpriteId(gClimateNext);
@ -533,8 +533,8 @@ static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase
{ {
if (gClimateUpdateTimer < 960) if (gClimateUpdateTimer < 960)
{ {
GfxDrawSprite(*dpi, ImageId(SPR_NEXT_WEATHER), screenCoords + ScreenCoordsXY{ 27, 5 }); GfxDrawSprite(dpi, ImageId(SPR_NEXT_WEATHER), screenCoords + ScreenCoordsXY{ 27, 5 });
GfxDrawSprite(*dpi, ImageId(nextWeatherSpriteId), screenCoords + ScreenCoordsXY{ 40, 0 }); GfxDrawSprite(dpi, ImageId(nextWeatherSpriteId), screenCoords + ScreenCoordsXY{ 40, 0 });
} }
} }
} }
@ -543,7 +543,7 @@ static void WindowGameBottomToolbarDrawRightPanel(DrawPixelInfo* dpi, WindowBase
* *
* rct2: 0x0066BFA5 * rct2: 0x0066BFA5
*/ */
static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase* w) static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo& dpi, WindowBase* w)
{ {
int32_t width; int32_t width;
News::Item* newsItem; News::Item* newsItem;
@ -554,7 +554,7 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
// Current news item // Current news item
GfxFillRectInset( GfxFillRectInset(
dpi, &dpi,
{ w->windowPos + ScreenCoordsXY{ middleOutsetWidget->left + 1, middleOutsetWidget->top + 1 }, { w->windowPos + ScreenCoordsXY{ middleOutsetWidget->left + 1, middleOutsetWidget->top + 1 },
w->windowPos + ScreenCoordsXY{ middleOutsetWidget->right - 1, middleOutsetWidget->bottom - 1 } }, w->windowPos + ScreenCoordsXY{ middleOutsetWidget->right - 1, middleOutsetWidget->bottom - 1 } },
w->colours[2], INSET_RECT_F_30); w->colours[2], INSET_RECT_F_30);
@ -563,7 +563,7 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
auto screenCoords = w->windowPos + ScreenCoordsXY{ middleOutsetWidget->midX(), middleOutsetWidget->top + 11 }; auto screenCoords = w->windowPos + ScreenCoordsXY{ middleOutsetWidget->midX(), middleOutsetWidget->top + 11 };
width = middleOutsetWidget->width() - 62; width = middleOutsetWidget->width() - 62;
DrawNewsTicker( DrawNewsTicker(
*dpi, screenCoords, width, COLOUR_BRIGHT_GREEN, STR_BOTTOM_TOOLBAR_NEWS_TEXT, newsItem->Text, newsItem->Ticks); dpi, screenCoords, width, COLOUR_BRIGHT_GREEN, STR_BOTTOM_TOOLBAR_NEWS_TEXT, newsItem->Text, newsItem->Ticks);
screenCoords = w->windowPos screenCoords = w->windowPos
+ ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_NEWS_SUBJECT].left, + ScreenCoordsXY{ window_game_bottom_toolbar_widgets[WIDX_NEWS_SUBJECT].left,
@ -571,7 +571,7 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
switch (newsItem->Type) switch (newsItem->Type)
{ {
case News::ItemType::Ride: case News::ItemType::Ride:
GfxDrawSprite(*dpi, ImageId(SPR_RIDE), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_RIDE), screenCoords);
break; break;
case News::ItemType::PeepOnRide: case News::ItemType::PeepOnRide:
case News::ItemType::Peep: case News::ItemType::Peep:
@ -580,7 +580,7 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
break; break;
DrawPixelInfo cliped_dpi; DrawPixelInfo cliped_dpi;
if (!ClipDrawPixelInfo(&cliped_dpi, dpi, screenCoords + ScreenCoordsXY{ 1, 1 }, 22, 22)) if (!ClipDrawPixelInfo(&cliped_dpi, &dpi, screenCoords + ScreenCoordsXY{ 1, 1 }, 22, 22))
{ {
break; break;
} }
@ -623,19 +623,19 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
} }
case News::ItemType::Money: case News::ItemType::Money:
case News::ItemType::Campaign: case News::ItemType::Campaign:
GfxDrawSprite(*dpi, ImageId(SPR_FINANCE), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_FINANCE), screenCoords);
break; break;
case News::ItemType::Research: case News::ItemType::Research:
GfxDrawSprite(*dpi, ImageId(newsItem->Assoc < 0x10000 ? SPR_NEW_SCENERY : SPR_NEW_RIDE), screenCoords); GfxDrawSprite(dpi, ImageId(newsItem->Assoc < 0x10000 ? SPR_NEW_SCENERY : SPR_NEW_RIDE), screenCoords);
break; break;
case News::ItemType::Peeps: case News::ItemType::Peeps:
GfxDrawSprite(*dpi, ImageId(SPR_GUESTS), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_GUESTS), screenCoords);
break; break;
case News::ItemType::Award: case News::ItemType::Award:
GfxDrawSprite(*dpi, ImageId(SPR_AWARD), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_AWARD), screenCoords);
break; break;
case News::ItemType::Graph: case News::ItemType::Graph:
GfxDrawSprite(*dpi, ImageId(SPR_GRAPH), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_GRAPH), screenCoords);
break; break;
case News::ItemType::Null: case News::ItemType::Null:
case News::ItemType::Blank: case News::ItemType::Blank:
@ -644,12 +644,12 @@ static void WindowGameBottomToolbarDrawNewsItem(DrawPixelInfo* dpi, WindowBase*
} }
} }
static void WindowGameBottomToolbarDrawMiddlePanel(DrawPixelInfo* dpi, WindowBase* w) static void WindowGameBottomToolbarDrawMiddlePanel(DrawPixelInfo& dpi, WindowBase* w)
{ {
Widget* middleOutsetWidget = &window_game_bottom_toolbar_widgets[WIDX_MIDDLE_OUTSET]; Widget* middleOutsetWidget = &window_game_bottom_toolbar_widgets[WIDX_MIDDLE_OUTSET];
GfxFillRectInset( GfxFillRectInset(
dpi, &dpi,
{ w->windowPos + ScreenCoordsXY{ middleOutsetWidget->left + 1, middleOutsetWidget->top + 1 }, { w->windowPos + ScreenCoordsXY{ middleOutsetWidget->left + 1, middleOutsetWidget->top + 1 },
w->windowPos + ScreenCoordsXY{ middleOutsetWidget->right - 1, middleOutsetWidget->bottom - 1 } }, w->windowPos + ScreenCoordsXY{ middleOutsetWidget->right - 1, middleOutsetWidget->bottom - 1 } },
w->colours[1], INSET_RECT_F_30); w->colours[1], INSET_RECT_F_30);
@ -668,12 +668,12 @@ static void WindowGameBottomToolbarDrawMiddlePanel(DrawPixelInfo* dpi, WindowBas
if (stringId == STR_NONE) if (stringId == STR_NONE)
{ {
DrawTextWrapped( DrawTextWrapped(
*dpi, middleWidgetCoords, width, STR_TITLE_SEQUENCE_OPENRCT2, ft, { w->colours[0], TextAlignment::CENTRE }); dpi, middleWidgetCoords, width, STR_TITLE_SEQUENCE_OPENRCT2, ft, { w->colours[0], TextAlignment::CENTRE });
} }
else else
{ {
// Show tooltip in bottom toolbar // Show tooltip in bottom toolbar
DrawTextWrapped(*dpi, middleWidgetCoords, width, STR_STRINGID, ft, { w->colours[0], TextAlignment::CENTRE }); DrawTextWrapped(dpi, middleWidgetCoords, width, STR_STRINGID, ft, { w->colours[0], TextAlignment::CENTRE });
} }
} }

2
src/openrct2-ui/windows/Guest.cpp
View File

@ -752,7 +752,7 @@ private:
// Draw the viewport no sound sprite // Draw the viewport no sound sprite
if (viewport != nullptr) if (viewport != nullptr)
{ {
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
if (viewport->flags & VIEWPORT_FLAG_SOUND_ON) if (viewport->flags & VIEWPORT_FLAG_SOUND_ON)
{ {
GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 }); GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 });

6
src/openrct2-ui/windows/LoadSave.cpp
View File

@ -1112,7 +1112,7 @@ static Widget window_overwrite_prompt_widgets[] = {
}; };
static void WindowOverwritePromptMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowOverwritePromptMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowOverwritePromptPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowOverwritePromptPaint(WindowBase* w, DrawPixelInfo& dpi);
static WindowEventList window_overwrite_prompt_events([](auto& events) { static WindowEventList window_overwrite_prompt_events([](auto& events) {
events.mouse_up = &WindowOverwritePromptMouseup; events.mouse_up = &WindowOverwritePromptMouseup;
@ -1164,7 +1164,7 @@ static void WindowOverwritePromptMouseup(WindowBase* w, WidgetIndex widgetIndex)
} }
} }
static void WindowOverwritePromptPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowOverwritePromptPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
@ -1173,7 +1173,7 @@ static void WindowOverwritePromptPaint(WindowBase* w, DrawPixelInfo* dpi)
ft.Add<char*>(_window_overwrite_prompt_name); ft.Add<char*>(_window_overwrite_prompt_name);
ScreenCoordsXY stringCoords(w->windowPos.x + w->width / 2, w->windowPos.y + (w->height / 2) - 3); ScreenCoordsXY stringCoords(w->windowPos.x + w->width / 2, w->windowPos.y + (w->height / 2) - 3);
DrawTextWrapped(*dpi, stringCoords, w->width - 4, STR_FILEBROWSER_OVERWRITE_PROMPT, ft, { TextAlignment::CENTRE }); DrawTextWrapped(dpi, stringCoords, w->width - 4, STR_FILEBROWSER_OVERWRITE_PROMPT, ft, { TextAlignment::CENTRE });
} }
#pragma endregion #pragma endregion

42
src/openrct2-ui/windows/Map.cpp
View File

@ -719,13 +719,13 @@ public:
if (selected_tab == PAGE_PEEPS) if (selected_tab == PAGE_PEEPS)
{ {
PaintPeepOverlay(&dpi); PaintPeepOverlay(dpi);
} }
else else
{ {
PaintTrainOverlay(&dpi); PaintTrainOverlay(dpi);
} }
PaintHudRectangle(&dpi); PaintHudRectangle(dpi);
} }
void OnPrepareDraw() override void OnPrepareDraw() override
@ -855,7 +855,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
DrawWidgets(dpi); DrawWidgets(dpi);
DrawTabImages(&dpi); DrawTabImages(dpi);
auto screenCoords = windowPos auto screenCoords = windowPos
+ ScreenCoordsXY{ window_map_widgets[WIDX_LAND_TOOL].midX(), window_map_widgets[WIDX_LAND_TOOL].midY() }; + ScreenCoordsXY{ window_map_widgets[WIDX_LAND_TOOL].midX(), window_map_widgets[WIDX_LAND_TOOL].midY() };
@ -1161,7 +1161,7 @@ private:
return colourB; return colourB;
} }
void PaintPeepOverlay(DrawPixelInfo* dpi) void PaintPeepOverlay(DrawPixelInfo& dpi)
{ {
auto flashColour = GetGuestFlashColour(); auto flashColour = GetGuestFlashColour();
for (auto guest : EntityList<Guest>()) for (auto guest : EntityList<Guest>())
@ -1175,7 +1175,7 @@ private:
} }
} }
void DrawMapPeepPixel(Peep* peep, const uint8_t flashColour, DrawPixelInfo* dpi) void DrawMapPeepPixel(Peep* peep, const uint8_t flashColour, DrawPixelInfo& dpi)
{ {
if (peep->x == LOCATION_NULL) if (peep->x == LOCATION_NULL)
return; return;
@ -1194,7 +1194,7 @@ private:
} }
} }
GfxFillRect(dpi, { leftTop, rightBottom }, colour); GfxFillRect(&dpi, { leftTop, rightBottom }, colour);
} }
static uint8_t GetGuestFlashColour() static uint8_t GetGuestFlashColour()
@ -1221,7 +1221,7 @@ private:
return colour; return colour;
} }
void PaintTrainOverlay(DrawPixelInfo* dpi) void PaintTrainOverlay(DrawPixelInfo& dpi)
{ {
for (auto train : TrainManager::View()) for (auto train : TrainManager::View())
{ {
@ -1232,7 +1232,7 @@ private:
MapCoordsXY c = TransformToMapCoords({ vehicle->x, vehicle->y }); MapCoordsXY c = TransformToMapCoords({ vehicle->x, vehicle->y });
GfxFillRect(dpi, { { c.x, c.y }, { c.x, c.y } }, PALETTE_INDEX_171); GfxFillRect(&dpi, { { c.x, c.y }, { c.x, c.y } }, PALETTE_INDEX_171);
} }
} }
} }
@ -1241,7 +1241,7 @@ private:
* The call to GfxFillRect was originally wrapped in Sub68DABD which made sure that arguments were ordered correctly, * The call to GfxFillRect was originally wrapped in Sub68DABD which made sure that arguments were ordered correctly,
* but it doesn't look like it's ever necessary here so the call was removed. * but it doesn't look like it's ever necessary here so the call was removed.
*/ */
void PaintHudRectangle(DrawPixelInfo* dpi) void PaintHudRectangle(DrawPixelInfo& dpi)
{ {
WindowBase* mainWindow = WindowGetMain(); WindowBase* mainWindow = WindowGetMain();
if (mainWindow == nullptr) if (mainWindow == nullptr)
@ -1259,23 +1259,23 @@ private:
auto leftBottom = ScreenCoordsXY{ leftTop.x, rightBottom.y }; auto leftBottom = ScreenCoordsXY{ leftTop.x, rightBottom.y };
// top horizontal lines // top horizontal lines
GfxFillRect(dpi, { leftTop, leftTop + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56); GfxFillRect(&dpi, { leftTop, leftTop + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56);
GfxFillRect(dpi, { rightTop - ScreenCoordsXY{ 3, 0 }, rightTop }, PALETTE_INDEX_56); GfxFillRect(&dpi, { rightTop - ScreenCoordsXY{ 3, 0 }, rightTop }, PALETTE_INDEX_56);
// left vertical lines // left vertical lines
GfxFillRect(dpi, { leftTop, leftTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56); GfxFillRect(&dpi, { leftTop, leftTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56);
GfxFillRect(dpi, { leftBottom - ScreenCoordsXY{ 0, 3 }, leftBottom }, PALETTE_INDEX_56); GfxFillRect(&dpi, { leftBottom - ScreenCoordsXY{ 0, 3 }, leftBottom }, PALETTE_INDEX_56);
// bottom horizontal lines // bottom horizontal lines
GfxFillRect(dpi, { leftBottom, leftBottom + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56); GfxFillRect(&dpi, { leftBottom, leftBottom + ScreenCoordsXY{ 3, 0 } }, PALETTE_INDEX_56);
GfxFillRect(dpi, { rightBottom - ScreenCoordsXY{ 3, 0 }, rightBottom }, PALETTE_INDEX_56); GfxFillRect(&dpi, { rightBottom - ScreenCoordsXY{ 3, 0 }, rightBottom }, PALETTE_INDEX_56);
// right vertical lines // right vertical lines
GfxFillRect(dpi, { rightTop, rightTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56); GfxFillRect(&dpi, { rightTop, rightTop + ScreenCoordsXY{ 0, 3 } }, PALETTE_INDEX_56);
GfxFillRect(dpi, { rightBottom - ScreenCoordsXY{ 0, 3 }, rightBottom }, PALETTE_INDEX_56); GfxFillRect(&dpi, { rightBottom - ScreenCoordsXY{ 0, 3 }, rightBottom }, PALETTE_INDEX_56);
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
// Guest tab image (animated) // Guest tab image (animated)
uint32_t guestTabImage = SPR_TAB_GUESTS_0; uint32_t guestTabImage = SPR_TAB_GUESTS_0;
@ -1283,7 +1283,7 @@ private:
guestTabImage += list_information_type / 4; guestTabImage += list_information_type / 4;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(guestTabImage), dpi, ImageId(guestTabImage),
windowPos + ScreenCoordsXY{ widgets[WIDX_PEOPLE_TAB].left, widgets[WIDX_PEOPLE_TAB].top }); windowPos + ScreenCoordsXY{ widgets[WIDX_PEOPLE_TAB].left, widgets[WIDX_PEOPLE_TAB].top });
// Ride/stall tab image (animated) // Ride/stall tab image (animated)
@ -1292,7 +1292,7 @@ private:
rideTabImage += list_information_type / 4; rideTabImage += list_information_type / 4;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(rideTabImage), dpi, ImageId(rideTabImage),
windowPos + ScreenCoordsXY{ widgets[WIDX_RIDES_TAB].left, widgets[WIDX_RIDES_TAB].top }); windowPos + ScreenCoordsXY{ widgets[WIDX_RIDES_TAB].left, widgets[WIDX_RIDES_TAB].top });
} }

6
src/openrct2-ui/windows/MapTooltip.cpp
View File

@ -24,7 +24,7 @@ static Widget window_map_tooltip_widgets[] = {
}; };
static void WindowMapTooltipUpdate(WindowBase *w); static void WindowMapTooltipUpdate(WindowBase *w);
static void WindowMapTooltipPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowMapTooltipPaint(WindowBase *w, DrawPixelInfo& dpi);
static WindowEventList window_map_tooltip_events([](auto& events) static WindowEventList window_map_tooltip_events([](auto& events)
{ {
@ -137,7 +137,7 @@ static void WindowMapTooltipUpdate(WindowBase* w)
* *
* rct2: 0x006EE894 * rct2: 0x006EE894
*/ */
static void WindowMapTooltipPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowMapTooltipPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
StringId stringId; StringId stringId;
std::memcpy(&stringId, _mapTooltipArgs.Data(), sizeof(StringId)); std::memcpy(&stringId, _mapTooltipArgs.Data(), sizeof(StringId));
@ -147,5 +147,5 @@ static void WindowMapTooltipPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
ScreenCoordsXY stringCoords(w->windowPos.x + (w->width / 2), w->windowPos.y + (w->height / 2)); ScreenCoordsXY stringCoords(w->windowPos.x + (w->width / 2), w->windowPos.y + (w->height / 2));
DrawTextWrapped(*dpi, stringCoords, w->width, STR_MAP_TOOLTIP_STRINGID, _mapTooltipArgs, { TextAlignment::CENTRE }); DrawTextWrapped(dpi, stringCoords, w->width, STR_MAP_TOOLTIP_STRINGID, _mapTooltipArgs, { TextAlignment::CENTRE });
} }

84
src/openrct2-ui/windows/Multiplayer.cpp
View File

@ -124,7 +124,7 @@ static void WindowMultiplayerInformationMouseup(WindowBase *w, WidgetIndex widge
static void WindowMultiplayerInformationResize(WindowBase *w); static void WindowMultiplayerInformationResize(WindowBase *w);
static void WindowMultiplayerInformationUpdate(WindowBase *w); static void WindowMultiplayerInformationUpdate(WindowBase *w);
static void WindowMultiplayerInformationInvalidate(WindowBase *w); static void WindowMultiplayerInformationInvalidate(WindowBase *w);
static void WindowMultiplayerInformationPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowMultiplayerInformationPaint(WindowBase *w, DrawPixelInfo& dpi);
static void WindowMultiplayerPlayersMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowMultiplayerPlayersMouseup(WindowBase *w, WidgetIndex widgetIndex);
static void WindowMultiplayerPlayersResize(WindowBase *w); static void WindowMultiplayerPlayersResize(WindowBase *w);
@ -133,8 +133,8 @@ static void WindowMultiplayerPlayersScrollgetsize(WindowBase *w, int32_t scrollI
static void WindowMultiplayerPlayersScrollmousedown(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords); static void WindowMultiplayerPlayersScrollmousedown(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
static void WindowMultiplayerPlayersScrollmouseover(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords); static void WindowMultiplayerPlayersScrollmouseover(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
static void WindowMultiplayerPlayersInvalidate(WindowBase *w); static void WindowMultiplayerPlayersInvalidate(WindowBase *w);
static void WindowMultiplayerPlayersPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowMultiplayerPlayersPaint(WindowBase *w, DrawPixelInfo& dpi);
static void WindowMultiplayerPlayersScrollpaint(WindowBase *w, DrawPixelInfo *dpi, int32_t scrollIndex); static void WindowMultiplayerPlayersScrollpaint(WindowBase *w, DrawPixelInfo& dpi, int32_t scrollIndex);
static void WindowMultiplayerGroupsMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowMultiplayerGroupsMouseup(WindowBase *w, WidgetIndex widgetIndex);
static void WindowMultiplayerGroupsResize(WindowBase *w); static void WindowMultiplayerGroupsResize(WindowBase *w);
@ -146,14 +146,14 @@ static void WindowMultiplayerGroupsScrollmousedown(WindowBase *w, int32_t scroll
static void WindowMultiplayerGroupsScrollmouseover(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords); static void WindowMultiplayerGroupsScrollmouseover(WindowBase *w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
static void WindowMultiplayerGroupsTextInput(WindowBase *w, WidgetIndex widgetIndex, const char *text); static void WindowMultiplayerGroupsTextInput(WindowBase *w, WidgetIndex widgetIndex, const char *text);
static void WindowMultiplayerGroupsInvalidate(WindowBase *w); static void WindowMultiplayerGroupsInvalidate(WindowBase *w);
static void WindowMultiplayerGroupsPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowMultiplayerGroupsPaint(WindowBase *w, DrawPixelInfo& dpi);
static void WindowMultiplayerGroupsScrollpaint(WindowBase *w, DrawPixelInfo *dpi, int32_t scrollIndex); static void WindowMultiplayerGroupsScrollpaint(WindowBase *w, DrawPixelInfo& dpi, int32_t scrollIndex);
static void WindowMultiplayerOptionsMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowMultiplayerOptionsMouseup(WindowBase *w, WidgetIndex widgetIndex);
static void WindowMultiplayerOptionsResize(WindowBase *w); static void WindowMultiplayerOptionsResize(WindowBase *w);
static void WindowMultiplayerOptionsUpdate(WindowBase *w); static void WindowMultiplayerOptionsUpdate(WindowBase *w);
static void WindowMultiplayerOptionsInvalidate(WindowBase *w); static void WindowMultiplayerOptionsInvalidate(WindowBase *w);
static void WindowMultiplayerOptionsPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowMultiplayerOptionsPaint(WindowBase *w, DrawPixelInfo& dpi);
static WindowEventList window_multiplayer_information_events([](auto& events) static WindowEventList window_multiplayer_information_events([](auto& events)
{ {
@ -223,7 +223,7 @@ static constexpr const int32_t window_multiplayer_animation_frames[] = {
4, 4,
}; };
static void WindowMultiplayerDrawTabImages(WindowBase* w, DrawPixelInfo* dpi); static void WindowMultiplayerDrawTabImages(WindowBase* w, DrawPixelInfo& dpi);
static void WindowMultiplayerSetPage(WindowBase* w, int32_t page); static void WindowMultiplayerSetPage(WindowBase* w, int32_t page);
static bool _windowInformationSizeDirty; static bool _windowInformationSizeDirty;
@ -395,16 +395,14 @@ static void WindowMultiplayerInformationInvalidate(WindowBase* w)
WindowAlignTabs(w, WIDX_TAB1, WIDX_TAB4); WindowAlignTabs(w, WIDX_TAB1, WIDX_TAB4);
} }
static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowMultiplayerDrawTabImages(w, dpi); WindowMultiplayerDrawTabImages(w, dpi);
DrawPixelInfo clippedDPI; DrawPixelInfo clippedDPI;
if (ClipDrawPixelInfo(&clippedDPI, dpi, w->windowPos, w->width, w->height)) if (ClipDrawPixelInfo(&clippedDPI, &dpi, w->windowPos, w->width, w->height))
{ {
dpi = &clippedDPI;
auto screenCoords = ScreenCoordsXY{ 3, 50 }; auto screenCoords = ScreenCoordsXY{ 3, 50 };
int32_t width = w->width - 6; int32_t width = w->width - 6;
@ -412,7 +410,7 @@ static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(name.c_str()); ft.Add<const char*>(name.c_str());
screenCoords.y += DrawTextWrapped(*dpi, screenCoords, width, STR_STRING, ft, { w->colours[1] }); screenCoords.y += DrawTextWrapped(clippedDPI, screenCoords, width, STR_STRING, ft, { w->colours[1] });
screenCoords.y += LIST_ROW_HEIGHT / 2; screenCoords.y += LIST_ROW_HEIGHT / 2;
} }
@ -421,7 +419,7 @@ static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(description.c_str()); ft.Add<const char*>(description.c_str());
screenCoords.y += DrawTextWrapped(*dpi, screenCoords, width, STR_STRING, ft, { w->colours[1] }); screenCoords.y += DrawTextWrapped(clippedDPI, screenCoords, width, STR_STRING, ft, { w->colours[1] });
screenCoords.y += LIST_ROW_HEIGHT / 2; screenCoords.y += LIST_ROW_HEIGHT / 2;
} }
@ -430,7 +428,7 @@ static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(providerName.c_str()); ft.Add<const char*>(providerName.c_str());
DrawTextBasic(*dpi, screenCoords, STR_PROVIDER_NAME, ft); DrawTextBasic(clippedDPI, screenCoords, STR_PROVIDER_NAME, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -439,7 +437,7 @@ static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(providerEmail.c_str()); ft.Add<const char*>(providerEmail.c_str());
DrawTextBasic(*dpi, screenCoords, STR_PROVIDER_EMAIL, ft); DrawTextBasic(clippedDPI, screenCoords, STR_PROVIDER_EMAIL, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -448,7 +446,7 @@ static void WindowMultiplayerInformationPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(providerWebsite.c_str()); ft.Add<const char*>(providerWebsite.c_str());
DrawTextBasic(*dpi, screenCoords, STR_PROVIDER_WEBSITE, ft); DrawTextBasic(clippedDPI, screenCoords, STR_PROVIDER_WEBSITE, ft);
} }
} }
} }
@ -557,7 +555,7 @@ static void WindowMultiplayerPlayersInvalidate(WindowBase* w)
WindowAlignTabs(w, WIDX_TAB1, WIDX_TAB4); WindowAlignTabs(w, WIDX_TAB1, WIDX_TAB4);
} }
static void WindowMultiplayerPlayersPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowMultiplayerPlayersPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
StringId stringId; StringId stringId;
@ -569,10 +567,10 @@ static void WindowMultiplayerPlayersPaint(WindowBase* w, DrawPixelInfo* dpi)
auto screenCoords = w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_LIST].bottom + 2 }; auto screenCoords = w->windowPos + ScreenCoordsXY{ 4, w->widgets[WIDX_LIST].bottom + 2 };
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint16_t>(w->no_list_items); ft.Add<uint16_t>(w->no_list_items);
DrawTextBasic(*dpi, screenCoords, stringId, ft, { w->colours[2] }); DrawTextBasic(dpi, screenCoords, stringId, ft, { w->colours[2] });
} }
static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
ScreenCoordsXY screenCoords; ScreenCoordsXY screenCoords;
screenCoords.y = 0; screenCoords.y = 0;
@ -582,12 +580,12 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
for (int32_t player = firstPlayerInList; player < NetworkGetNumPlayers(); player++) for (int32_t player = firstPlayerInList; player < NetworkGetNumPlayers(); player++)
{ {
if (screenCoords.y > dpi->y + dpi->height) if (screenCoords.y > dpi.y + dpi.height)
{ {
break; break;
} }
if (screenCoords.y + SCROLLABLE_ROW_HEIGHT + 1 >= dpi->y) if (screenCoords.y + SCROLLABLE_ROW_HEIGHT + 1 >= dpi.y)
{ {
thread_local std::string _buffer; thread_local std::string _buffer;
_buffer.reserve(512); _buffer.reserve(512);
@ -598,7 +596,7 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
if (listPosition == w->selected_list_item) if (listPosition == w->selected_list_item)
{ {
GfxFilterRect( GfxFilterRect(
dpi, { 0, screenCoords.y, 800, screenCoords.y + SCROLLABLE_ROW_HEIGHT - 1 }, &dpi, { 0, screenCoords.y, 800, screenCoords.y + SCROLLABLE_ROW_HEIGHT - 1 },
FilterPaletteID::PaletteDarken1); FilterPaletteID::PaletteDarken1);
_buffer += NetworkGetPlayerName(player); _buffer += NetworkGetPlayerName(player);
colour = w->colours[2]; colour = w->colours[2];
@ -617,7 +615,7 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
} }
screenCoords.x = 0; screenCoords.x = 0;
GfxClipString(_buffer.data(), 230, FontStyle::Medium); GfxClipString(_buffer.data(), 230, FontStyle::Medium);
GfxDrawString(*dpi, screenCoords, _buffer.c_str(), { colour }); GfxDrawString(dpi, screenCoords, _buffer.c_str(), { colour });
// Draw group name // Draw group name
_buffer.resize(0); _buffer.resize(0);
@ -628,7 +626,7 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
screenCoords.x = 173; screenCoords.x = 173;
_buffer += NetworkGetGroupName(group); _buffer += NetworkGetGroupName(group);
GfxClipString(_buffer.data(), 80, FontStyle::Medium); GfxClipString(_buffer.data(), 80, FontStyle::Medium);
GfxDrawString(*dpi, screenCoords, _buffer.c_str(), { colour }); GfxDrawString(dpi, screenCoords, _buffer.c_str(), { colour });
} }
// Draw last action // Draw last action
@ -642,7 +640,7 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
{ {
ft.Add<StringId>(STR_ACTION_NA); ft.Add<StringId>(STR_ACTION_NA);
} }
DrawTextEllipsised(*dpi, { 256, screenCoords.y }, 100, STR_BLACK_STRING, ft); DrawTextEllipsised(dpi, { 256, screenCoords.y }, 100, STR_BLACK_STRING, ft);
// Draw ping // Draw ping
_buffer.resize(0); _buffer.resize(0);
@ -665,7 +663,7 @@ static void WindowMultiplayerPlayersScrollpaint(WindowBase* w, DrawPixelInfo* dp
_buffer += pingBuffer; _buffer += pingBuffer;
screenCoords.x = 356; screenCoords.x = 356;
GfxDrawString(*dpi, screenCoords, _buffer.c_str(), { colour }); GfxDrawString(dpi, screenCoords, _buffer.c_str(), { colour });
} }
screenCoords.y += SCROLLABLE_ROW_HEIGHT; screenCoords.y += SCROLLABLE_ROW_HEIGHT;
listPosition++; listPosition++;
@ -841,7 +839,7 @@ static void WindowMultiplayerGroupsInvalidate(WindowBase* w)
} }
} }
static void WindowMultiplayerGroupsPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowMultiplayerGroupsPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
thread_local std::string _buffer; thread_local std::string _buffer;
@ -858,7 +856,7 @@ static void WindowMultiplayerGroupsPaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(_buffer.c_str()); ft.Add<const char*>(_buffer.c_str());
DrawTextEllipsised( DrawTextEllipsised(
*dpi, w->windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft, dpi, w->windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft,
{ TextAlignment::CENTRE }); { TextAlignment::CENTRE });
} }
@ -866,12 +864,12 @@ static void WindowMultiplayerGroupsPaint(WindowBase* w, DrawPixelInfo* dpi)
+ ScreenCoordsXY{ window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].left + 4, + ScreenCoordsXY{ window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].left + 4,
window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].top + 4 }; window_multiplayer_groups_widgets[WIDX_CONTENT_PANEL].top + 4 };
DrawTextBasic(*dpi, screenPos, STR_DEFAULT_GROUP, {}, { w->colours[2] }); DrawTextBasic(dpi, screenPos, STR_DEFAULT_GROUP, {}, { w->colours[2] });
screenPos.y += 20; screenPos.y += 20;
GfxFillRectInset( GfxFillRectInset(
dpi, { screenPos - ScreenCoordsXY{ 0, 6 }, screenPos + ScreenCoordsXY{ 310, -5 } }, w->colours[1], &dpi, { screenPos - ScreenCoordsXY{ 0, 6 }, screenPos + ScreenCoordsXY{ 310, -5 } }, w->colours[1],
INSET_RECT_FLAG_BORDER_INSET); INSET_RECT_FLAG_BORDER_INSET);
widget = &window_multiplayer_groups_widgets[WIDX_SELECTED_GROUP]; widget = &window_multiplayer_groups_widgets[WIDX_SELECTED_GROUP];
@ -883,32 +881,32 @@ static void WindowMultiplayerGroupsPaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<const char*>(_buffer.c_str()); ft.Add<const char*>(_buffer.c_str());
DrawTextEllipsised( DrawTextEllipsised(
*dpi, w->windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft, dpi, w->windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft,
{ TextAlignment::CENTRE }); { TextAlignment::CENTRE });
} }
} }
static void WindowMultiplayerGroupsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) static void WindowMultiplayerGroupsScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
auto screenCoords = ScreenCoordsXY{ 0, 0 }; auto screenCoords = ScreenCoordsXY{ 0, 0 };
auto dpiCoords = ScreenCoordsXY{ dpi->x, dpi->y }; auto dpiCoords = ScreenCoordsXY{ dpi.x, dpi.y };
GfxFillRect( GfxFillRect(
dpi, { dpiCoords, dpiCoords + ScreenCoordsXY{ dpi->width - 1, dpi->height - 1 } }, ColourMapA[w->colours[1]].mid_light); &dpi, { dpiCoords, dpiCoords + ScreenCoordsXY{ dpi.width - 1, dpi.height - 1 } }, ColourMapA[w->colours[1]].mid_light);
for (int32_t i = 0; i < NetworkGetNumActions(); i++) for (int32_t i = 0; i < NetworkGetNumActions(); i++)
{ {
if (i == w->selected_list_item) if (i == w->selected_list_item)
{ {
GfxFilterRect( GfxFilterRect(
dpi, { 0, screenCoords.y, 800, screenCoords.y + SCROLLABLE_ROW_HEIGHT - 1 }, FilterPaletteID::PaletteDarken1); &dpi, { 0, screenCoords.y, 800, screenCoords.y + SCROLLABLE_ROW_HEIGHT - 1 }, FilterPaletteID::PaletteDarken1);
} }
if (screenCoords.y > dpi->y + dpi->height) if (screenCoords.y > dpi.y + dpi.height)
{ {
break; break;
} }
if (screenCoords.y + SCROLLABLE_ROW_HEIGHT + 1 >= dpi->y) if (screenCoords.y + SCROLLABLE_ROW_HEIGHT + 1 >= dpi.y)
{ {
int32_t groupindex = NetworkGetGroupIndex(_selectedGroup); int32_t groupindex = NetworkGetGroupIndex(_selectedGroup);
if (groupindex != -1) if (groupindex != -1)
@ -916,14 +914,14 @@ static void WindowMultiplayerGroupsScrollpaint(WindowBase* w, DrawPixelInfo* dpi
if (NetworkCanPerformAction(groupindex, static_cast<NetworkPermission>(i))) if (NetworkCanPerformAction(groupindex, static_cast<NetworkPermission>(i)))
{ {
screenCoords.x = 0; screenCoords.x = 0;
GfxDrawString(*dpi, screenCoords, u8"{WINDOW_COLOUR_2}✓", {}); GfxDrawString(dpi, screenCoords, u8"{WINDOW_COLOUR_2}✓", {});
} }
} }
// Draw action name // Draw action name
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint16_t>(NetworkGetActionNameStringID(i)); ft.Add<uint16_t>(NetworkGetActionNameStringID(i));
DrawTextBasic(*dpi, { 10, screenCoords.y }, STR_WINDOW_COLOUR_2_STRINGID, ft); DrawTextBasic(dpi, { 10, screenCoords.y }, STR_WINDOW_COLOUR_2_STRINGID, ft);
} }
screenCoords.y += SCROLLABLE_ROW_HEIGHT; screenCoords.y += SCROLLABLE_ROW_HEIGHT;
} }
@ -991,7 +989,7 @@ static void WindowMultiplayerOptionsInvalidate(WindowBase* w)
WidgetSetCheckboxValue(*w, WIDX_KNOWN_KEYS_ONLY_CHECKBOX, gConfigNetwork.KnownKeysOnly); WidgetSetCheckboxValue(*w, WIDX_KNOWN_KEYS_ONLY_CHECKBOX, gConfigNetwork.KnownKeysOnly);
} }
static void WindowMultiplayerOptionsPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowMultiplayerOptionsPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowMultiplayerDrawTabImages(w, dpi); WindowMultiplayerDrawTabImages(w, dpi);
@ -999,7 +997,7 @@ static void WindowMultiplayerOptionsPaint(WindowBase* w, DrawPixelInfo* dpi)
#pragma endregion #pragma endregion
static void WindowMultiplayerDrawTabImage(WindowBase* w, DrawPixelInfo* dpi, int32_t page, int32_t spriteIndex) static void WindowMultiplayerDrawTabImage(WindowBase* w, DrawPixelInfo& dpi, int32_t page, int32_t spriteIndex)
{ {
WidgetIndex widgetIndex = WIDX_TAB1 + page; WidgetIndex widgetIndex = WIDX_TAB1 + page;
@ -1016,12 +1014,12 @@ static void WindowMultiplayerDrawTabImage(WindowBase* w, DrawPixelInfo* dpi, int
} }
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(spriteIndex), dpi, ImageId(spriteIndex),
w->windowPos + ScreenCoordsXY{ w->widgets[widgetIndex].left, w->widgets[widgetIndex].top }); w->windowPos + ScreenCoordsXY{ w->widgets[widgetIndex].left, w->widgets[widgetIndex].top });
} }
} }
static void WindowMultiplayerDrawTabImages(WindowBase* w, DrawPixelInfo* dpi) static void WindowMultiplayerDrawTabImages(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowMultiplayerDrawTabImage(w, dpi, WINDOW_MULTIPLAYER_PAGE_INFORMATION, SPR_TAB_KIOSKS_AND_FACILITIES_0); WindowMultiplayerDrawTabImage(w, dpi, WINDOW_MULTIPLAYER_PAGE_INFORMATION, SPR_TAB_KIOSKS_AND_FACILITIES_0);
WindowMultiplayerDrawTabImage(w, dpi, WINDOW_MULTIPLAYER_PAGE_PLAYERS, SPR_TAB_GUESTS_0); WindowMultiplayerDrawTabImage(w, dpi, WINDOW_MULTIPLAYER_PAGE_PLAYERS, SPR_TAB_GUESTS_0);

2
src/openrct2-ui/windows/NetworkStatus.cpp
View File

@ -99,7 +99,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
thread_local std::string _buffer; thread_local std::string _buffer;
_buffer.assign("{BLACK}"); _buffer.assign("{BLACK}");
_buffer += _windowNetworkStatusText; _buffer += _windowNetworkStatusText;

2
src/openrct2-ui/windows/NewRide.cpp
View File

@ -427,7 +427,7 @@ public:
} }
else else
{ {
WindowResearchDevelopmentPagePaint(this, &dpi, WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP); WindowResearchDevelopmentPagePaint(this, dpi, WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP);
} }
} }

8
src/openrct2-ui/windows/NewsOptions.cpp
View File

@ -204,7 +204,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
DrawWidgets(dpi); DrawWidgets(dpi);
DrawTabImages(&dpi); DrawTabImages(dpi);
} }
private: private:
@ -218,14 +218,14 @@ private:
} }
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
DrawTabImage(dpi, NOTIFICATION_CATEGORY_PARK, SPR_TAB_PARK); DrawTabImage(dpi, NOTIFICATION_CATEGORY_PARK, SPR_TAB_PARK);
DrawTabImage(dpi, NOTIFICATION_CATEGORY_RIDE, SPR_TAB_RIDE_0); DrawTabImage(dpi, NOTIFICATION_CATEGORY_RIDE, SPR_TAB_RIDE_0);
DrawTabImage(dpi, NOTIFICATION_CATEGORY_GUEST, SPR_TAB_GUESTS_0); DrawTabImage(dpi, NOTIFICATION_CATEGORY_GUEST, SPR_TAB_GUESTS_0);
} }
void DrawTabImage(DrawPixelInfo* dpi, int32_t p, int32_t spriteIndex) void DrawTabImage(DrawPixelInfo& dpi, int32_t p, int32_t spriteIndex)
{ {
WidgetIndex widgetIndex = WIDX_FIRST_TAB + p; WidgetIndex widgetIndex = WIDX_FIRST_TAB + p;
@ -242,7 +242,7 @@ private:
} }
const auto& widget = widgets[widgetIndex]; const auto& widget = widgets[widgetIndex];
GfxDrawSprite(*dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget.left, widget.top }); GfxDrawSprite(dpi, ImageId(spriteIndex), windowPos + ScreenCoordsXY{ widget.left, widget.top });
} }
} }

2
src/openrct2-ui/windows/ObjectLoadError.cpp
View File

@ -487,7 +487,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
// Draw explanatory message // Draw explanatory message
auto ft = Formatter(); auto ft = Formatter();

26
src/openrct2-ui/windows/Options.cpp
View File

@ -555,15 +555,15 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
DrawWidgets(dpi); DrawWidgets(dpi);
DrawTabImages(&dpi); DrawTabImages(dpi);
switch (page) switch (page)
{ {
case WINDOW_OPTIONS_PAGE_DISPLAY: case WINDOW_OPTIONS_PAGE_DISPLAY:
DisplayDraw(&dpi); DisplayDraw(dpi);
break; break;
case WINDOW_OPTIONS_PAGE_ADVANCED: case WINDOW_OPTIONS_PAGE_ADVANCED:
AdvancedDraw(&dpi); AdvancedDraw(dpi);
break; break;
default: default:
break; break;
@ -909,12 +909,12 @@ private:
widgets[WIDX_DRAWING_ENGINE].text = DrawingEngineStringIds[EnumValue(gConfigGeneral.DrawingEngine)]; widgets[WIDX_DRAWING_ENGINE].text = DrawingEngineStringIds[EnumValue(gConfigGeneral.DrawingEngine)];
} }
void DisplayDraw(DrawPixelInfo* dpi) void DisplayDraw(DrawPixelInfo& dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int32_t>(static_cast<int32_t>(gConfigGeneral.WindowScale * 100)); ft.Add<int32_t>(static_cast<int32_t>(gConfigGeneral.WindowScale * 100));
DrawTextBasic( DrawTextBasic(
*dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_SCALE].left + 1, widgets[WIDX_SCALE].top + 1 }, dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_SCALE].left + 1, widgets[WIDX_SCALE].top + 1 },
STR_WINDOW_COLOUR_2_COMMA2DP32, ft, { colours[1] }); STR_WINDOW_COLOUR_2_COMMA2DP32, ft, { colours[1] });
} }
#pragma endregion #pragma endregion
@ -1997,12 +1997,12 @@ private:
widgets[WIDX_AUTOSAVE_FREQUENCY].text = AutosaveNames[gConfigGeneral.AutosaveFrequency]; widgets[WIDX_AUTOSAVE_FREQUENCY].text = AutosaveNames[gConfigGeneral.AutosaveFrequency];
} }
void AdvancedDraw(DrawPixelInfo* dpi) void AdvancedDraw(DrawPixelInfo& dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int32_t>(static_cast<int32_t>(gConfigGeneral.AutosaveAmount)); ft.Add<int32_t>(static_cast<int32_t>(gConfigGeneral.AutosaveAmount));
DrawTextBasic( DrawTextBasic(
*dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_AUTOSAVE_AMOUNT].left + 1, widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 }, dpi, windowPos + ScreenCoordsXY{ widgets[WIDX_AUTOSAVE_AMOUNT].left + 1, widgets[WIDX_AUTOSAVE_AMOUNT].top + 1 },
STR_WINDOW_COLOUR_2_COMMA16, ft, { colours[1] }); STR_WINDOW_COLOUR_2_COMMA16, ft, { colours[1] });
const auto normalisedPath = Platform::StrDecompToPrecomp(gConfigGeneral.RCT1Path); const auto normalisedPath = Platform::StrDecompToPrecomp(gConfigGeneral.RCT1Path);
@ -2017,7 +2017,7 @@ private:
uint32_t padding = widgetHeight > lineHeight ? (widgetHeight - lineHeight) / 2 : 0; uint32_t padding = widgetHeight > lineHeight ? (widgetHeight - lineHeight) / 2 : 0;
ScreenCoordsXY screenCoords = { windowPos.x + pathWidget.left + 1, ScreenCoordsXY screenCoords = { windowPos.x + pathWidget.left + 1,
windowPos.y + pathWidget.top + static_cast<int32_t>(padding) }; windowPos.y + pathWidget.top + static_cast<int32_t>(padding) };
DrawTextEllipsised(*dpi, screenCoords, 277, STR_STRING, ft, { colours[1] }); DrawTextEllipsised(dpi, screenCoords, 277, STR_STRING, ft, { colours[1] });
} }
OpenRCT2String AdvancedTooltip(WidgetIndex widgetIndex, StringId fallback) OpenRCT2String AdvancedTooltip(WidgetIndex widgetIndex, StringId fallback)
@ -2068,7 +2068,7 @@ private:
Dropdown::Flag::StayOpen, num_items, widget->width() - 3); Dropdown::Flag::StayOpen, num_items, widget->width() - 3);
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_DISPLAY, SPR_TAB_PAINT_0); DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_DISPLAY, SPR_TAB_PAINT_0);
DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_RENDERING, SPR_G2_TAB_TREE); DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_RENDERING, SPR_G2_TAB_TREE);
@ -2079,7 +2079,7 @@ private:
DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_ADVANCED, SPR_TAB_WRENCH_0); DrawTabImage(dpi, WINDOW_OPTIONS_PAGE_ADVANCED, SPR_TAB_WRENCH_0);
} }
void DrawTabImage(DrawPixelInfo* dpi, int32_t p, int32_t spriteIndex) void DrawTabImage(DrawPixelInfo& dpi, int32_t p, int32_t spriteIndex)
{ {
WidgetIndex widgetIndex = WIDX_FIRST_TAB + p; WidgetIndex widgetIndex = WIDX_FIRST_TAB + p;
Widget* widget = &widgets[widgetIndex]; Widget* widget = &widgets[widgetIndex];
@ -2095,7 +2095,7 @@ private:
} }
// Draw normal, enabled sprite. // Draw normal, enabled sprite.
GfxDrawSprite(*dpi, ImageId(spriteIndex), screenCoords); GfxDrawSprite(dpi, ImageId(spriteIndex), screenCoords);
} }
else else
{ {
@ -2104,10 +2104,10 @@ private:
// Draw greyed out (light border bottom right shadow) // Draw greyed out (light border bottom right shadow)
GfxDrawSpriteSolid( GfxDrawSpriteSolid(
dpi, ImageId(spriteIndex), screenCoords + ScreenCoordsXY{ 1, 1 }, ColourMapA[window_colour].lighter); &dpi, ImageId(spriteIndex), screenCoords + ScreenCoordsXY{ 1, 1 }, ColourMapA[window_colour].lighter);
// Draw greyed out (dark) // Draw greyed out (dark)
GfxDrawSpriteSolid(dpi, ImageId(spriteIndex), screenCoords, ColourMapA[window_colour].mid_light); GfxDrawSpriteSolid(&dpi, ImageId(spriteIndex), screenCoords, ColourMapA[window_colour].mid_light);
} }
} }

2
src/openrct2-ui/windows/Park.cpp
View File

@ -593,7 +593,7 @@ private:
// Draw viewport // Draw viewport
if (viewport != nullptr) if (viewport != nullptr)
{ {
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
if (viewport->flags & VIEWPORT_FLAG_SOUND_ON) if (viewport->flags & VIEWPORT_FLAG_SOUND_ON)
GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 }); GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 });
} }

30
src/openrct2-ui/windows/Player.cpp
View File

@ -165,11 +165,11 @@ public:
switch (page) switch (page)
{ {
case WINDOW_PLAYER_PAGE_OVERVIEW: case WINDOW_PLAYER_PAGE_OVERVIEW:
OnDrawOverview(&dpi); OnDrawOverview(dpi);
break; break;
case WINDOW_PLAYER_PAGE_STATISTICS: case WINDOW_PLAYER_PAGE_STATISTICS:
OnDrawStatistics(&dpi); OnDrawStatistics(dpi);
break; break;
} }
} }
@ -258,7 +258,7 @@ private:
} }
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
Widget* widget; Widget* widget;
@ -267,7 +267,7 @@ private:
{ {
widget = &this->widgets[WIDX_TAB_1]; widget = &this->widgets[WIDX_TAB_1];
auto screenCoords = windowPos + ScreenCoordsXY{ widget->left, widget->top }; auto screenCoords = windowPos + ScreenCoordsXY{ widget->left, widget->top };
GfxDrawSprite(*dpi, ImageId(SPR_PEEP_LARGE_FACE_NORMAL), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_PEEP_LARGE_FACE_NORMAL), screenCoords);
} }
// Tab 2 // Tab 2
@ -282,7 +282,7 @@ private:
imageId += (frame_no / 2) & 7; imageId += (frame_no / 2) & 7;
} }
GfxDrawSprite(*dpi, ImageId(imageId), screenCoords); GfxDrawSprite(dpi, ImageId(imageId), screenCoords);
} }
} }
@ -430,9 +430,9 @@ private:
WidgetSetEnabled(*this, WIDX_KICK, canKick && !isOwnWindow && !isServer); WidgetSetEnabled(*this, WIDX_KICK, canKick && !isOwnWindow && !isServer);
} }
void OnDrawOverview(DrawPixelInfo* dpi) void OnDrawOverview(DrawPixelInfo& dpi)
{ {
DrawWidgets(*dpi); DrawWidgets(dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
int32_t player = NetworkGetPlayerIndex(static_cast<uint8_t>(number)); int32_t player = NetworkGetPlayerIndex(static_cast<uint8_t>(number));
@ -454,7 +454,7 @@ private:
ft.Add<const char*>(_buffer.c_str()); ft.Add<const char*>(_buffer.c_str());
DrawTextEllipsised( DrawTextEllipsised(
*dpi, windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft, dpi, windowPos + ScreenCoordsXY{ widget->midX() - 5, widget->top }, widget->width() - 8, STR_STRING, ft,
{ TextAlignment::CENTRE }); { TextAlignment::CENTRE });
} }
@ -463,10 +463,10 @@ private:
auto ft = Formatter(); auto ft = Formatter();
ft.Add<StringId>(STR_PING); ft.Add<StringId>(STR_PING);
DrawTextBasic(*dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft); DrawTextBasic(dpi, screenCoords, STR_WINDOW_COLOUR_2_STRINGID, ft);
char ping[64]; char ping[64];
snprintf(ping, 64, "%d ms", NetworkGetPlayerPing(player)); snprintf(ping, 64, "%d ms", NetworkGetPlayerPing(player));
GfxDrawString(*dpi, screenCoords + ScreenCoordsXY(30, 0), ping, { colours[2] }); GfxDrawString(dpi, screenCoords + ScreenCoordsXY(30, 0), ping, { colours[2] });
// Draw last action // Draw last action
screenCoords = windowPos + ScreenCoordsXY{ width / 2, height - 13 }; screenCoords = windowPos + ScreenCoordsXY{ width / 2, height - 13 };
@ -481,7 +481,7 @@ private:
{ {
ft.Add<StringId>(STR_ACTION_NA); ft.Add<StringId>(STR_ACTION_NA);
} }
DrawTextEllipsised(*dpi, screenCoords, updatedWidth, STR_LAST_ACTION_RAN, ft, { TextAlignment::CENTRE }); DrawTextEllipsised(dpi, screenCoords, updatedWidth, STR_LAST_ACTION_RAN, ft, { TextAlignment::CENTRE });
if (viewport != nullptr && var_492 != -1) if (viewport != nullptr && var_492 != -1)
{ {
@ -629,9 +629,9 @@ private:
WindowAlignTabs(this, WIDX_TAB_1, WIDX_TAB_2); WindowAlignTabs(this, WIDX_TAB_1, WIDX_TAB_2);
} }
void OnDrawStatistics(DrawPixelInfo* dpi) void OnDrawStatistics(DrawPixelInfo& dpi)
{ {
DrawWidgets(*dpi); DrawWidgets(dpi);
DrawTabImages(dpi); DrawTabImages(dpi);
int32_t player = NetworkGetPlayerIndex(static_cast<uint8_t>(number)); int32_t player = NetworkGetPlayerIndex(static_cast<uint8_t>(number));
@ -646,13 +646,13 @@ private:
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint32_t>(NetworkGetPlayerCommandsRan(player)); ft.Add<uint32_t>(NetworkGetPlayerCommandsRan(player));
DrawTextBasic(*dpi, screenCoords, STR_COMMANDS_RAN, ft); DrawTextBasic(dpi, screenCoords, STR_COMMANDS_RAN, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(NetworkGetPlayerMoneySpent(player)); ft.Add<uint32_t>(NetworkGetPlayerMoneySpent(player));
DrawTextBasic(*dpi, screenCoords, STR_MONEY_SPENT, ft); DrawTextBasic(dpi, screenCoords, STR_MONEY_SPENT, ft);
} }
#pragma endregion #pragma endregion

2
src/openrct2-ui/windows/RefurbishRidePrompt.cpp
View File

@ -75,7 +75,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
auto currentRide = GetRide(rideId); auto currentRide = GetRide(rideId);
if (currentRide != nullptr) if (currentRide != nullptr)

36
src/openrct2-ui/windows/Research.cpp
View File

@ -104,14 +104,14 @@ static Widget *window_research_page_widgets[] = {
static void WindowResearchDevelopmentMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowResearchDevelopmentMouseup(WindowBase *w, WidgetIndex widgetIndex);
static void WindowResearchDevelopmentUpdate(WindowBase *w); static void WindowResearchDevelopmentUpdate(WindowBase *w);
static void WindowResearchDevelopmentInvalidate(WindowBase *w); static void WindowResearchDevelopmentInvalidate(WindowBase *w);
static void WindowResearchDevelopmentPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowResearchDevelopmentPaint(WindowBase *w, DrawPixelInfo& dpi);
static void WindowResearchFundingMouseup(WindowBase *w, WidgetIndex widgetIndex); static void WindowResearchFundingMouseup(WindowBase *w, WidgetIndex widgetIndex);
static void WindowResearchFundingMousedown(WindowBase *w, WidgetIndex widgetIndex, Widget* widget); static void WindowResearchFundingMousedown(WindowBase *w, WidgetIndex widgetIndex, Widget* widget);
static void WindowResearchFundingDropdown(WindowBase *w, WidgetIndex widgetIndex, int32_t dropdownIndex); static void WindowResearchFundingDropdown(WindowBase *w, WidgetIndex widgetIndex, int32_t dropdownIndex);
static void WindowResearchFundingUpdate(WindowBase *w); static void WindowResearchFundingUpdate(WindowBase *w);
static void WindowResearchFundingInvalidate(WindowBase *w); static void WindowResearchFundingInvalidate(WindowBase *w);
static void WindowResearchFundingPaint(WindowBase *w, DrawPixelInfo *dpi); static void WindowResearchFundingPaint(WindowBase *w, DrawPixelInfo& dpi);
// //
static WindowEventList window_research_development_events([](auto& events) static WindowEventList window_research_development_events([](auto& events)
@ -156,7 +156,7 @@ static constexpr const StringId ResearchStageNames[] = {
static void WindowResearchSetPage(WindowBase* w, int32_t page); static void WindowResearchSetPage(WindowBase* w, int32_t page);
static void WindowResearchSetPressedTab(WindowBase* w); static void WindowResearchSetPressedTab(WindowBase* w);
static void WindowResearchDrawTabImages(DrawPixelInfo* dpi, WindowBase* w); static void WindowResearchDrawTabImages(DrawPixelInfo& dpi, WindowBase* w);
WindowBase* WindowResearchOpen() WindowBase* WindowResearchOpen()
{ {
@ -253,7 +253,7 @@ static void WindowResearchDevelopmentInvalidate(WindowBase* w)
* *
* rct2: 0x006B689B * rct2: 0x006B689B
*/ */
static void WindowResearchDevelopmentPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowResearchDevelopmentPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowResearchDrawTabImages(dpi, w); WindowResearchDrawTabImages(dpi, w);
@ -261,7 +261,7 @@ static void WindowResearchDevelopmentPaint(WindowBase* w, DrawPixelInfo* dpi)
WindowResearchDevelopmentPagePaint(w, dpi, WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP); WindowResearchDevelopmentPagePaint(w, dpi, WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP);
} }
void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, WidgetIndex baseWidgetIndex) void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo& dpi, WidgetIndex baseWidgetIndex)
{ {
baseWidgetIndex = baseWidgetIndex - WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP; baseWidgetIndex = baseWidgetIndex - WIDX_CURRENTLY_IN_DEVELOPMENT_GROUP;
@ -273,19 +273,19 @@ void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, Widge
// Research type // Research type
auto ft = Formatter(); auto ft = Formatter();
ft.Add<StringId>(STR_RESEARCH_UNKNOWN); ft.Add<StringId>(STR_RESEARCH_UNKNOWN);
DrawTextWrapped(*dpi, screenCoords, 296, STR_RESEARCH_TYPE_LABEL, ft); DrawTextWrapped(dpi, screenCoords, 296, STR_RESEARCH_TYPE_LABEL, ft);
screenCoords.y += 25; screenCoords.y += 25;
// Progress // Progress
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(STR_RESEARCH_COMPLETED_AL); ft.Add<StringId>(STR_RESEARCH_COMPLETED_AL);
DrawTextWrapped(*dpi, screenCoords, 296, STR_RESEARCH_PROGRESS_LABEL, ft); DrawTextWrapped(dpi, screenCoords, 296, STR_RESEARCH_PROGRESS_LABEL, ft);
screenCoords.y += 15; screenCoords.y += 15;
// Expected // Expected
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(STR_RESEARCH_STAGE_UNKNOWN); ft.Add<StringId>(STR_RESEARCH_STAGE_UNKNOWN);
DrawTextBasic(*dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft); DrawTextBasic(dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft);
} }
else else
{ {
@ -322,13 +322,13 @@ void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, Widge
{ {
ft.Add<StringId>(gResearchNextItem->GetName()); ft.Add<StringId>(gResearchNextItem->GetName());
} }
DrawTextWrapped(*dpi, screenCoords, 296, label, ft); DrawTextWrapped(dpi, screenCoords, 296, label, ft);
screenCoords.y += 25; screenCoords.y += 25;
// Progress // Progress
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(ResearchStageNames[gResearchProgressStage]); ft.Add<StringId>(ResearchStageNames[gResearchProgressStage]);
DrawTextWrapped(*dpi, screenCoords, 296, STR_RESEARCH_PROGRESS_LABEL, ft); DrawTextWrapped(dpi, screenCoords, 296, STR_RESEARCH_PROGRESS_LABEL, ft);
screenCoords.y += 15; screenCoords.y += 15;
// Expected // Expected
@ -344,7 +344,7 @@ void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, Widge
{ {
ft.Add<StringId>(STR_RESEARCH_STAGE_UNKNOWN); ft.Add<StringId>(STR_RESEARCH_STAGE_UNKNOWN);
} }
DrawTextBasic(*dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft); DrawTextBasic(dpi, screenCoords, STR_RESEARCH_EXPECTED_LABEL, ft);
} }
// Last development // Last development
@ -379,7 +379,7 @@ void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, Widge
} }
} }
DrawTextWrapped(*dpi, screenCoords, 266, lastDevelopmentFormat, ft); DrawTextWrapped(dpi, screenCoords, 266, lastDevelopmentFormat, ft);
} }
} }
@ -528,7 +528,7 @@ static void WindowResearchFundingInvalidate(WindowBase* w)
* *
* rct2: 0x0069DAF0 * rct2: 0x0069DAF0
*/ */
static void WindowResearchFundingPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowResearchFundingPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowResearchDrawTabImages(dpi, w); WindowResearchDrawTabImages(dpi, w);
@ -536,7 +536,7 @@ static void WindowResearchFundingPaint(WindowBase* w, DrawPixelInfo* dpi)
WindowResearchFundingPagePaint(w, dpi, WIDX_RESEARCH_FUNDING); WindowResearchFundingPagePaint(w, dpi, WIDX_RESEARCH_FUNDING);
} }
void WindowResearchFundingPagePaint(WindowBase* w, DrawPixelInfo* dpi, WidgetIndex baseWidgetIndex) void WindowResearchFundingPagePaint(WindowBase* w, DrawPixelInfo& dpi, WidgetIndex baseWidgetIndex)
{ {
if (gParkFlags & PARK_FLAGS_NO_MONEY) if (gParkFlags & PARK_FLAGS_NO_MONEY)
return; return;
@ -544,7 +544,7 @@ void WindowResearchFundingPagePaint(WindowBase* w, DrawPixelInfo* dpi, WidgetInd
int32_t currentResearchLevel = gResearchFundingLevel; int32_t currentResearchLevel = gResearchFundingLevel;
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(research_cost_table[currentResearchLevel]); ft.Add<money64>(research_cost_table[currentResearchLevel]);
DrawTextBasic(*dpi, w->windowPos + ScreenCoordsXY{ 10, 77 }, STR_RESEARCH_COST_PER_MONTH, ft); DrawTextBasic(dpi, w->windowPos + ScreenCoordsXY{ 10, 77 }, STR_RESEARCH_COST_PER_MONTH, ft);
} }
#pragma endregion #pragma endregion
@ -593,7 +593,7 @@ static void WindowResearchSetPressedTab(WindowBase* w)
w->pressed_widgets |= 1LL << (WIDX_TAB_1 + w->page); w->pressed_widgets |= 1LL << (WIDX_TAB_1 + w->page);
} }
static void WindowResearchDrawTabImage(DrawPixelInfo* dpi, WindowBase* w, int32_t page, int32_t spriteIndex) static void WindowResearchDrawTabImage(DrawPixelInfo& dpi, WindowBase* w, int32_t page, int32_t spriteIndex)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + page; WidgetIndex widgetIndex = WIDX_TAB_1 + page;
@ -608,12 +608,12 @@ static void WindowResearchDrawTabImage(DrawPixelInfo* dpi, WindowBase* w, int32_
} }
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(spriteIndex), dpi, ImageId(spriteIndex),
w->windowPos + ScreenCoordsXY{ w->widgets[widgetIndex].left, w->widgets[widgetIndex].top }); w->windowPos + ScreenCoordsXY{ w->widgets[widgetIndex].left, w->widgets[widgetIndex].top });
} }
} }
static void WindowResearchDrawTabImages(DrawPixelInfo* dpi, WindowBase* w) static void WindowResearchDrawTabImages(DrawPixelInfo& dpi, WindowBase* w)
{ {
WindowResearchDrawTabImage(dpi, w, WINDOW_RESEARCH_PAGE_DEVELOPMENT, SPR_TAB_FINANCES_RESEARCH_0); WindowResearchDrawTabImage(dpi, w, WINDOW_RESEARCH_PAGE_DEVELOPMENT, SPR_TAB_FINANCES_RESEARCH_0);
WindowResearchDrawTabImage(dpi, w, WINDOW_RESEARCH_PAGE_FUNDING, SPR_TAB_FINANCES_SUMMARY_0); WindowResearchDrawTabImage(dpi, w, WINDOW_RESEARCH_PAGE_FUNDING, SPR_TAB_FINANCES_SUMMARY_0);

248
src/openrct2-ui/windows/Ride.cpp
View File

@ -439,7 +439,7 @@ static void WindowRideMainUpdate(WindowBase* w);
static void WindowRideMainTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text); static void WindowRideMainTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text);
static void WindowRideMainViewportRotate(WindowBase* w); static void WindowRideMainViewportRotate(WindowBase* w);
static void WindowRideMainInvalidate(WindowBase* w); static void WindowRideMainInvalidate(WindowBase* w);
static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideMainFollowRide(WindowBase* w); static void WindowRideMainFollowRide(WindowBase* w);
static void WindowRideVehicleMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideVehicleMouseup(WindowBase* w, WidgetIndex widgetIndex);
@ -449,8 +449,8 @@ static void WindowRideVehicleDropdown(WindowBase* w, WidgetIndex widgetIndex, in
static void WindowRideVehicleUpdate(WindowBase* w); static void WindowRideVehicleUpdate(WindowBase* w);
static OpenRCT2String WindowRideVehicleTooltip(WindowBase* const w, const WidgetIndex widgetIndex, StringId fallback); static OpenRCT2String WindowRideVehicleTooltip(WindowBase* const w, const WidgetIndex widgetIndex, StringId fallback);
static void WindowRideVehicleInvalidate(WindowBase* w); static void WindowRideVehicleInvalidate(WindowBase* w);
static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex); static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex);
static void WindowRideOperatingMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideOperatingMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideOperatingResize(WindowBase* w); static void WindowRideOperatingResize(WindowBase* w);
@ -461,7 +461,7 @@ static void WindowRideOperatingDropdown(WindowBase* w, WidgetIndex widgetIndex,
static void WindowRideOperatingUpdate(WindowBase* w); static void WindowRideOperatingUpdate(WindowBase* w);
static void WindowRideOperatingTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text); static void WindowRideOperatingTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text);
static void WindowRideOperatingInvalidate(WindowBase* w); static void WindowRideOperatingInvalidate(WindowBase* w);
static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideMaintenanceMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideMaintenanceMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideMaintenanceResize(WindowBase* w); static void WindowRideMaintenanceResize(WindowBase* w);
@ -469,7 +469,7 @@ static void WindowRideMaintenanceMousedown(WindowBase* w, WidgetIndex widgetInde
static void WindowRideMaintenanceDropdown(WindowBase* w, WidgetIndex widgetIndex, int32_t dropdownIndex); static void WindowRideMaintenanceDropdown(WindowBase* w, WidgetIndex widgetIndex, int32_t dropdownIndex);
static void WindowRideMaintenanceUpdate(WindowBase* w); static void WindowRideMaintenanceUpdate(WindowBase* w);
static void WindowRideMaintenanceInvalidate(WindowBase* w); static void WindowRideMaintenanceInvalidate(WindowBase* w);
static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideColourClose(WindowBase* w); static void WindowRideColourClose(WindowBase* w);
static void WindowRideColourMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideColourMouseup(WindowBase* w, WidgetIndex widgetIndex);
@ -480,8 +480,8 @@ static void WindowRideColourUpdate(WindowBase* w);
static void WindowRideColourTooldown(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords); static void WindowRideColourTooldown(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords);
static void WindowRideColourTooldrag(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords); static void WindowRideColourTooldrag(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords);
static void WindowRideColourInvalidate(WindowBase* w); static void WindowRideColourInvalidate(WindowBase* w);
static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex); static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex);
static void WindowRideMusicMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideMusicMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideMusicResize(WindowBase* w); static void WindowRideMusicResize(WindowBase* w);
@ -489,7 +489,7 @@ static void WindowRideMusicMousedown(WindowBase* w, WidgetIndex widgetIndex, Wid
static void WindowRideMusicDropdown(WindowBase* w, WidgetIndex widgetIndex, int32_t dropdownIndex); static void WindowRideMusicDropdown(WindowBase* w, WidgetIndex widgetIndex, int32_t dropdownIndex);
static void WindowRideMusicUpdate(WindowBase* w); static void WindowRideMusicUpdate(WindowBase* w);
static void WindowRideMusicInvalidate(WindowBase* w); static void WindowRideMusicInvalidate(WindowBase* w);
static void WindowRideMusicPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideMusicPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideMeasurementsClose(WindowBase* w); static void WindowRideMeasurementsClose(WindowBase* w);
static void WindowRideMeasurementsMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideMeasurementsMouseup(WindowBase* w, WidgetIndex widgetIndex);
@ -501,7 +501,7 @@ static void WindowRideMeasurementsTooldown(WindowBase* w, WidgetIndex widgetInde
static void WindowRideMeasurementsTooldrag(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords); static void WindowRideMeasurementsTooldrag(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords);
static void WindowRideMeasurementsToolabort(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideMeasurementsToolabort(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideMeasurementsInvalidate(WindowBase* w); static void WindowRideMeasurementsInvalidate(WindowBase* w);
static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideGraphsMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideGraphsMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideGraphsResize(WindowBase* w); static void WindowRideGraphsResize(WindowBase* w);
@ -511,8 +511,8 @@ static void WindowRideGraphsScrollgetheight(WindowBase* w, int32_t scrollIndex,
static void WindowRideGraphs15(WindowBase* w, int32_t scrollIndex, int32_t scrollAreaType); static void WindowRideGraphs15(WindowBase* w, int32_t scrollIndex, int32_t scrollAreaType);
static OpenRCT2String WindowRideGraphsTooltip(WindowBase* w, const WidgetIndex widgetIndex, const StringId fallback); static OpenRCT2String WindowRideGraphsTooltip(WindowBase* w, const WidgetIndex widgetIndex, const StringId fallback);
static void WindowRideGraphsInvalidate(WindowBase* w); static void WindowRideGraphsInvalidate(WindowBase* w);
static void WindowRideGraphsPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideGraphsPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex); static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex);
static void WindowRideIncomeMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideIncomeMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideIncomeResize(WindowBase* w); static void WindowRideIncomeResize(WindowBase* w);
@ -520,14 +520,14 @@ static void WindowRideIncomeMousedown(WindowBase* w, WidgetIndex widgetIndex, Wi
static void WindowRideIncomeUpdate(WindowBase* w); static void WindowRideIncomeUpdate(WindowBase* w);
static void WindowRideIncomeTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text); static void WindowRideIncomeTextinput(WindowBase* w, WidgetIndex widgetIndex, const char* text);
static void WindowRideIncomeInvalidate(WindowBase* w); static void WindowRideIncomeInvalidate(WindowBase* w);
static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo& dpi);
static bool WindowRideIncomeCanModifyPrimaryPrice(WindowBase* w); static bool WindowRideIncomeCanModifyPrimaryPrice(WindowBase* w);
static void WindowRideCustomerMouseup(WindowBase* w, WidgetIndex widgetIndex); static void WindowRideCustomerMouseup(WindowBase* w, WidgetIndex widgetIndex);
static void WindowRideCustomerResize(WindowBase* w); static void WindowRideCustomerResize(WindowBase* w);
static void WindowRideCustomerUpdate(WindowBase* w); static void WindowRideCustomerUpdate(WindowBase* w);
static void WindowRideCustomerInvalidate(WindowBase* w); static void WindowRideCustomerInvalidate(WindowBase* w);
static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi); static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo& dpi);
static void WindowRideSetPage(WindowBase* w, int32_t page); static void WindowRideSetPage(WindowBase* w, int32_t page);
@ -862,7 +862,7 @@ static const RideObjectEntry* VehicleDropdownRideType = nullptr;
static bool VehicleDropdownExpanded = false; static bool VehicleDropdownExpanded = false;
static std::vector<VehicleTypeLabel> VehicleDropdownData; static std::vector<VehicleTypeLabel> VehicleDropdownData;
static void WindowRideDrawTabImage(DrawPixelInfo* dpi, WindowBase* w, int32_t page, int32_t spriteIndex) static void WindowRideDrawTabImage(DrawPixelInfo& dpi, WindowBase* w, int32_t page, int32_t spriteIndex)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + page; WidgetIndex widgetIndex = WIDX_TAB_1 + page;
@ -875,7 +875,7 @@ static void WindowRideDrawTabImage(DrawPixelInfo* dpi, WindowBase* w, int32_t pa
} }
const auto& widget = w->widgets[widgetIndex]; const auto& widget = w->widgets[widgetIndex];
GfxDrawSprite(*dpi, ImageId(spriteIndex), w->windowPos + ScreenCoordsXY{ widget.left, widget.top }); GfxDrawSprite(dpi, ImageId(spriteIndex), w->windowPos + ScreenCoordsXY{ widget.left, widget.top });
} }
} }
@ -883,7 +883,7 @@ static void WindowRideDrawTabImage(DrawPixelInfo* dpi, WindowBase* w, int32_t pa
* *
* rct2: 0x006B2E88 * rct2: 0x006B2E88
*/ */
static void WindowRideDrawTabMain(DrawPixelInfo* dpi, WindowBase* w) static void WindowRideDrawTabMain(DrawPixelInfo& dpi, WindowBase* w)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_MAIN); WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_MAIN);
if (!WidgetIsDisabled(*w, widgetIndex)) if (!WidgetIsDisabled(*w, widgetIndex))
@ -912,7 +912,7 @@ static void WindowRideDrawTabMain(DrawPixelInfo* dpi, WindowBase* w)
} }
const auto& widget = w->widgets[widgetIndex]; const auto& widget = w->widgets[widgetIndex];
GfxDrawSprite(*dpi, ImageId(spriteIndex), w->windowPos + ScreenCoordsXY{ widget.left, widget.top }); GfxDrawSprite(dpi, ImageId(spriteIndex), w->windowPos + ScreenCoordsXY{ widget.left, widget.top });
} }
} }
} }
@ -921,7 +921,7 @@ static void WindowRideDrawTabMain(DrawPixelInfo* dpi, WindowBase* w)
* *
* rct2: 0x006B2B68 * rct2: 0x006B2B68
*/ */
static void WindowRideDrawTabVehicle(DrawPixelInfo* dpi, WindowBase* w) static void WindowRideDrawTabVehicle(DrawPixelInfo& dpi, WindowBase* w)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_VEHICLE); WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_VEHICLE);
const auto& widget = w->widgets[widgetIndex]; const auto& widget = w->widgets[widgetIndex];
@ -937,7 +937,7 @@ static void WindowRideDrawTabVehicle(DrawPixelInfo* dpi, WindowBase* w)
screenCoords += w->windowPos; screenCoords += w->windowPos;
DrawPixelInfo clipDPI; DrawPixelInfo clipDPI;
if (!ClipDrawPixelInfo(&clipDPI, dpi, screenCoords, width, height)) if (!ClipDrawPixelInfo(&clipDPI, &dpi, screenCoords, width, height))
{ {
return; return;
} }
@ -992,7 +992,7 @@ static void WindowRideDrawTabVehicle(DrawPixelInfo* dpi, WindowBase* w)
* *
* rct2: 0x006B2F42 * rct2: 0x006B2F42
*/ */
static void WindowRideDrawTabCustomer(DrawPixelInfo* dpi, WindowBase* w) static void WindowRideDrawTabCustomer(DrawPixelInfo& dpi, WindowBase* w)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_CUSTOMER); WidgetIndex widgetIndex = WIDX_TAB_1 + static_cast<int32_t>(WINDOW_RIDE_PAGE_CUSTOMER);
@ -1006,7 +1006,7 @@ static void WindowRideDrawTabCustomer(DrawPixelInfo* dpi, WindowBase* w)
spriteIndex += GetPeepAnimation(PeepSpriteType::Normal).base_image + 1; spriteIndex += GetPeepAnimation(PeepSpriteType::Normal).base_image + 1;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(spriteIndex, COLOUR_BRIGHT_RED, COLOUR_TEAL), dpi, ImageId(spriteIndex, COLOUR_BRIGHT_RED, COLOUR_TEAL),
w->windowPos + ScreenCoordsXY{ widget.midX(), widget.bottom - 6 }); w->windowPos + ScreenCoordsXY{ widget.midX(), widget.bottom - 6 });
} }
} }
@ -1015,7 +1015,7 @@ static void WindowRideDrawTabCustomer(DrawPixelInfo* dpi, WindowBase* w)
* *
* rct2: 0x006B2B35 * rct2: 0x006B2B35
*/ */
static void WindowRideDrawTabImages(DrawPixelInfo* dpi, WindowBase* w) static void WindowRideDrawTabImages(DrawPixelInfo& dpi, WindowBase* w)
{ {
WindowRideDrawTabVehicle(dpi, w); WindowRideDrawTabVehicle(dpi, w);
WindowRideDrawTabImage(dpi, w, WINDOW_RIDE_PAGE_OPERATING, SPR_TAB_GEARS_0); WindowRideDrawTabImage(dpi, w, WINDOW_RIDE_PAGE_OPERATING, SPR_TAB_GEARS_0);
@ -2580,7 +2580,7 @@ static StringId WindowRideGetStatus(WindowBase* w, Formatter& ft)
* *
* rct2: 0x006AEE73 * rct2: 0x006AEE73
*/ */
static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
Widget* widget; Widget* widget;
@ -2592,7 +2592,7 @@ static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
WindowDrawViewport(dpi, *w); WindowDrawViewport(dpi, *w);
if (w->viewport->flags & VIEWPORT_FLAG_SOUND_ON) if (w->viewport->flags & VIEWPORT_FLAG_SOUND_ON)
GfxDrawSprite(*dpi, ImageId(SPR_HEARING_VIEWPORT), w->windowPos + ScreenCoordsXY{ 2, 2 }); GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), w->windowPos + ScreenCoordsXY{ 2, 2 });
} }
// View dropdown // View dropdown
@ -2621,7 +2621,7 @@ static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo* dpi)
widget = &window_ride_main_widgets[WIDX_VIEW]; widget = &window_ride_main_widgets[WIDX_VIEW];
DrawTextBasic( DrawTextBasic(
*dpi, { w->windowPos.x + (widget->left + widget->right - 11) / 2, w->windowPos.y + widget->top }, dpi, { w->windowPos.x + (widget->left + widget->right - 11) / 2, w->windowPos.y + widget->top },
STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::CENTRE }); STR_WINDOW_COLOUR_2_STRINGID, ft, { TextAlignment::CENTRE });
// Status // Status
@ -2629,7 +2629,7 @@ static void WindowRideMainPaint(WindowBase* w, DrawPixelInfo* dpi)
widget = &window_ride_main_widgets[WIDX_STATUS]; widget = &window_ride_main_widgets[WIDX_STATUS];
StringId rideStatus = WindowRideGetStatus(w, ft); StringId rideStatus = WindowRideGetStatus(w, ft);
DrawTextEllipsised( DrawTextEllipsised(
*dpi, w->windowPos + ScreenCoordsXY{ (widget->left + widget->right) / 2, widget->top }, widget->width(), rideStatus, ft, dpi, w->windowPos + ScreenCoordsXY{ (widget->left + widget->right) / 2, widget->top }, widget->width(), rideStatus, ft,
{ TextAlignment::CENTRE }); { TextAlignment::CENTRE });
} }
@ -2885,7 +2885,7 @@ static void WindowRideVehicleInvalidate(WindowBase* w)
* *
* rct2: 0x006B23DC * rct2: 0x006B23DC
*/ */
static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -2903,13 +2903,13 @@ static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi)
// Description // Description
auto ft = Formatter(); auto ft = Formatter();
ft.Add<StringId>(rideEntry->naming.Description); ft.Add<StringId>(rideEntry->naming.Description);
screenCoords.y += DrawTextWrapped(*dpi, screenCoords, 300, STR_BLACK_STRING, ft, { TextAlignment::LEFT }); screenCoords.y += DrawTextWrapped(dpi, screenCoords, 300, STR_BLACK_STRING, ft, { TextAlignment::LEFT });
screenCoords.y += 2; screenCoords.y += 2;
// Capacity // Capacity
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(rideEntry->capacity); ft.Add<StringId>(rideEntry->capacity);
DrawTextBasic(*dpi, screenCoords, STR_CAPACITY, ft); DrawTextBasic(dpi, screenCoords, STR_CAPACITY, ft);
// Excitement Factor // Excitement Factor
if (rideEntry->excitement_multiplier != 0) if (rideEntry->excitement_multiplier != 0)
@ -2919,7 +2919,7 @@ static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(abs(rideEntry->excitement_multiplier)); ft.Add<int16_t>(abs(rideEntry->excitement_multiplier));
StringId stringId = rideEntry->excitement_multiplier > 0 ? STR_EXCITEMENT_FACTOR : STR_EXCITEMENT_FACTOR_NEGATIVE; StringId stringId = rideEntry->excitement_multiplier > 0 ? STR_EXCITEMENT_FACTOR : STR_EXCITEMENT_FACTOR_NEGATIVE;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
} }
// Intensity Factor // Intensity Factor
@ -2934,7 +2934,7 @@ static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(abs(rideEntry->intensity_multiplier)); ft.Add<int16_t>(abs(rideEntry->intensity_multiplier));
StringId stringId = rideEntry->intensity_multiplier > 0 ? STR_INTENSITY_FACTOR : STR_INTENSITY_FACTOR_NEGATIVE; StringId stringId = rideEntry->intensity_multiplier > 0 ? STR_INTENSITY_FACTOR : STR_INTENSITY_FACTOR_NEGATIVE;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
if (lineHeight != 10) if (lineHeight != 10)
screenCoords.x -= 150; screenCoords.x -= 150;
@ -2948,7 +2948,7 @@ static void WindowRideVehiclePaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(abs(rideEntry->nausea_multiplier)); ft.Add<int16_t>(abs(rideEntry->nausea_multiplier));
StringId stringId = rideEntry->nausea_multiplier > 0 ? STR_NAUSEA_FACTOR : STR_NAUSEA_FACTOR_NEGATIVE; StringId stringId = rideEntry->nausea_multiplier > 0 ? STR_NAUSEA_FACTOR : STR_NAUSEA_FACTOR_NEGATIVE;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
} }
} }
@ -2963,7 +2963,7 @@ struct VehicleDrawInfo
* *
* rct2: 0x006B2502 * rct2: 0x006B2502
*/ */
static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
auto ride = GetRide(w->rideId); auto ride = GetRide(w->rideId);
if (ride == nullptr) if (ride == nullptr)
@ -2972,7 +2972,7 @@ static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int3
const auto* rideEntry = ride->GetRideEntry(); const auto* rideEntry = ride->GetRideEntry();
// Background // Background
GfxFillRect(dpi, { { dpi->x, dpi->y }, { dpi->x + dpi->width, dpi->y + dpi->height } }, PALETTE_INDEX_12); GfxFillRect(&dpi, { { dpi.x, dpi.y }, { dpi.x + dpi.width, dpi.y + dpi.height } }, PALETTE_INDEX_12);
Widget* widget = &window_ride_vehicle_widgets[WIDX_VEHICLE_TRAINS_PREVIEW]; Widget* widget = &window_ride_vehicle_widgets[WIDX_VEHICLE_TRAINS_PREVIEW];
int32_t startX = std::max(2, (widget->width() - ((ride->NumTrains - 1) * 36)) / 2 - 25); int32_t startX = std::max(2, (widget->width() - ((ride->NumTrains - 1) * 36)) / 2 - 25);
@ -3038,7 +3038,7 @@ static void WindowRideVehicleScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int3
VehicleDrawInfo* current = nextSpriteToDraw; VehicleDrawInfo* current = nextSpriteToDraw;
while (--current >= trainCarImages) while (--current >= trainCarImages)
GfxDrawSprite(*dpi, current->imageId, { current->x, current->y }); GfxDrawSprite(dpi, current->imageId, { current->x, current->y });
startX += 36; startX += 36;
} }
@ -3721,7 +3721,7 @@ static void WindowRideOperatingInvalidate(WindowBase* w)
* *
* rct2: 0x006B1001 * rct2: 0x006B1001
*/ */
static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -3732,7 +3732,7 @@ static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo* dpi)
// Horizontal rule between mode settings and depart settings // Horizontal rule between mode settings and depart settings
GfxFillRectInset( GfxFillRectInset(
dpi, &dpi,
{ w->windowPos + ScreenCoordsXY{ window_ride_operating_widgets[WIDX_PAGE_BACKGROUND].left + 4, 103 }, { w->windowPos + ScreenCoordsXY{ window_ride_operating_widgets[WIDX_PAGE_BACKGROUND].left + 4, 103 },
w->windowPos + ScreenCoordsXY{ window_ride_operating_widgets[WIDX_PAGE_BACKGROUND].right - 5, 104 } }, w->windowPos + ScreenCoordsXY{ window_ride_operating_widgets[WIDX_PAGE_BACKGROUND].right - 5, 104 } },
w->colours[1], INSET_RECT_FLAG_BORDER_INSET); w->colours[1], INSET_RECT_FLAG_BORDER_INSET);
@ -3743,7 +3743,7 @@ static void WindowRideOperatingPaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint16_t>(ride->num_block_brakes + ride->num_stations); ft.Add<uint16_t>(ride->num_block_brakes + ride->num_stations);
DrawTextBasic( DrawTextBasic(
*dpi, w->windowPos + ScreenCoordsXY{ 21, ride->mode == RideMode::PoweredLaunchBlockSectioned ? 89 : 61 }, dpi, w->windowPos + ScreenCoordsXY{ 21, ride->mode == RideMode::PoweredLaunchBlockSectioned ? 89 : 61 },
STR_BLOCK_SECTIONS, ft, COLOUR_BLACK); STR_BLOCK_SECTIONS, ft, COLOUR_BLACK);
} }
} }
@ -3784,9 +3784,9 @@ static void WindowRideLocateMechanic(WindowBase* w)
* rct2: 0x006B7D08 * rct2: 0x006B7D08
*/ */
static void WindowRideMaintenanceDrawBar( static void WindowRideMaintenanceDrawBar(
WindowBase* w, DrawPixelInfo* dpi, const ScreenCoordsXY& coords, int32_t value, int32_t colour) WindowBase* w, DrawPixelInfo& dpi, const ScreenCoordsXY& coords, int32_t value, int32_t colour)
{ {
GfxFillRectInset(dpi, { coords, coords + ScreenCoordsXY{ 149, 8 } }, w->colours[1], INSET_RECT_F_30); GfxFillRectInset(&dpi, { coords, coords + ScreenCoordsXY{ 149, 8 } }, w->colours[1], INSET_RECT_F_30);
if (colour & BAR_BLINK) if (colour & BAR_BLINK)
{ {
colour &= ~BAR_BLINK; colour &= ~BAR_BLINK;
@ -3797,7 +3797,7 @@ static void WindowRideMaintenanceDrawBar(
value = ((186 * ((value * 2) & 0xFF)) >> 8) & 0xFF; value = ((186 * ((value * 2) & 0xFF)) >> 8) & 0xFF;
if (value > 2) if (value > 2)
{ {
GfxFillRectInset(dpi, { coords + ScreenCoordsXY{ 2, 1 }, coords + ScreenCoordsXY{ value + 1, 7 } }, colour, 0); GfxFillRectInset(&dpi, { coords + ScreenCoordsXY{ 2, 1 }, coords + ScreenCoordsXY{ value + 1, 7 } }, colour, 0);
} }
} }
@ -4117,7 +4117,7 @@ static void WindowRideMaintenanceInvalidate(WindowBase* w)
* *
* rct2: 0x006B1877 * rct2: 0x006B1877
*/ */
static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -4130,12 +4130,12 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
Widget* widget = &window_ride_maintenance_widgets[WIDX_LOCATE_MECHANIC]; Widget* widget = &window_ride_maintenance_widgets[WIDX_LOCATE_MECHANIC];
auto screenCoords = w->windowPos + ScreenCoordsXY{ widget->left, widget->top }; auto screenCoords = w->windowPos + ScreenCoordsXY{ widget->left, widget->top };
auto image = ImageId(SPR_MECHANIC, COLOUR_BLACK, gStaffMechanicColour); auto image = ImageId(SPR_MECHANIC, COLOUR_BLACK, gStaffMechanicColour);
GfxDrawSprite(*dpi, image, screenCoords); GfxDrawSprite(dpi, image, screenCoords);
// Inspection label // Inspection label
widget = &window_ride_maintenance_widgets[WIDX_INSPECTION_INTERVAL]; widget = &window_ride_maintenance_widgets[WIDX_INSPECTION_INTERVAL];
screenCoords = w->windowPos + ScreenCoordsXY{ 4, widget->top + 1 }; screenCoords = w->windowPos + ScreenCoordsXY{ 4, widget->top + 1 };
DrawTextBasic(*dpi, screenCoords, STR_INSPECTION); DrawTextBasic(dpi, screenCoords, STR_INSPECTION);
// Reliability // Reliability
widget = &window_ride_maintenance_widgets[WIDX_PAGE_BACKGROUND]; widget = &window_ride_maintenance_widgets[WIDX_PAGE_BACKGROUND];
@ -4144,7 +4144,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
uint16_t reliability = ride->reliability_percentage; uint16_t reliability = ride->reliability_percentage;
auto ft = Formatter(); auto ft = Formatter();
ft.Add<uint16_t>(reliability); ft.Add<uint16_t>(reliability);
DrawTextBasic(*dpi, screenCoords, STR_RELIABILITY_LABEL_1757, ft); DrawTextBasic(dpi, screenCoords, STR_RELIABILITY_LABEL_1757, ft);
WindowRideMaintenanceDrawBar( WindowRideMaintenanceDrawBar(
w, dpi, screenCoords + ScreenCoordsXY{ 103, 0 }, std::max<int32_t>(10, reliability), COLOUR_BRIGHT_GREEN); w, dpi, screenCoords + ScreenCoordsXY{ 103, 0 }, std::max<int32_t>(10, reliability), COLOUR_BRIGHT_GREEN);
screenCoords.y += 11; screenCoords.y += 11;
@ -4152,7 +4152,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
uint16_t downTime = ride->downtime; uint16_t downTime = ride->downtime;
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>(downTime); ft.Add<uint16_t>(downTime);
DrawTextBasic(*dpi, screenCoords, STR_DOWN_TIME_LABEL_1889, ft); DrawTextBasic(dpi, screenCoords, STR_DOWN_TIME_LABEL_1889, ft);
WindowRideMaintenanceDrawBar(w, dpi, screenCoords + ScreenCoordsXY{ 103, 0 }, downTime, COLOUR_BRIGHT_RED); WindowRideMaintenanceDrawBar(w, dpi, screenCoords + ScreenCoordsXY{ 103, 0 }, downTime, COLOUR_BRIGHT_RED);
screenCoords.y += 26; screenCoords.y += 26;
@ -4167,7 +4167,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>(ride->last_inspection); ft.Add<uint16_t>(ride->last_inspection);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += 12; screenCoords.y += 12;
// Last / current breakdown // Last / current breakdown
@ -4177,7 +4177,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
stringId = (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) ? STR_CURRENT_BREAKDOWN : STR_LAST_BREAKDOWN; stringId = (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) ? STR_CURRENT_BREAKDOWN : STR_LAST_BREAKDOWN;
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(RideBreakdownReasonNames[ride->breakdown_reason]); ft.Add<StringId>(RideBreakdownReasonNames[ride->breakdown_reason]);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += 12; screenCoords.y += 12;
// Mechanic status // Mechanic status
@ -4215,7 +4215,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
if (stringId == STR_CALLING_MECHANIC || stringId == STR_NO_MECHANICS_ARE_HIRED_MESSAGE) if (stringId == STR_CALLING_MECHANIC || stringId == STR_NO_MECHANICS_ARE_HIRED_MESSAGE)
{ {
DrawTextWrapped(*dpi, screenCoords, 280, stringId, {}, { TextAlignment::LEFT }); DrawTextWrapped(dpi, screenCoords, 280, stringId, {}, { TextAlignment::LEFT });
} }
else else
{ {
@ -4224,7 +4224,7 @@ static void WindowRideMaintenancePaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
ft = Formatter(); ft = Formatter();
staff->FormatNameTo(ft); staff->FormatNameTo(ft);
DrawTextWrapped(*dpi, screenCoords, 280, stringId, ft, { TextAlignment::LEFT }); DrawTextWrapped(dpi, screenCoords, 280, stringId, ft, { TextAlignment::LEFT });
} }
} }
} }
@ -4876,7 +4876,7 @@ static void WindowRideColourInvalidate(WindowBase* w)
* *
* rct2: 0x006AFF3E * rct2: 0x006AFF3E
*/ */
static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
// TODO: This should use lists and identified sprites // TODO: This should use lists and identified sprites
DrawPixelInfo clippedDpi; DrawPixelInfo clippedDpi;
@ -4892,7 +4892,7 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
const auto& trackPreviewWidget = window_ride_colour_widgets[WIDX_TRACK_PREVIEW]; const auto& trackPreviewWidget = window_ride_colour_widgets[WIDX_TRACK_PREVIEW];
if (trackPreviewWidget.type != WindowWidgetType::Empty) if (trackPreviewWidget.type != WindowWidgetType::Empty)
GfxFillRect( GfxFillRect(
dpi, &dpi,
{ { w->windowPos + ScreenCoordsXY{ trackPreviewWidget.left + 1, trackPreviewWidget.top + 1 } }, { { w->windowPos + ScreenCoordsXY{ trackPreviewWidget.left + 1, trackPreviewWidget.top + 1 } },
{ w->windowPos + ScreenCoordsXY{ trackPreviewWidget.right - 1, trackPreviewWidget.bottom - 1 } } }, { w->windowPos + ScreenCoordsXY{ trackPreviewWidget.right - 1, trackPreviewWidget.bottom - 1 } } },
PALETTE_INDEX_12); PALETTE_INDEX_12);
@ -4909,7 +4909,7 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
const auto& rtd = ride->GetRideTypeDescriptor(); const auto& rtd = ride->GetRideTypeDescriptor();
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)) if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{ {
GfxDrawSprite(*dpi, ImageId(MazeOptions[trackColour.supports].sprite), screenCoords); GfxDrawSprite(dpi, ImageId(MazeOptions[trackColour.supports].sprite), screenCoords);
} }
else else
{ {
@ -4917,14 +4917,14 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
int32_t spriteIndex = typeDescriptor.ColourPreview.Track; int32_t spriteIndex = typeDescriptor.ColourPreview.Track;
if (spriteIndex != 0) if (spriteIndex != 0)
{ {
GfxDrawSprite(*dpi, ImageId(spriteIndex, trackColour.main, trackColour.additional), screenCoords); GfxDrawSprite(dpi, ImageId(spriteIndex, trackColour.main, trackColour.additional), screenCoords);
} }
// Supports // Supports
spriteIndex = typeDescriptor.ColourPreview.Supports; spriteIndex = typeDescriptor.ColourPreview.Supports;
if (spriteIndex != 0) if (spriteIndex != 0)
{ {
GfxDrawSprite(*dpi, ImageId(spriteIndex, trackColour.supports), screenCoords); GfxDrawSprite(dpi, ImageId(spriteIndex, trackColour.supports), screenCoords);
} }
} }
} }
@ -4948,11 +4948,11 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
} }
GfxDrawSprite(*dpi, ImageId(GetShopItemDescriptor(shopItem).Image, spriteColour), screenCoords); GfxDrawSprite(dpi, ImageId(GetShopItemDescriptor(shopItem).Image, spriteColour), screenCoords);
} }
else else
{ {
GfxDrawSprite(*dpi, ImageId(GetShopItemDescriptor(shopItem).Image, ride->track_colour[0].main), screenCoords); GfxDrawSprite(dpi, ImageId(GetShopItemDescriptor(shopItem).Image, ride->track_colour[0].main), screenCoords);
} }
} }
@ -4962,7 +4962,7 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
if (entrancePreviewWidget.type != WindowWidgetType::Empty) if (entrancePreviewWidget.type != WindowWidgetType::Empty)
{ {
if (ClipDrawPixelInfo( if (ClipDrawPixelInfo(
&clippedDpi, dpi, &clippedDpi, &dpi,
w->windowPos + ScreenCoordsXY{ entrancePreviewWidget.left + 1, entrancePreviewWidget.top + 1 }, w->windowPos + ScreenCoordsXY{ entrancePreviewWidget.left + 1, entrancePreviewWidget.top + 1 },
entrancePreviewWidget.width(), entrancePreviewWidget.height())) entrancePreviewWidget.width(), entrancePreviewWidget.height()))
{ {
@ -4988,7 +4988,7 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
} }
DrawTextEllipsised(*dpi, { w->windowPos.x + 3, w->windowPos.y + 103 }, 97, STR_STATION_STYLE, {}); DrawTextEllipsised(dpi, { w->windowPos.x + 3, w->windowPos.y + 103 }, 97, STR_STATION_STYLE, {});
} }
} }
@ -4996,7 +4996,7 @@ static void WindowRideColourPaint(WindowBase* w, DrawPixelInfo* dpi)
* *
* rct2: 0x006B0192 * rct2: 0x006B0192
*/ */
static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
auto ride = GetRide(w->rideId); auto ride = GetRide(w->rideId);
if (ride == nullptr) if (ride == nullptr)
@ -5010,7 +5010,7 @@ static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
auto vehicleColour = RideGetVehicleColour(*ride, w->vehicleIndex); auto vehicleColour = RideGetVehicleColour(*ride, w->vehicleIndex);
// Background colour // Background colour
GfxFillRect(dpi, { { dpi->x, dpi->y }, { dpi->x + dpi->width - 1, dpi->y + dpi->height - 1 } }, PALETTE_INDEX_12); GfxFillRect(&dpi, { { dpi.x, dpi.y }, { dpi.x + dpi.width - 1, dpi.y + dpi.height - 1 } }, PALETTE_INDEX_12);
// ? // ?
auto screenCoords = ScreenCoordsXY{ vehiclePreviewWidget->width() / 2, vehiclePreviewWidget->height() - 15 }; auto screenCoords = ScreenCoordsXY{ vehiclePreviewWidget->width() / 2, vehiclePreviewWidget->height() - 15 };
@ -5031,7 +5031,7 @@ static void WindowRideColourScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
imageIndex *= carEntry.base_num_frames; imageIndex *= carEntry.base_num_frames;
imageIndex += carEntry.base_image_id; imageIndex += carEntry.base_image_id;
auto imageId = ImageId(imageIndex, vehicleColour.Body, vehicleColour.Trim, vehicleColour.Tertiary); auto imageId = ImageId(imageIndex, vehicleColour.Body, vehicleColour.Trim, vehicleColour.Tertiary);
GfxDrawSprite(*dpi, imageId, screenCoords); GfxDrawSprite(dpi, imageId, screenCoords);
} }
#pragma endregion #pragma endregion
@ -5259,7 +5259,7 @@ static void WindowRideMusicInvalidate(WindowBase* w)
* *
* rct2: 0x006B1ECC * rct2: 0x006B1ECC
*/ */
static void WindowRideMusicPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideMusicPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -5639,7 +5639,7 @@ static void WindowRideMeasurementsInvalidate(WindowBase* w)
* *
* rct2: 0x006ACF07 * rct2: 0x006ACF07
*/ */
static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -5649,12 +5649,12 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
Widget* widget = &window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND]; Widget* widget = &window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND];
ScreenCoordsXY widgetCoords(w->windowPos.x + widget->width() / 2, w->windowPos.y + widget->top + 40); ScreenCoordsXY widgetCoords(w->windowPos.x + widget->width() / 2, w->windowPos.y + widget->top + 40);
DrawTextWrapped(*dpi, widgetCoords, w->width - 8, STR_CLICK_ITEMS_OF_SCENERY_TO_SELECT, {}, { TextAlignment::CENTRE }); DrawTextWrapped(dpi, widgetCoords, w->width - 8, STR_CLICK_ITEMS_OF_SCENERY_TO_SELECT, {}, { TextAlignment::CENTRE });
widgetCoords.x = w->windowPos.x + 4; widgetCoords.x = w->windowPos.x + 4;
widgetCoords.y = w->windowPos.y + window_ride_measurements_widgets[WIDX_SELECT_NEARBY_SCENERY].bottom + 17; widgetCoords.y = w->windowPos.y + window_ride_measurements_widgets[WIDX_SELECT_NEARBY_SCENERY].bottom + 17;
GfxFillRectInset( GfxFillRectInset(
dpi, { widgetCoords, { w->windowPos.x + 312, widgetCoords.y + 1 } }, w->colours[1], INSET_RECT_FLAG_BORDER_INSET); &dpi, { widgetCoords, { w->windowPos.x + 312, widgetCoords.y + 1 } }, w->colours[1], INSET_RECT_FLAG_BORDER_INSET);
} }
else else
{ {
@ -5674,7 +5674,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
ft.Add<uint32_t>(ride->excitement); ft.Add<uint32_t>(ride->excitement);
ft.Add<StringId>(ratingName); ft.Add<StringId>(ratingName);
StringId stringId = !RideHasRatings(*ride) ? STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE : STR_EXCITEMENT_RATING; StringId stringId = !RideHasRatings(*ride) ? STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE : STR_EXCITEMENT_RATING;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Intensity // Intensity
@ -5689,7 +5689,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
else if (ride->intensity >= RIDE_RATING(10, 00)) else if (ride->intensity >= RIDE_RATING(10, 00))
stringId = STR_INTENSITY_RATING_RED; stringId = STR_INTENSITY_RATING_RED;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Nausea // Nausea
@ -5698,12 +5698,12 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
ft.Add<uint32_t>(ride->nausea); ft.Add<uint32_t>(ride->nausea);
ft.Add<StringId>(ratingName); ft.Add<StringId>(ratingName);
stringId = !RideHasRatings(*ride) ? STR_NAUSEA_RATING_NOT_YET_AVAILABLE : STR_NAUSEA_RATING; stringId = !RideHasRatings(*ride) ? STR_NAUSEA_RATING_NOT_YET_AVAILABLE : STR_NAUSEA_RATING;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += 2 * LIST_ROW_HEIGHT; screenCoords.y += 2 * LIST_ROW_HEIGHT;
// Horizontal rule // Horizontal rule
GfxFillRectInset( GfxFillRectInset(
dpi, { screenCoords - ScreenCoordsXY{ 0, 6 }, screenCoords + ScreenCoordsXY{ 303, -5 } }, w->colours[1], &dpi, { screenCoords - ScreenCoordsXY{ 0, 6 }, screenCoords + ScreenCoordsXY{ 303, -5 } }, w->colours[1],
INSET_RECT_FLAG_BORDER_INSET); INSET_RECT_FLAG_BORDER_INSET);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_NO_RAW_STATS)) if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_NO_RAW_STATS))
@ -5713,7 +5713,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
// Holes // Holes
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>(ride->holes); ft.Add<uint16_t>(ride->holes);
DrawTextBasic(*dpi, screenCoords, STR_HOLES, ft); DrawTextBasic(dpi, screenCoords, STR_HOLES, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
else else
@ -5721,13 +5721,13 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
// Max speed // Max speed
ft = Formatter(); ft = Formatter();
ft.Add<int32_t>((ride->max_speed * 9) >> 18); ft.Add<int32_t>((ride->max_speed * 9) >> 18);
DrawTextBasic(*dpi, screenCoords, STR_MAX_SPEED, ft); DrawTextBasic(dpi, screenCoords, STR_MAX_SPEED, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Average speed // Average speed
ft = Formatter(); ft = Formatter();
ft.Add<int32_t>((ride->average_speed * 9) >> 18); ft.Add<int32_t>((ride->average_speed * 9) >> 18);
DrawTextBasic(*dpi, screenCoords, STR_AVERAGE_SPEED, ft); DrawTextBasic(dpi, screenCoords, STR_AVERAGE_SPEED, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Ride time // Ride time
@ -5764,7 +5764,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
DrawTextEllipsised(*dpi, screenCoords, 308, STR_RIDE_TIME, ft); DrawTextEllipsised(dpi, screenCoords, 308, STR_RIDE_TIME, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -5803,7 +5803,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
ft.Add<uint16_t>(0); ft.Add<uint16_t>(0);
DrawTextEllipsised(*dpi, screenCoords, 308, STR_RIDE_LENGTH, ft); DrawTextEllipsised(dpi, screenCoords, 308, STR_RIDE_LENGTH, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
@ -5814,7 +5814,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<fixed16_2dp>(ride->max_positive_vertical_g); ft.Add<fixed16_2dp>(ride->max_positive_vertical_g);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Max. negative vertical G's // Max. negative vertical G's
@ -5822,20 +5822,20 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
: STR_MAX_NEGATIVE_VERTICAL_G; : STR_MAX_NEGATIVE_VERTICAL_G;
ft = Formatter(); ft = Formatter();
ft.Add<int32_t>(ride->max_negative_vertical_g); ft.Add<int32_t>(ride->max_negative_vertical_g);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Max lateral G's // Max lateral G's
stringId = ride->max_lateral_g > RIDE_G_FORCES_RED_LATERAL ? STR_MAX_LATERAL_G_RED : STR_MAX_LATERAL_G; stringId = ride->max_lateral_g > RIDE_G_FORCES_RED_LATERAL ? STR_MAX_LATERAL_G_RED : STR_MAX_LATERAL_G;
ft = Formatter(); ft = Formatter();
ft.Add<fixed16_2dp>(ride->max_lateral_g); ft.Add<fixed16_2dp>(ride->max_lateral_g);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Total 'air' time // Total 'air' time
ft = Formatter(); ft = Formatter();
ft.Add<fixed32_2dp>(ride->total_air_time * 3); ft.Add<fixed32_2dp>(ride->total_air_time * 3);
DrawTextBasic(*dpi, screenCoords, STR_TOTAL_AIR_TIME, ft); DrawTextBasic(dpi, screenCoords, STR_TOTAL_AIR_TIME, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -5845,14 +5845,14 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
auto drops = ride->drops & 0x3F; auto drops = ride->drops & 0x3F;
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>(drops); ft.Add<uint16_t>(drops);
DrawTextBasic(*dpi, screenCoords, STR_DROPS, ft); DrawTextBasic(dpi, screenCoords, STR_DROPS, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Highest drop height // Highest drop height
auto highestDropHeight = (ride->highest_drop_height * 3) / 4; auto highestDropHeight = (ride->highest_drop_height * 3) / 4;
ft = Formatter(); ft = Formatter();
ft.Add<int32_t>(highestDropHeight); ft.Add<int32_t>(highestDropHeight);
DrawTextBasic(*dpi, screenCoords, STR_HIGHEST_DROP_HEIGHT, ft); DrawTextBasic(dpi, screenCoords, STR_HIGHEST_DROP_HEIGHT, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -5863,7 +5863,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
ft = Formatter(); ft = Formatter();
ft.Add<uint16_t>(ride->inversions); ft.Add<uint16_t>(ride->inversions);
DrawTextBasic(*dpi, screenCoords, STR_INVERSIONS, ft); DrawTextBasic(dpi, screenCoords, STR_INVERSIONS, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
} }
@ -5871,7 +5871,7 @@ static void WindowRideMeasurementsPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
else else
{ {
DrawTextBasic(*dpi, screenCoords, STR_NO_TEST_RESULTS_YET); DrawTextBasic(dpi, screenCoords, STR_NO_TEST_RESULTS_YET);
} }
} }
} }
@ -6126,7 +6126,7 @@ static void WindowRideGraphsInvalidate(WindowBase* w)
* *
* rct2: 0x006AE4BC * rct2: 0x006AE4BC
*/ */
static void WindowRideGraphsPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideGraphsPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
WindowDrawWidgets(*w, dpi); WindowDrawWidgets(*w, dpi);
WindowRideDrawTabImages(dpi, w); WindowRideDrawTabImages(dpi, w);
@ -6136,9 +6136,9 @@ static void WindowRideGraphsPaint(WindowBase* w, DrawPixelInfo* dpi)
* *
* rct2: 0x006AE4C7 * rct2: 0x006AE4C7
*/ */
static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
GfxClear(dpi, ColourMapA[COLOUR_SATURATED_GREEN].darker); GfxClear(&dpi, ColourMapA[COLOUR_SATURATED_GREEN].darker);
auto widget = &window_ride_graphs_widgets[WIDX_GRAPH]; auto widget = &window_ride_graphs_widgets[WIDX_GRAPH];
auto ride = GetRide(w->rideId); auto ride = GetRide(w->rideId);
@ -6154,7 +6154,7 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
// No measurement message // No measurement message
ScreenCoordsXY stringCoords(widget->width() / 2, widget->height() / 2 - 5); ScreenCoordsXY stringCoords(widget->width() / 2, widget->height() / 2 - 5);
int32_t width = widget->width() - 2; int32_t width = widget->width() - 2;
DrawTextWrapped(*dpi, stringCoords, width, message.str, message.args, { TextAlignment::CENTRE }); DrawTextWrapped(dpi, stringCoords, width, message.str, message.args, { TextAlignment::CENTRE });
return; return;
} }
@ -6163,17 +6163,17 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
const uint8_t darkColour = ColourMapA[COLOUR_SATURATED_GREEN].mid_dark; const uint8_t darkColour = ColourMapA[COLOUR_SATURATED_GREEN].mid_dark;
int32_t time = 0; int32_t time = 0;
for (int32_t x = 0; x < dpi->x + dpi->width; x += 80) for (int32_t x = 0; x < dpi.x + dpi.width; x += 80)
{ {
if (x + 80 >= dpi->x) if (x + 80 >= dpi.x)
{ {
auto coord1 = ScreenCoordsXY{ x, dpi->y }; auto coord1 = ScreenCoordsXY{ x, dpi.y };
auto coord2 = ScreenCoordsXY{ x, dpi->y + dpi->height - 1 }; auto coord2 = ScreenCoordsXY{ x, dpi.y + dpi.height - 1 };
GfxFillRect(dpi, { coord1, coord2 }, lightColour); GfxFillRect(&dpi, { coord1, coord2 }, lightColour);
GfxFillRect(dpi, { coord1 + ScreenCoordsXY{ 16, 0 }, coord2 + ScreenCoordsXY{ 16, 0 } }, darkColour); GfxFillRect(&dpi, { coord1 + ScreenCoordsXY{ 16, 0 }, coord2 + ScreenCoordsXY{ 16, 0 } }, darkColour);
GfxFillRect(dpi, { coord1 + ScreenCoordsXY{ 32, 0 }, coord2 + ScreenCoordsXY{ 32, 0 } }, darkColour); GfxFillRect(&dpi, { coord1 + ScreenCoordsXY{ 32, 0 }, coord2 + ScreenCoordsXY{ 32, 0 } }, darkColour);
GfxFillRect(dpi, { coord1 + ScreenCoordsXY{ 48, 0 }, coord2 + ScreenCoordsXY{ 48, 0 } }, darkColour); GfxFillRect(&dpi, { coord1 + ScreenCoordsXY{ 48, 0 }, coord2 + ScreenCoordsXY{ 48, 0 } }, darkColour);
GfxFillRect(dpi, { coord1 + ScreenCoordsXY{ 64, 0 }, coord2 + ScreenCoordsXY{ 64, 0 } }, darkColour); GfxFillRect(&dpi, { coord1 + ScreenCoordsXY{ 64, 0 }, coord2 + ScreenCoordsXY{ 64, 0 } }, darkColour);
} }
time += 5; time += 5;
} }
@ -6195,7 +6195,7 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
{ {
// Minor / major line // Minor / major line
int32_t colour = yUnit == 0 ? lightColour : darkColour; int32_t colour = yUnit == 0 ? lightColour : darkColour;
GfxFillRect(dpi, { { dpi->x, y }, { dpi->x + dpi->width - 1, y } }, colour); GfxFillRect(&dpi, { { dpi.x, y }, { dpi.x + dpi.width - 1, y } }, colour);
int16_t scaled_yUnit = yUnit; int16_t scaled_yUnit = yUnit;
// Scale modifier // Scale modifier
@ -6205,27 +6205,27 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int16_t>(scaled_yUnit); ft.Add<int16_t>(scaled_yUnit);
DrawTextBasic(*dpi, { w->scrolls[0].h_left + 1, y - 4 }, stringID, ft, { FontStyle::Small }); DrawTextBasic(dpi, { w->scrolls[0].h_left + 1, y - 4 }, stringID, ft, { FontStyle::Small });
} }
// Time marks // Time marks
time = 0; time = 0;
for (int32_t x = 0; x < dpi->x + dpi->width; x += 80) for (int32_t x = 0; x < dpi.x + dpi.width; x += 80)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int32_t>(time); ft.Add<int32_t>(time);
if (x + 80 >= dpi->x) if (x + 80 >= dpi.x)
DrawTextBasic(*dpi, { x + 2, 1 }, STR_RIDE_STATS_TIME, ft, { FontStyle::Small }); DrawTextBasic(dpi, { x + 2, 1 }, STR_RIDE_STATS_TIME, ft, { FontStyle::Small });
time += 5; time += 5;
} }
// Plot // Plot
int32_t x = dpi->x; int32_t x = dpi.x;
int32_t firstPoint, secondPoint; int32_t firstPoint, secondPoint;
// Uses the force limits (used to draw extreme G's in red on measurement tab) to determine if line should be drawn red. // Uses the force limits (used to draw extreme G's in red on measurement tab) to determine if line should be drawn red.
int32_t intensityThresholdPositive = 0; int32_t intensityThresholdPositive = 0;
int32_t intensityThresholdNegative = 0; int32_t intensityThresholdNegative = 0;
for (int32_t width = 0; width < dpi->width; width++, x++) for (int32_t width = 0; width < dpi.width; width++, x++)
{ {
if (x < 0 || x >= measurement->num_items - 1) if (x < 0 || x >= measurement->num_items - 1)
continue; continue;
@ -6278,7 +6278,7 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
const bool previousMeasurement = x > measurement->current_item; const bool previousMeasurement = x > measurement->current_item;
// Draw the current line in grey. // Draw the current line in grey.
GfxFillRect(dpi, { { x, firstPoint }, { x, secondPoint } }, previousMeasurement ? PALETTE_INDEX_17 : PALETTE_INDEX_21); GfxFillRect(&dpi, { { x, firstPoint }, { x, secondPoint } }, previousMeasurement ? PALETTE_INDEX_17 : PALETTE_INDEX_21);
// Draw red over extreme values (if supported by graph type). // Draw red over extreme values (if supported by graph type).
if (listType == GRAPH_VERTICAL || listType == GRAPH_LATERAL) if (listType == GRAPH_VERTICAL || listType == GRAPH_LATERAL)
@ -6290,7 +6290,7 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
{ {
const auto redLineTop = ScreenCoordsXY{ x, std::max(firstPoint, intensityThresholdNegative) }; const auto redLineTop = ScreenCoordsXY{ x, std::max(firstPoint, intensityThresholdNegative) };
const auto redLineBottom = ScreenCoordsXY{ x, std::max(secondPoint, intensityThresholdNegative) }; const auto redLineBottom = ScreenCoordsXY{ x, std::max(secondPoint, intensityThresholdNegative) };
GfxFillRect(dpi, { redLineTop, redLineBottom }, redLineColour); GfxFillRect(&dpi, { redLineTop, redLineBottom }, redLineColour);
} }
// Line exceeds positive threshold (at top of graph). // Line exceeds positive threshold (at top of graph).
@ -6298,7 +6298,7 @@ static void WindowRideGraphsScrollpaint(WindowBase* w, DrawPixelInfo* dpi, int32
{ {
const auto redLineTop = ScreenCoordsXY{ x, std::min(firstPoint, intensityThresholdPositive) }; const auto redLineTop = ScreenCoordsXY{ x, std::min(firstPoint, intensityThresholdPositive) };
const auto redLineBottom = ScreenCoordsXY{ x, std::min(secondPoint, intensityThresholdPositive) }; const auto redLineBottom = ScreenCoordsXY{ x, std::min(secondPoint, intensityThresholdPositive) };
GfxFillRect(dpi, { redLineTop, redLineBottom }, redLineColour); GfxFillRect(&dpi, { redLineTop, redLineBottom }, redLineColour);
} }
} }
} }
@ -6742,7 +6742,7 @@ static void WindowRideIncomeInvalidate(WindowBase* w)
* *
* rct2: 0x006ADCE5 * rct2: 0x006ADCE5
*/ */
static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
StringId stringId; StringId stringId;
money64 profit; money64 profit;
@ -6780,7 +6780,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(profit); ft.Add<money64>(profit);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
} }
screenCoords.y += 44; screenCoords.y += 44;
@ -6804,7 +6804,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(profit); ft.Add<money64>(profit);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
} }
screenCoords.y += 18; screenCoords.y += 18;
@ -6814,7 +6814,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(ride->income_per_hour); ft.Add<money64>(ride->income_per_hour);
DrawTextBasic(*dpi, screenCoords, STR_INCOME_PER_HOUR, ft); DrawTextBasic(dpi, screenCoords, STR_INCOME_PER_HOUR, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -6823,7 +6823,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
stringId = ride->upkeep_cost == MONEY64_UNDEFINED ? STR_RUNNING_COST_UNKNOWN : STR_RUNNING_COST_PER_HOUR; stringId = ride->upkeep_cost == MONEY64_UNDEFINED ? STR_RUNNING_COST_UNKNOWN : STR_RUNNING_COST_PER_HOUR;
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(costPerHour); ft.Add<money64>(costPerHour);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Profit per hour // Profit per hour
@ -6831,7 +6831,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
ft = Formatter(); ft = Formatter();
ft.Add<money64>(ride->profit); ft.Add<money64>(ride->profit);
DrawTextBasic(*dpi, screenCoords, STR_PROFIT_PER_HOUR, ft); DrawTextBasic(dpi, screenCoords, STR_PROFIT_PER_HOUR, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
screenCoords.y += 5; screenCoords.y += 5;
@ -6839,7 +6839,7 @@ static void WindowRideIncomePaint(WindowBase* w, DrawPixelInfo* dpi)
// Total profit // Total profit
ft = Formatter(); ft = Formatter();
ft.Add<money64>(ride->total_profit); ft.Add<money64>(ride->total_profit);
DrawTextBasic(*dpi, screenCoords, STR_TOTAL_PROFIT, ft); DrawTextBasic(dpi, screenCoords, STR_TOTAL_PROFIT, ft);
} }
#pragma endregion #pragma endregion
@ -6969,7 +6969,7 @@ static void WindowRideCustomerInvalidate(WindowBase* w)
* *
* rct2: 0x006AD6CD * rct2: 0x006AD6CD
*/ */
static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi) static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo& dpi)
{ {
ShopItem shopItem; ShopItem shopItem;
int16_t popularity, satisfaction, queueTime; int16_t popularity, satisfaction, queueTime;
@ -6991,14 +6991,14 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int16_t>(ride->num_riders); ft.Add<int16_t>(ride->num_riders);
DrawTextBasic(*dpi, screenCoords, STR_CUSTOMERS_ON_RIDE, ft); DrawTextBasic(dpi, screenCoords, STR_CUSTOMERS_ON_RIDE, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
// Customers per hour // Customers per hour
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int32_t>(RideCustomersPerHour(*ride)); ft.Add<int32_t>(RideCustomersPerHour(*ride));
DrawTextBasic(*dpi, screenCoords, STR_CUSTOMERS_PER_HOUR, ft); DrawTextBasic(dpi, screenCoords, STR_CUSTOMERS_PER_HOUR, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Popularity // Popularity
@ -7014,7 +7014,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(popularity); ft.Add<int16_t>(popularity);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Satisfaction // Satisfaction
@ -7030,7 +7030,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
} }
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(satisfaction); ft.Add<int16_t>(satisfaction);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Queue time // Queue time
@ -7040,7 +7040,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
stringId = queueTime == 1 ? STR_QUEUE_TIME_MINUTE : STR_QUEUE_TIME_MINUTES; stringId = queueTime == 1 ? STR_QUEUE_TIME_MINUTE : STR_QUEUE_TIME_MINUTES;
ft = Formatter(); ft = Formatter();
ft.Add<int32_t>(queueTime); ft.Add<int32_t>(queueTime);
screenCoords.y += DrawTextWrapped(*dpi, screenCoords, 308, stringId, ft, { TextAlignment::LEFT }); screenCoords.y += DrawTextWrapped(dpi, screenCoords, 308, stringId, ft, { TextAlignment::LEFT });
screenCoords.y += 5; screenCoords.y += 5;
} }
@ -7051,7 +7051,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(GetShopItemDescriptor(shopItem).Naming.Plural); ft.Add<StringId>(GetShopItemDescriptor(shopItem).Naming.Plural);
ft.Add<uint32_t>(ride->no_primary_items_sold); ft.Add<uint32_t>(ride->no_primary_items_sold);
DrawTextBasic(*dpi, screenCoords, STR_ITEMS_SOLD, ft); DrawTextBasic(dpi, screenCoords, STR_ITEMS_SOLD, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
@ -7063,14 +7063,14 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<StringId>(GetShopItemDescriptor(shopItem).Naming.Plural); ft.Add<StringId>(GetShopItemDescriptor(shopItem).Naming.Plural);
ft.Add<uint32_t>(ride->no_secondary_items_sold); ft.Add<uint32_t>(ride->no_secondary_items_sold);
DrawTextBasic(*dpi, screenCoords, STR_ITEMS_SOLD, ft); DrawTextBasic(dpi, screenCoords, STR_ITEMS_SOLD, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
// Total customers // Total customers
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(ride->total_customers); ft.Add<uint32_t>(ride->total_customers);
DrawTextBasic(*dpi, screenCoords, STR_TOTAL_CUSTOMERS, ft); DrawTextBasic(dpi, screenCoords, STR_TOTAL_CUSTOMERS, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
// Guests favourite // Guests favourite
@ -7079,7 +7079,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(ride->guests_favourite); ft.Add<uint32_t>(ride->guests_favourite);
stringId = ride->guests_favourite == 1 ? STR_FAVOURITE_RIDE_OF_GUEST : STR_FAVOURITE_RIDE_OF_GUESTS; stringId = ride->guests_favourite == 1 ? STR_FAVOURITE_RIDE_OF_GUEST : STR_FAVOURITE_RIDE_OF_GUESTS;
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
screenCoords.y += 2; screenCoords.y += 2;
@ -7090,7 +7090,7 @@ static void WindowRideCustomerPaint(WindowBase* w, DrawPixelInfo* dpi)
stringId = age == 0 ? STR_BUILT_THIS_YEAR : age == 1 ? STR_BUILT_LAST_YEAR : STR_BUILT_YEARS_AGO; stringId = age == 0 ? STR_BUILT_THIS_YEAR : age == 1 ? STR_BUILT_LAST_YEAR : STR_BUILT_YEARS_AGO;
ft = Formatter(); ft = Formatter();
ft.Add<int16_t>(age); ft.Add<int16_t>(age);
DrawTextBasic(*dpi, screenCoords, stringId, ft); DrawTextBasic(dpi, screenCoords, stringId, ft);
} }
#pragma endregion #pragma endregion

12
src/openrct2-ui/windows/RideConstruction.cpp
View File

@ -1519,7 +1519,7 @@ public:
widgetHeight = widget->height() - 1; widgetHeight = widget->height() - 1;
if (ClipDrawPixelInfo(&clipdpi, &dpi, screenCoords, widgetWidth, widgetHeight)) if (ClipDrawPixelInfo(&clipdpi, &dpi, screenCoords, widgetWidth, widgetHeight))
{ {
DrawTrackPiece(&clipdpi, rideIndex, trackType, trackDirection, liftHillAndInvertedState, widgetWidth, widgetHeight); DrawTrackPiece(clipdpi, rideIndex, trackType, trackDirection, liftHillAndInvertedState, widgetWidth, widgetHeight);
} }
// Draw cost // Draw cost
@ -2624,7 +2624,7 @@ private:
} }
void DrawTrackPiece( void DrawTrackPiece(
DrawPixelInfo* dpi, RideId rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndInvertedState, DrawPixelInfo& dpi, RideId rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndInvertedState,
int32_t widgetWidth, int32_t widgetHeight) int32_t widgetWidth, int32_t widgetHeight)
{ {
auto currentRide = GetRide(rideIndex); auto currentRide = GetRide(rideIndex);
@ -2656,20 +2656,20 @@ private:
const ScreenCoordsXY rotatedScreenCoords = Translate3DTo2DWithZ(GetCurrentRotation(), mapCoords); const ScreenCoordsXY rotatedScreenCoords = Translate3DTo2DWithZ(GetCurrentRotation(), mapCoords);
dpi->x += rotatedScreenCoords.x - widgetWidth / 2; dpi.x += rotatedScreenCoords.x - widgetWidth / 2;
dpi->y += rotatedScreenCoords.y - widgetHeight / 2 - 16; dpi.y += rotatedScreenCoords.y - widgetHeight / 2 - 16;
DrawTrackPieceHelper(dpi, rideIndex, trackType, trackDirection, liftHillAndInvertedState, { 4096, 4096 }, 1024); DrawTrackPieceHelper(dpi, rideIndex, trackType, trackDirection, liftHillAndInvertedState, { 4096, 4096 }, 1024);
} }
void DrawTrackPieceHelper( void DrawTrackPieceHelper(
DrawPixelInfo* dpi, RideId rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndInvertedState, DrawPixelInfo& dpi, RideId rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndInvertedState,
const CoordsXY& originCoords, int32_t originZ) const CoordsXY& originCoords, int32_t originZ)
{ {
TileElement tempSideTrackTileElement{ 0x80, 0x8F, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; TileElement tempSideTrackTileElement{ 0x80, 0x8F, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
TileElement tempTrackTileElement{}; TileElement tempTrackTileElement{};
TileElement* backupTileElementArrays[5]{}; TileElement* backupTileElementArrays[5]{};
PaintSession* session = PaintSessionAlloc(dpi, 0); PaintSession* session = PaintSessionAlloc(&dpi, 0);
trackDirection &= 3; trackDirection &= 3;
auto currentRide = GetRide(rideIndex); auto currentRide = GetRide(rideIndex);

12
src/openrct2-ui/windows/RideList.cpp
View File

@ -509,8 +509,8 @@ public:
*/ */
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
DrawTabImages(&dpi); DrawTabImages(dpi);
// Draw number of attractions on bottom // Draw number of attractions on bottom
auto ft = Formatter(); auto ft = Formatter();
@ -739,7 +739,7 @@ private:
* *
* rct2: 0x006B38EA * rct2: 0x006B38EA
*/ */
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
int32_t sprite_idx; int32_t sprite_idx;
@ -748,21 +748,21 @@ private:
if (page == PAGE_RIDES) if (page == PAGE_RIDES)
sprite_idx += frame_no / 4; sprite_idx += frame_no / 4;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_1].left, widgets[WIDX_TAB_1].top }); dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_1].left, widgets[WIDX_TAB_1].top });
// Shops and stalls tab // Shops and stalls tab
sprite_idx = SPR_TAB_SHOPS_AND_STALLS_0; sprite_idx = SPR_TAB_SHOPS_AND_STALLS_0;
if (page == PAGE_SHOPS_AND_STALLS) if (page == PAGE_SHOPS_AND_STALLS)
sprite_idx += frame_no / 4; sprite_idx += frame_no / 4;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_2].left, widgets[WIDX_TAB_2].top }); dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_2].left, widgets[WIDX_TAB_2].top });
// Information kiosks and facilities tab // Information kiosks and facilities tab
sprite_idx = SPR_TAB_KIOSKS_AND_FACILITIES_0; sprite_idx = SPR_TAB_KIOSKS_AND_FACILITIES_0;
if (page == PAGE_KIOSKS_AND_FACILITIES) if (page == PAGE_KIOSKS_AND_FACILITIES)
sprite_idx += (frame_no / 4) % 8; sprite_idx += (frame_no / 4) % 8;
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_3].left, widgets[WIDX_TAB_3].top }); dpi, ImageId(sprite_idx), windowPos + ScreenCoordsXY{ widgets[WIDX_TAB_3].left, widgets[WIDX_TAB_3].top });
} }
/** /**

2
src/openrct2-ui/windows/SceneryScatter.cpp
View File

@ -178,7 +178,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
// Draw area as a number for tool sizes bigger than 7 // Draw area as a number for tool sizes bigger than 7
if (gWindowSceneryScatterSize > MAX_TOOL_SIZE_WITH_SPRITE) if (gWindowSceneryScatterSize > MAX_TOOL_SIZE_WITH_SPRITE)

2
src/openrct2-ui/windows/Sign.cpp
View File

@ -293,7 +293,7 @@ public:
if (viewport != nullptr) if (viewport != nullptr)
{ {
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
} }
} }

42
src/openrct2-ui/windows/Staff.cpp
View File

@ -206,15 +206,15 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
DrawWidgets(dpi); DrawWidgets(dpi);
DrawTabImages(&dpi); DrawTabImages(dpi);
switch (page) switch (page)
{ {
case WINDOW_STAFF_OVERVIEW: case WINDOW_STAFF_OVERVIEW:
OverviewDraw(&dpi); OverviewDraw(dpi);
break; break;
case WINDOW_STAFF_STATISTICS: case WINDOW_STAFF_STATISTICS:
StatsDraw(&dpi); StatsDraw(dpi);
break; break;
} }
} }
@ -513,7 +513,7 @@ private:
widgets[WIDX_FIRE].right = width - 2; widgets[WIDX_FIRE].right = width - 2;
} }
void OverviewDraw(DrawPixelInfo* dpi) void OverviewDraw(DrawPixelInfo& dpi)
{ {
// Draw the viewport no sound sprite // Draw the viewport no sound sprite
if (viewport != nullptr) if (viewport != nullptr)
@ -522,7 +522,7 @@ private:
if (viewport->flags & VIEWPORT_FLAG_SOUND_ON) if (viewport->flags & VIEWPORT_FLAG_SOUND_ON)
{ {
GfxDrawSprite(*dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 }); GfxDrawSprite(dpi, ImageId(SPR_HEARING_VIEWPORT), windowPos + ScreenCoordsXY{ 2, 2 });
} }
} }
@ -537,10 +537,10 @@ private:
const auto& widget = widgets[WIDX_BTM_LABEL]; const auto& widget = widgets[WIDX_BTM_LABEL];
auto screenPos = windowPos + ScreenCoordsXY{ widget.midX(), widget.top }; auto screenPos = windowPos + ScreenCoordsXY{ widget.midX(), widget.top };
int32_t widgetWidth = widget.width(); int32_t widgetWidth = widget.width();
DrawTextEllipsised(*dpi, screenPos, widgetWidth, STR_BLACK_STRING, ft, { TextAlignment::CENTRE }); DrawTextEllipsised(dpi, screenPos, widgetWidth, STR_BLACK_STRING, ft, { TextAlignment::CENTRE });
} }
void DrawOverviewTabImage(DrawPixelInfo* dpi) void DrawOverviewTabImage(DrawPixelInfo& dpi)
{ {
if (IsWidgetDisabled(WIDX_TAB_1)) if (IsWidgetDisabled(WIDX_TAB_1))
return; return;
@ -553,7 +553,7 @@ private:
widgetHeight++; widgetHeight++;
DrawPixelInfo clip_dpi; DrawPixelInfo clip_dpi;
if (!ClipDrawPixelInfo(&clip_dpi, dpi, screenCoords, widgetWidth, widgetHeight)) if (!ClipDrawPixelInfo(&clip_dpi, &dpi, screenCoords, widgetWidth, widgetHeight))
{ {
return; return;
} }
@ -914,7 +914,7 @@ private:
#pragma endregion #pragma endregion
#pragma region Statistics tab events #pragma region Statistics tab events
void StatsDraw(DrawPixelInfo* dpi) void StatsDraw(DrawPixelInfo& dpi)
{ {
auto staff = GetStaff(); auto staff = GetStaff();
if (staff == nullptr) if (staff == nullptr)
@ -928,13 +928,13 @@ private:
{ {
auto ft = Formatter(); auto ft = Formatter();
ft.Add<money64>(GetStaffWage(staff->AssignedStaffType)); ft.Add<money64>(GetStaffWage(staff->AssignedStaffType));
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_WAGES, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_WAGES, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
} }
auto ft = Formatter(); auto ft = Formatter();
ft.Add<int32_t>(staff->GetHireDate()); ft.Add<int32_t>(staff->GetHireDate());
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_EMPLOYED_FOR, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_EMPLOYED_FOR, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
switch (staff->AssignedStaffType) switch (staff->AssignedStaffType)
@ -942,37 +942,37 @@ private:
case StaffType::Handyman: case StaffType::Handyman:
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffLawnsMown); ft.Add<uint32_t>(staff->StaffLawnsMown);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_LAWNS_MOWN, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_LAWNS_MOWN, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffGardensWatered); ft.Add<uint32_t>(staff->StaffGardensWatered);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_GARDENS_WATERED, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_GARDENS_WATERED, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffLitterSwept); ft.Add<uint32_t>(staff->StaffLitterSwept);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_LITTER_SWEPT, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_LITTER_SWEPT, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffBinsEmptied); ft.Add<uint32_t>(staff->StaffBinsEmptied);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_BINS_EMPTIED, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_BINS_EMPTIED, ft);
break; break;
case StaffType::Mechanic: case StaffType::Mechanic:
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffRidesInspected); ft.Add<uint32_t>(staff->StaffRidesInspected);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_RIDES_INSPECTED, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_RIDES_INSPECTED, ft);
screenCoords.y += LIST_ROW_HEIGHT; screenCoords.y += LIST_ROW_HEIGHT;
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffRidesFixed); ft.Add<uint32_t>(staff->StaffRidesFixed);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_RIDES_FIXED, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_RIDES_FIXED, ft);
break; break;
case StaffType::Security: case StaffType::Security:
ft = Formatter(); ft = Formatter();
ft.Add<uint32_t>(staff->StaffVandalsStopped); ft.Add<uint32_t>(staff->StaffVandalsStopped);
DrawTextBasic(*dpi, screenCoords, STR_STAFF_STAT_VANDALS_STOPPED, ft); DrawTextBasic(dpi, screenCoords, STR_STAFF_STAT_VANDALS_STOPPED, ft);
break; break;
case StaffType::Entertainer: case StaffType::Entertainer:
case StaffType::Count: case StaffType::Count:
@ -1192,14 +1192,14 @@ private:
WindowFollowSprite(*main, EntityId::FromUnderlying(number)); WindowFollowSprite(*main, EntityId::FromUnderlying(number));
} }
void DrawTabImages(DrawPixelInfo* dpi) void DrawTabImages(DrawPixelInfo& dpi)
{ {
DrawOverviewTabImage(dpi); DrawOverviewTabImage(dpi);
DrawTabImage(dpi, WINDOW_STAFF_OPTIONS, SPR_TAB_STAFF_OPTIONS_0); DrawTabImage(dpi, WINDOW_STAFF_OPTIONS, SPR_TAB_STAFF_OPTIONS_0);
DrawTabImage(dpi, WINDOW_STAFF_STATISTICS, SPR_TAB_STATS_0); DrawTabImage(dpi, WINDOW_STAFF_STATISTICS, SPR_TAB_STATS_0);
} }
void DrawTabImage(DrawPixelInfo* dpi, int32_t p, int32_t baseImageId) void DrawTabImage(DrawPixelInfo& dpi, int32_t p, int32_t baseImageId)
{ {
WidgetIndex widgetIndex = WIDX_TAB_1 + p; WidgetIndex widgetIndex = WIDX_TAB_1 + p;
Widget* widget = &widgets[widgetIndex]; Widget* widget = &widgets[widgetIndex];
@ -1215,7 +1215,7 @@ private:
} }
// Draw normal, enabled sprite. // Draw normal, enabled sprite.
GfxDrawSprite(*dpi, ImageId(baseImageId), screenCoords); GfxDrawSprite(dpi, ImageId(baseImageId), screenCoords);
} }
} }

8
src/openrct2-ui/windows/Themes.cpp
View File

@ -447,8 +447,8 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
// Widgets // Widgets
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
WindowThemesDrawTabImages(&dpi); WindowThemesDrawTabImages(dpi);
if (_selected_tab == WINDOW_THEMES_TAB_SETTINGS) if (_selected_tab == WINDOW_THEMES_TAB_SETTINGS)
{ {
@ -868,7 +868,7 @@ public:
return 0; return 0;
} }
void WindowThemesDrawTabImages(DrawPixelInfo* dpi) void WindowThemesDrawTabImages(DrawPixelInfo& dpi)
{ {
for (int32_t i = 0; i < WINDOW_THEMES_TAB_COUNT; i++) for (int32_t i = 0; i < WINDOW_THEMES_TAB_COUNT; i++)
{ {
@ -876,7 +876,7 @@ public:
if (_selected_tab == i) if (_selected_tab == i)
sprite_idx += frame_no / window_themes_tab_animation_divisor[_selected_tab]; sprite_idx += frame_no / window_themes_tab_animation_divisor[_selected_tab];
GfxDrawSprite( GfxDrawSprite(
*dpi, ImageId(sprite_idx), dpi, ImageId(sprite_idx),
windowPos windowPos
+ ScreenCoordsXY{ widgets[WIDX_THEMES_SETTINGS_TAB + i].left, widgets[WIDX_THEMES_SETTINGS_TAB + i].top }); + ScreenCoordsXY{ widgets[WIDX_THEMES_SETTINGS_TAB + i].left, widgets[WIDX_THEMES_SETTINGS_TAB + i].top });
} }

2
src/openrct2-ui/windows/TopToolbar.cpp
View File

@ -3180,7 +3180,7 @@ public:
{ {
int32_t imgId; int32_t imgId;
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
ScreenCoordsXY screenPos{}; ScreenCoordsXY screenPos{};
// Draw staff button image (setting masks to the staff colours) // Draw staff button image (setting masks to the staff colours)

2
src/openrct2-ui/windows/TrackDesignPlace.cpp
View File

@ -288,7 +288,7 @@ public:
{ {
auto ft = Formatter::Common(); auto ft = Formatter::Common();
ft.Add<char*>(_trackDesign->name.c_str()); ft.Add<char*>(_trackDesign->name.c_str());
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
// Draw mini tile preview // Draw mini tile preview
DrawPixelInfo clippedDpi; DrawPixelInfo clippedDpi;

2
src/openrct2-ui/windows/ViewClipping.cpp
View File

@ -274,7 +274,7 @@ public:
void OnDraw(DrawPixelInfo& dpi) override void OnDraw(DrawPixelInfo& dpi) override
{ {
WindowDrawWidgets(*this, &dpi); WindowDrawWidgets(*this, dpi);
// Clip height value // Clip height value
auto screenCoords = this->windowPos + ScreenCoordsXY{ 8, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; auto screenCoords = this->windowPos + ScreenCoordsXY{ 8, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top };

2
src/openrct2-ui/windows/Viewport.cpp
View File

@ -156,7 +156,7 @@ public:
// Draw viewport // Draw viewport
if (viewport != nullptr) if (viewport != nullptr)
WindowDrawViewport(&dpi, *this); WindowDrawViewport(dpi, *this);
} }
void OnResize() override void OnResize() override

4
src/openrct2-ui/windows/Window.h
View File

@ -120,8 +120,8 @@ WindowBase* WindowMapOpen();
void WindowMapReset(); void WindowMapReset();
WindowBase* WindowResearchOpen(); WindowBase* WindowResearchOpen();
void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo* dpi, WidgetIndex baseWidgetIndex); void WindowResearchDevelopmentPagePaint(WindowBase* w, DrawPixelInfo& dpi, WidgetIndex baseWidgetIndex);
void WindowResearchFundingPagePaint(WindowBase* w, DrawPixelInfo* dpi, WidgetIndex baseWidgetIndex); void WindowResearchFundingPagePaint(WindowBase* w, DrawPixelInfo& dpi, WidgetIndex baseWidgetIndex);
WindowBase* WindowNewRideOpen(); WindowBase* WindowNewRideOpen();
WindowBase* WindowNewRideOpenResearch(); WindowBase* WindowNewRideOpenResearch();

2
src/openrct2/drawing/X8DrawingEngine.cpp
View File

@ -437,7 +437,7 @@ void X8DrawingEngine::DrawDirtyBlocks(uint32_t x, uint32_t y, uint32_t columns,
// Draw region // Draw region
OnDrawDirtyBlock(x, y, columns, rows); OnDrawDirtyBlock(x, y, columns, rows);
WindowDrawAll(&_bitsDPI, left, top, right, bottom); WindowDrawAll(_bitsDPI, left, top, right, bottom);
} }
#ifdef __WARN_SUGGEST_FINAL_METHODS__ #ifdef __WARN_SUGGEST_FINAL_METHODS__

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

@ -370,14 +370,14 @@ static void ViewportRedrawAfterShift(DrawPixelInfo* dpi, WindowBase* window, Vie
{ {
// draw left // draw left
auto _right = viewport->pos.x + coords.x; auto _right = viewport->pos.x + coords.x;
WindowDrawAll(dpi, left, top, _right, bottom); WindowDrawAll(*dpi, left, top, _right, bottom);
left += coords.x; left += coords.x;
} }
else if (coords.x < 0) else if (coords.x < 0)
{ {
// draw right // draw right
auto _left = viewport->pos.x + viewport->width + coords.x; auto _left = viewport->pos.x + viewport->width + coords.x;
WindowDrawAll(dpi, _left, top, right, bottom); WindowDrawAll(*dpi, _left, top, right, bottom);
right += coords.x; right += coords.x;
} }
@ -385,19 +385,19 @@ static void ViewportRedrawAfterShift(DrawPixelInfo* dpi, WindowBase* window, Vie
{ {
// draw top // draw top
bottom = viewport->pos.y + coords.y; bottom = viewport->pos.y + coords.y;
WindowDrawAll(dpi, left, top, right, bottom); WindowDrawAll(*dpi, left, top, right, bottom);
} }
else if (coords.y < 0) else if (coords.y < 0)
{ {
// draw bottom // draw bottom
top = viewport->pos.y + viewport->height + coords.y; top = viewport->pos.y + viewport->height + coords.y;
WindowDrawAll(dpi, left, top, right, bottom); WindowDrawAll(*dpi, left, top, right, bottom);
} }
} }
else else
{ {
// redraw whole viewport // redraw whole viewport
WindowDrawAll(dpi, left, top, right, bottom); WindowDrawAll(*dpi, left, top, right, bottom);
} }
} }
} }
@ -443,7 +443,7 @@ static void ViewportShiftPixels(DrawPixelInfo* dpi, WindowBase* window, Viewport
if (top >= bottom) if (top >= bottom)
continue; continue;
WindowDrawAll(dpi, left, top, right, bottom); WindowDrawAll(*dpi, left, top, right, bottom);
} }
ViewportRedrawAfterShift(dpi, window, viewport, { x_diff, y_diff }); ViewportRedrawAfterShift(dpi, window, viewport, { x_diff, y_diff });
@ -480,7 +480,7 @@ static void ViewportMove(const ScreenCoordsXY& coords, WindowBase* w, Viewport*
if (DrawingEngineHasDirtyOptimisations()) if (DrawingEngineHasDirtyOptimisations())
{ {
DrawPixelInfo* dpi = DrawingEngineGetDpi(); DrawPixelInfo* dpi = DrawingEngineGetDpi();
WindowDrawAll(dpi, left, top, right, bottom); WindowDrawAll(*dpi, left, top, right, bottom);
return; return;
} }
} }

28
src/openrct2/interface/Window.cpp
View File

@ -84,7 +84,7 @@ namespace WindowCloseFlags
static constexpr uint32_t CloseSingle = (1 << 1); static constexpr uint32_t CloseSingle = (1 << 1);
} // namespace WindowCloseFlags } // namespace WindowCloseFlags
static void WindowDrawCore(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom); static void WindowDrawCore(DrawPixelInfo& dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom);
static void WindowDrawSingle(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom); static void WindowDrawSingle(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom);
std::list<std::shared_ptr<WindowBase>>::iterator WindowGetIterator(const WindowBase* w) std::list<std::shared_ptr<WindowBase>>::iterator WindowGetIterator(const WindowBase* w)
@ -1130,7 +1130,7 @@ void MainWindowZoom(bool zoomIn, bool atCursor)
* Splits a drawing of a window into regions that can be seen and are not hidden * Splits a drawing of a window into regions that can be seen and are not hidden
* by other opaque overlapping windows. * by other opaque overlapping windows.
*/ */
void WindowDraw(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom) void WindowDraw(DrawPixelInfo& dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom)
{ {
if (!WindowIsVisible(w)) if (!WindowIsVisible(w))
return; return;
@ -1185,7 +1185,7 @@ void WindowDraw(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, in
/** /**
* Draws the given window and any other overlapping transparent windows. * Draws the given window and any other overlapping transparent windows.
*/ */
static void WindowDrawCore(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom) static void WindowDrawCore(DrawPixelInfo& dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom)
{ {
// Clamp region // Clamp region
left = std::max<int32_t>(left, w.windowPos.x); left = std::max<int32_t>(left, w.windowPos.x);
@ -1203,7 +1203,7 @@ static void WindowDrawCore(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int3
auto* v = (*it).get(); auto* v = (*it).get();
if ((&w == v || (v->flags & WF_TRANSPARENT)) && WindowIsVisible(*v)) if ((&w == v || (v->flags & WF_TRANSPARENT)) && WindowIsVisible(*v))
{ {
WindowDrawSingle(dpi, *v, left, top, right, bottom); WindowDrawSingle(&dpi, *v, left, top, right, bottom);
} }
} }
} }
@ -1266,7 +1266,7 @@ static void WindowDrawSingle(DrawPixelInfo* dpi, WindowBase& w, int32_t left, in
gCurrentWindowColours[2] = NOT_TRANSLUCENT(w.colours[2]); gCurrentWindowColours[2] = NOT_TRANSLUCENT(w.colours[2]);
gCurrentWindowColours[3] = NOT_TRANSLUCENT(w.colours[3]); gCurrentWindowColours[3] = NOT_TRANSLUCENT(w.colours[3]);
WindowEventPaintCall(&w, dpi); WindowEventPaintCall(&w, *dpi);
} }
/** /**
@ -1276,9 +1276,9 @@ static void WindowDrawSingle(DrawPixelInfo* dpi, WindowBase& w, int32_t left, in
* @param dpi (edi) * @param dpi (edi)
* @param w (esi) * @param w (esi)
*/ */
void WindowDrawViewport(DrawPixelInfo* dpi, WindowBase& w) void WindowDrawViewport(DrawPixelInfo& dpi, WindowBase& w)
{ {
ViewportRender(dpi, w.viewport, { { dpi->x, dpi->y }, { dpi->x + dpi->width, dpi->y + dpi->height } }); ViewportRender(&dpi, w.viewport, { { dpi.x, dpi.y }, { dpi.x + dpi.width, dpi.y + dpi.height } });
} }
void WindowSetPosition(WindowBase& w, const ScreenCoordsXY& screenCoords) void WindowSetPosition(WindowBase& w, const ScreenCoordsXY& screenCoords)
@ -1647,18 +1647,18 @@ void WindowEventInvalidateCall(WindowBase* w)
w->event_handlers->invalidate(w); w->event_handlers->invalidate(w);
} }
void WindowEventPaintCall(WindowBase* w, DrawPixelInfo* dpi) void WindowEventPaintCall(WindowBase* w, DrawPixelInfo& dpi)
{ {
if (w->event_handlers == nullptr) if (w->event_handlers == nullptr)
w->OnDraw(*dpi); w->OnDraw(dpi);
else if (w->event_handlers->paint != nullptr) else if (w->event_handlers->paint != nullptr)
w->event_handlers->paint(w, dpi); w->event_handlers->paint(w, dpi);
} }
void WindowEventScrollPaintCall(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex) void WindowEventScrollPaintCall(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex)
{ {
if (w->event_handlers == nullptr) if (w->event_handlers == nullptr)
w->OnScrollDraw(scrollIndex, *dpi); w->OnScrollDraw(scrollIndex, dpi);
else if (w->event_handlers->scroll_paint != nullptr) else if (w->event_handlers->scroll_paint != nullptr)
w->event_handlers->scroll_paint(w, dpi, scrollIndex); w->event_handlers->scroll_paint(w, dpi, scrollIndex);
} }
@ -2089,9 +2089,9 @@ bool WindowIsVisible(WindowBase& w)
* right (dx) * right (dx)
* bottom (bp) * bottom (bp)
*/ */
void WindowDrawAll(DrawPixelInfo* dpi, int32_t left, int32_t top, int32_t right, int32_t bottom) void WindowDrawAll(DrawPixelInfo& dpi, int32_t left, int32_t top, int32_t right, int32_t bottom)
{ {
auto windowDPI = dpi->Crop({ left, top }, { right - left, bottom - top }); auto windowDPI = dpi.Crop({ left, top }, { right - left, bottom - top });
WindowVisitEach([&windowDPI, left, top, right, bottom](WindowBase* w) { WindowVisitEach([&windowDPI, left, top, right, bottom](WindowBase* w) {
if (w->flags & WF_TRANSPARENT) if (w->flags & WF_TRANSPARENT)
return; return;
@ -2099,7 +2099,7 @@ void WindowDrawAll(DrawPixelInfo* dpi, int32_t left, int32_t top, int32_t right,
return; return;
if (left >= w->windowPos.x + w->width || top >= w->windowPos.y + w->height) if (left >= w->windowPos.x + w->width || top >= w->windowPos.y + w->height)
return; return;
WindowDraw(&windowDPI, *w, left, top, right, bottom); WindowDraw(windowDPI, *w, left, top, right, bottom);
}); });
} }

16
src/openrct2/interface/Window.h
View File

@ -247,8 +247,8 @@ struct WindowEventList
void (*cursor)(struct WindowBase*, WidgetIndex, const ScreenCoordsXY&, CursorID*){}; void (*cursor)(struct WindowBase*, WidgetIndex, const ScreenCoordsXY&, CursorID*){};
void (*moved)(struct WindowBase*, const ScreenCoordsXY&){}; void (*moved)(struct WindowBase*, const ScreenCoordsXY&){};
void (*invalidate)(struct WindowBase*){}; void (*invalidate)(struct WindowBase*){};
void (*paint)(struct WindowBase*, DrawPixelInfo*){}; void (*paint)(struct WindowBase*, DrawPixelInfo&){};
void (*scroll_paint)(struct WindowBase*, DrawPixelInfo*, int32_t){}; void (*scroll_paint)(struct WindowBase*, DrawPixelInfo&, int32_t){};
typedef void (*fnEventInitializer)(WindowEventList&); typedef void (*fnEventInitializer)(WindowEventList&);
WindowEventList(fnEventInitializer fn) WindowEventList(fnEventInitializer fn)
@ -662,10 +662,10 @@ void WindowZoomIn(WindowBase& w, bool atCursor);
void WindowZoomOut(WindowBase& w, bool atCursor); void WindowZoomOut(WindowBase& w, bool atCursor);
void MainWindowZoom(bool zoomIn, bool atCursor); void MainWindowZoom(bool zoomIn, bool atCursor);
void WindowDrawAll(DrawPixelInfo* dpi, int32_t left, int32_t top, int32_t right, int32_t bottom); void WindowDrawAll(DrawPixelInfo& dpi, int32_t left, int32_t top, int32_t right, int32_t bottom);
void WindowDraw(DrawPixelInfo* dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom); void WindowDraw(DrawPixelInfo& dpi, WindowBase& w, int32_t left, int32_t top, int32_t right, int32_t bottom);
void WindowDrawWidgets(WindowBase& w, DrawPixelInfo* dpi); void WindowDrawWidgets(WindowBase& w, DrawPixelInfo& dpi);
void WindowDrawViewport(DrawPixelInfo* dpi, WindowBase& w); void WindowDrawViewport(DrawPixelInfo& dpi, WindowBase& w);
void WindowSetPosition(WindowBase& w, const ScreenCoordsXY& screenCoords); void WindowSetPosition(WindowBase& w, const ScreenCoordsXY& screenCoords);
void WindowMovePosition(WindowBase& w, const ScreenCoordsXY& screenCoords); void WindowMovePosition(WindowBase& w, const ScreenCoordsXY& screenCoords);
@ -713,8 +713,8 @@ OpenRCT2String WindowEventTooltipCall(WindowBase* w, const WidgetIndex widgetInd
CursorID WindowEventCursorCall(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords); CursorID WindowEventCursorCall(WindowBase* w, WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords);
void WindowEventMovedCall(WindowBase* w, const ScreenCoordsXY& screenCoords); void WindowEventMovedCall(WindowBase* w, const ScreenCoordsXY& screenCoords);
void WindowEventInvalidateCall(WindowBase* w); void WindowEventInvalidateCall(WindowBase* w);
void WindowEventPaintCall(WindowBase* w, DrawPixelInfo* dpi); void WindowEventPaintCall(WindowBase* w, DrawPixelInfo& dpi);
void WindowEventScrollPaintCall(WindowBase* w, DrawPixelInfo* dpi, int32_t scrollIndex); void WindowEventScrollPaintCall(WindowBase* w, DrawPixelInfo& dpi, int32_t scrollIndex);
void InvalidateAllWindowsAfterInput(); void InvalidateAllWindowsAfterInput();
void TextinputCancel(); void TextinputCancel();