From 419201f4767e517c40d94aa627a03c1f84425781 Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Tue, 28 Sep 2021 21:02:30 +0200 Subject: [PATCH 01/19] Work on refactoring ViewClipping.cpp to the new window framework. --- src/openrct2-ui/windows/ViewClipping.cpp | 350 ++++++++++++++++++++++- 1 file changed, 341 insertions(+), 9 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index e4c897d335..ef0d668230 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -65,17 +65,17 @@ static rct_widget window_view_clipping_widgets[] = { #pragma endregion #pragma region Members - +/* static CoordsXY _selectionStart; static CoordsXY _previousClipSelectionA; static CoordsXY _previousClipSelectionB; static bool _toolActive; static bool _dragging; - +*/ #pragma endregion #pragma region Events - +/* static void window_view_clipping_close_button(rct_window* w); static void window_view_clipping_mouseup(rct_window* w, rct_widgetindex widgetIndex); static void window_view_clipping_mousedown(rct_window*w, rct_widgetindex widgetIndex, rct_widget *widget); @@ -103,20 +103,327 @@ static rct_window_event_list window_view_clipping_events([](auto& events) events.invalidate = &window_view_clipping_invalidate; events.paint = &window_view_clipping_paint; }); +*/ // clang-format on #pragma endregion -static void window_view_clipping_set_clipheight(rct_window* w, const uint8_t clipheight) +class ViewClippingWindow final : public Window { - gClipHeight = clipheight; - rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; - const float clip_height_ratio = static_cast(gClipHeight) / 255; - w->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (w->scrolls[0].h_right - (widget->width() - 1)))); -} +private: + + CoordsXY _selectionStart; + CoordsXY _previousClipSelectionA; + CoordsXY _previousClipSelectionB; + bool _toolActive; + bool _dragging; +public: + void OnCloseButton() + { + OnClose(); + } + + void OnMouseUp(rct_widgetindex widgetIndex) override + { + rct_window* mainWindow; + + // mouseup appears to be used for buttons, checkboxes + switch (widgetIndex) + { + case WIDX_CLOSE: + window_close(this); // Unsure about this. ~hjort96 + break; + case WIDX_CLIP_CHECKBOX_ENABLE: + // Toggle height clipping. + mainWindow = window_get_main(); + if (mainWindow != nullptr) + { + mainWindow->viewport->flags ^= VIEWPORT_FLAG_CLIP_VIEW; + mainWindow->Invalidate(); + } + this->Invalidate(); + break; + case WIDX_CLIP_HEIGHT_VALUE: + // Toggle display of the cut height value in RAW vs UNITS + if (gClipHeightDisplayType == DISPLAY_TYPE::DISPLAY_RAW) + { + gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; + } + else + { + gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_RAW; + } + this->Invalidate(); + break; + case WIDX_CLIP_SELECTOR: + // Activate the selection tool + tool_set(this, WIDX_BACKGROUND, Tool::Crosshair); + _toolActive = true; + _dragging = false; + + // Reset clip selection to show all tiles + _previousClipSelectionA = gClipSelectionA; + _previousClipSelectionB = gClipSelectionB; + gClipSelectionA = { 0, 0 }; + gClipSelectionB = { MAXIMUM_MAP_SIZE_BIG - 1, MAXIMUM_MAP_SIZE_BIG - 1 }; + gfx_invalidate_screen(); + break; + case WIDX_CLIP_CLEAR: + if (IsActive()) + { + _toolActive = false; + tool_cancel(); + } + gClipSelectionA = { 0, 0 }; + gClipSelectionB = { MAXIMUM_MAP_SIZE_BIG - 1, MAXIMUM_MAP_SIZE_BIG - 1 }; + gfx_invalidate_screen(); + break; + } + } + + void OnMouseDown(rct_widgetindex widgetIndex) override + { + + rct_window* mainWindow; + + switch (widgetIndex) + { + case WIDX_CLIP_HEIGHT_INCREASE: + if (gClipHeight < 255) + SetClipHeight(gClipHeight + 1); + mainWindow = window_get_main(); + if (mainWindow != nullptr) + mainWindow->Invalidate(); + break; + case WIDX_CLIP_HEIGHT_DECREASE: + if (gClipHeight > 0) + SetClipHeight(gClipHeight - 1); + mainWindow = window_get_main(); + if (mainWindow != nullptr) + mainWindow->Invalidate(); + break; + } + } + + void OnUpdate() override + { + const rct_widget* const widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const rct_scroll* const scroll = &this->scrolls[0]; + const int16_t scroll_width = widget->width() - 1; + const uint8_t clip_height = static_cast( + (static_cast(scroll->h_left) / (scroll->h_right - scroll_width)) * 255); + if (clip_height != gClipHeight) + { + gClipHeight = clip_height; + + // Update the main window accordingly. + rct_window* mainWindow = window_get_main(); + if (mainWindow != nullptr) + { + mainWindow->Invalidate(); + } + } + + // Restore previous selection if the tool has been interrupted + if (_toolActive && !IsActive()) + { + _toolActive = false; + gClipSelectionA = _previousClipSelectionA; + gClipSelectionB = _previousClipSelectionB; + } + + widget_invalidate(this, WIDX_CLIP_HEIGHT_SLIDER); + } + + void OnToolUpdate(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + { + if (_dragging) + { + return; + } + + int32_t direction; + auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); + if (mapCoords.has_value()) + { + gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE; + map_invalidate_tile_full(gMapSelectPositionA); + gMapSelectPositionA = gMapSelectPositionB = mapCoords.value(); + map_invalidate_tile_full(mapCoords.value()); + gMapSelectType = MAP_SELECT_TYPE_FULL; + } + } + + void OnToolDown(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) override + { + int32_t direction; + auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); + if (mapCoords.has_value()) + { + _dragging = true; + _selectionStart = mapCoords.value(); + } + } + + void OnToolDrag(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + { + if (!_dragging) + { + return; + } + + int32_t direction; + auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); + if (mapCoords) + { + map_invalidate_selection_rect(); + gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE; + gMapSelectPositionA.x = std::min(_selectionStart.x, mapCoords->x); + gMapSelectPositionB.x = std::max(_selectionStart.x, mapCoords->x); + gMapSelectPositionA.y = std::min(_selectionStart.y, mapCoords->y); + gMapSelectPositionB.y = std::max(_selectionStart.y, mapCoords->y); + gMapSelectType = MAP_SELECT_TYPE_FULL; + map_invalidate_selection_rect(); + } + } + + void OnToolUp(rct_widgetindex, const ScreenCoordsXY&) + { + gClipSelectionA = gMapSelectPositionA; + gClipSelectionB = gMapSelectPositionB; + _toolActive = false; + tool_cancel(); + gfx_invalidate_screen(); + } + + void OnInvalidate() + { + WidgetScrollUpdateThumbs(this, WIDX_CLIP_HEIGHT_SLIDER); + + rct_window* mainWindow = window_get_main(); + if (mainWindow != nullptr) + { + WidgetSetCheckboxValue(this, WIDX_CLIP_CHECKBOX_ENABLE, mainWindow->viewport->flags & VIEWPORT_FLAG_CLIP_VIEW); + } + + if (IsActive()) + { + this->pressed_widgets |= 1ULL << WIDX_CLIP_SELECTOR; + } + else + { + this->pressed_widgets &= ~(1ULL << WIDX_CLIP_SELECTOR); + } + } + + void OnPaint(rct_drawpixelinfo* dpi) + { + + WindowDrawWidgets(this, dpi); + + // Clip height value + auto screenCoords = this->windowPos + ScreenCoordsXY{ 8, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; + DrawTextBasic(dpi, screenCoords, STR_VIEW_CLIPPING_HEIGHT_VALUE, {}, { this->colours[0] }); + + screenCoords = this->windowPos + + ScreenCoordsXY{ this->widgets[WIDX_CLIP_HEIGHT_VALUE].left + 1, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; + + switch (gClipHeightDisplayType) + { + case DISPLAY_TYPE::DISPLAY_RAW: + default: + { + auto ft = Formatter(); + ft.Add(static_cast(gClipHeight)); + DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); // Printing the raw value. + break; + } + case DISPLAY_TYPE::DISPLAY_UNITS: + { + // Print the value in the configured height label type: + if (gConfigGeneral.show_height_as_units == 1) + { + // Height label is Units. + auto ft = Formatter(); + ft.Add(static_cast(FIXED_1DP(gClipHeight, 0) / 2 - FIXED_1DP(7, 0))); + DrawTextBasic( + dpi, screenCoords, STR_UNIT1DP_NO_SUFFIX, ft, + { this->colours[0] }); // Printing the value in Height Units. + } + else + { + // Height label is Real Values. + // Print the value in the configured measurement units. + switch (gConfigGeneral.measurement_format) + { + case MeasurementFormat::Metric: + case MeasurementFormat::SI: + { + auto ft = Formatter(); + ft.Add( + static_cast(FIXED_2DP(gClipHeight, 0) / 2 * 1.5f - FIXED_2DP(10, 50))); + DrawTextBasic(dpi, screenCoords, STR_UNIT2DP_SUFFIX_METRES, ft, { this->colours[0] }); + break; + } + case MeasurementFormat::Imperial: + { + auto ft = Formatter(); + ft.Add( + static_cast(FIXED_1DP(gClipHeight, 0) / 2.0f * 5 - FIXED_1DP(35, 0))); + DrawTextBasic(dpi, screenCoords, STR_UNIT1DP_SUFFIX_FEET, ft, { this->colours[0] }); + break; + } + } + } + } + } + } + + ScreenSize OnScrollGetSize(int32_t scrollIndex) override //void OnScrollGetSize(int scrollIndex, int* width, int* height) + { + return { 1000, 0 }; + } + +private: + void OnClose() override + { + // Turn off view clipping when the window is closed. + rct_window* mainWindow = window_get_main(); + if (mainWindow != nullptr) + { + mainWindow->viewport->flags &= ~VIEWPORT_FLAG_CLIP_VIEW; + mainWindow->Invalidate(); + } + } + + void SetClipHeight(const uint8_t clipheight) + { + gClipHeight = clipheight; + rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const float clip_height_ratio = static_cast(gClipHeight) / 255; + this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + } + + bool IsActive() + { + if (!(input_test_flag(INPUT_FLAG_TOOL_ACTIVE))) + return false; + if (gCurrentToolWidget.window_classification != WC_VIEW_CLIPPING) + return false; + return _toolActive; + } + +}; rct_window* window_view_clipping_open() { + auto* window = window_bring_to_front_by_class(WC_VIEW_CLIPPING); + if (window == nullptr) + { + window = WindowCreate(WC_VIEW_CLIPPING, ScreenCoordsXY(32, 32), WW, WH); + } + return window; + /* rct_window* window; // Get the main viewport to set the view clipping flag. @@ -155,8 +462,19 @@ rct_window* window_view_clipping_open() _dragging = false; return window; + */ +} +/* +// Done +static void window_view_clipping_set_clipheight(rct_window* w, const uint8_t clipheight) +{ + gClipHeight = clipheight; + rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const float clip_height_ratio = static_cast(gClipHeight) / 255; + w->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (w->scrolls[0].h_right - (widget->width() - 1)))); } +// Done static void window_view_clipping_close() { // Turn off view clipping when the window is closed. @@ -168,11 +486,13 @@ static void window_view_clipping_close() } } +// Done static void window_view_clipping_close_button(rct_window* w) { window_view_clipping_close(); } +// Done // Returns true when the tool is active static bool window_view_clipping_tool_is_active() { @@ -183,6 +503,7 @@ static bool window_view_clipping_tool_is_active() return _toolActive; } +// Done static void window_view_clipping_mouseup(rct_window* w, rct_widgetindex widgetIndex) { rct_window* mainWindow; @@ -241,6 +562,7 @@ static void window_view_clipping_mouseup(rct_window* w, rct_widgetindex widgetIn } } +// Done static void window_view_clipping_mousedown(rct_window* w, rct_widgetindex widgetIndex, rct_widget* widget) { rct_window* mainWindow = window_get_main(); @@ -262,6 +584,7 @@ static void window_view_clipping_mousedown(rct_window* w, rct_widgetindex widget } } +// Done static void window_view_clipping_update(rct_window* w) { const rct_widget* const widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; @@ -292,6 +615,7 @@ static void window_view_clipping_update(rct_window* w) widget_invalidate(w, WIDX_CLIP_HEIGHT_SLIDER); } +// Done static void window_view_clipping_tool_update(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { if (_dragging) @@ -311,6 +635,7 @@ static void window_view_clipping_tool_update(rct_window* w, rct_widgetindex widg } } +// Done static void window_view_clipping_tool_down(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { int32_t direction; @@ -322,6 +647,7 @@ static void window_view_clipping_tool_down(rct_window* w, rct_widgetindex widget } } +// Done static void window_view_clipping_tool_drag(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { if (!_dragging) @@ -344,6 +670,7 @@ static void window_view_clipping_tool_drag(rct_window* w, rct_widgetindex widget } } +// Done static void window_view_clipping_tool_up(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&) { gClipSelectionA = gMapSelectPositionA; @@ -353,6 +680,7 @@ static void window_view_clipping_tool_up(struct rct_window*, rct_widgetindex, co gfx_invalidate_screen(); } +// Done static void window_view_clipping_invalidate(rct_window* w) { WidgetScrollUpdateThumbs(w, WIDX_CLIP_HEIGHT_SLIDER); @@ -373,6 +701,7 @@ static void window_view_clipping_invalidate(rct_window* w) } } +// Done static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi) { WindowDrawWidgets(w, dpi); @@ -430,7 +759,10 @@ static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi) } } +// Done static void window_view_clipping_scrollgetsize(rct_window* w, int scrollIndex, int* width, int* height) { *width = 1000; } +*/ + From 762005f25a2381474af140c8226a747da8755f5f Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Tue, 28 Sep 2021 21:25:07 +0200 Subject: [PATCH 02/19] Fixed crash caused by window not being properly initialized --- src/openrct2-ui/windows/ViewClipping.cpp | 61 +++++++++--------------- 1 file changed, 22 insertions(+), 39 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index ef0d668230..c3d9aacfe2 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -115,8 +115,9 @@ private: CoordsXY _selectionStart; CoordsXY _previousClipSelectionA; CoordsXY _previousClipSelectionB; - bool _toolActive; - bool _dragging; + bool _toolActive{ false }; + bool _dragging{ false }; + public: void OnCloseButton() { @@ -384,6 +385,14 @@ public: return { 1000, 0 }; } + void SetClipHeight(const uint8_t clipheight) + { + gClipHeight = clipheight; + rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const float clip_height_ratio = static_cast(gClipHeight) / 255; + this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + } + private: void OnClose() override { @@ -396,14 +405,6 @@ private: } } - void SetClipHeight(const uint8_t clipheight) - { - gClipHeight = clipheight; - rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; - const float clip_height_ratio = static_cast(gClipHeight) / 255; - this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); - } - bool IsActive() { if (!(input_test_flag(INPUT_FLAG_TOOL_ACTIVE))) @@ -421,36 +422,22 @@ rct_window* window_view_clipping_open() if (window == nullptr) { window = WindowCreate(WC_VIEW_CLIPPING, ScreenCoordsXY(32, 32), WW, WH); + window->widgets = window_view_clipping_widgets; + window->enabled_widgets = (1ULL << WIDX_CLOSE) | (1ULL << WIDX_CLIP_CHECKBOX_ENABLE) | (1ULL << WIDX_CLIP_HEIGHT_VALUE) + | (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1ULL << WIDX_CLIP_HEIGHT_DECREASE) | (1ULL << WIDX_CLIP_HEIGHT_SLIDER) + | (1ULL << WIDX_CLIP_SELECTOR) | (1ULL << WIDX_CLIP_CLEAR); + window->hold_down_widgets = (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1UL << WIDX_CLIP_HEIGHT_DECREASE); + WindowInitScrollWidgets(window); } - return window; - /* - rct_window* window; + + // Initialise the clip height slider from the current clip height value. + dynamic_cast(window)->SetClipHeight(gClipHeight); + + window_push_others_below(window); // Get the main viewport to set the view clipping flag. rct_window* mainWindow = window_get_main(); - // Check if window is already open - window = window_find_by_class(WC_VIEW_CLIPPING); - if (window != nullptr) - { - return window; - } - - // Window is not open - create it. - window = WindowCreate(ScreenCoordsXY(32, 32), WW, WH, &window_view_clipping_events, WC_VIEW_CLIPPING, 0); - window->widgets = window_view_clipping_widgets; - window->enabled_widgets = (1ULL << WIDX_CLOSE) | (1ULL << WIDX_CLIP_CHECKBOX_ENABLE) | (1ULL << WIDX_CLIP_HEIGHT_VALUE) - | (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1ULL << WIDX_CLIP_HEIGHT_DECREASE) | (1ULL << WIDX_CLIP_HEIGHT_SLIDER) - | (1ULL << WIDX_CLIP_SELECTOR) | (1ULL << WIDX_CLIP_CLEAR); - window->hold_down_widgets = (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1UL << WIDX_CLIP_HEIGHT_DECREASE); - - WindowInitScrollWidgets(window); - - // Initialise the clip height slider from the current clip height value. - window_view_clipping_set_clipheight(window, gClipHeight); - - window_push_others_below(window); - // Turn on view clipping when the window is opened. if (mainWindow != nullptr) { @@ -458,11 +445,7 @@ rct_window* window_view_clipping_open() mainWindow->Invalidate(); } - _toolActive = false; - _dragging = false; - return window; - */ } /* // Done From dbe07554c9ba4b501514caace07901ecb22eeca6 Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Sun, 3 Oct 2021 14:11:53 +0200 Subject: [PATCH 03/19] Added OnOpen() to ViewClippingWindow --- src/openrct2-ui/windows/ViewClipping.cpp | 58 +++++++++++++----------- 1 file changed, 31 insertions(+), 27 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index c3d9aacfe2..4d60925b7e 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -385,12 +385,30 @@ public: return { 1000, 0 }; } - void SetClipHeight(const uint8_t clipheight) + void OnOpen() override { - gClipHeight = clipheight; - rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; - const float clip_height_ratio = static_cast(gClipHeight) / 255; - this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + this->widgets = window_view_clipping_widgets; + this->enabled_widgets = (1ULL << WIDX_CLOSE) | (1ULL << WIDX_CLIP_CHECKBOX_ENABLE) | (1ULL << WIDX_CLIP_HEIGHT_VALUE) + | (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1ULL << WIDX_CLIP_HEIGHT_DECREASE) | (1ULL << WIDX_CLIP_HEIGHT_SLIDER) + | (1ULL << WIDX_CLIP_SELECTOR) | (1ULL << WIDX_CLIP_CLEAR); + this->hold_down_widgets = (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1UL << WIDX_CLIP_HEIGHT_DECREASE); + WindowInitScrollWidgets(this); + + // Initialise the clip height slider from the current clip height value. + this->SetClipHeight(gClipHeight); + + window_push_others_below(this); + + // Get the main viewport to set the view clipping flag. + rct_window* mainWindow = window_get_main(); + + // Turn on view clipping when the window is opened. + if (mainWindow != nullptr) + { + mainWindow->viewport->flags |= VIEWPORT_FLAG_CLIP_VIEW; + mainWindow->Invalidate(); + } + } private: @@ -405,6 +423,14 @@ private: } } + void SetClipHeight(const uint8_t clipheight) + { + gClipHeight = clipheight; + rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const float clip_height_ratio = static_cast(gClipHeight) / 255; + this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + } + bool IsActive() { if (!(input_test_flag(INPUT_FLAG_TOOL_ACTIVE))) @@ -422,29 +448,7 @@ rct_window* window_view_clipping_open() if (window == nullptr) { window = WindowCreate(WC_VIEW_CLIPPING, ScreenCoordsXY(32, 32), WW, WH); - window->widgets = window_view_clipping_widgets; - window->enabled_widgets = (1ULL << WIDX_CLOSE) | (1ULL << WIDX_CLIP_CHECKBOX_ENABLE) | (1ULL << WIDX_CLIP_HEIGHT_VALUE) - | (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1ULL << WIDX_CLIP_HEIGHT_DECREASE) | (1ULL << WIDX_CLIP_HEIGHT_SLIDER) - | (1ULL << WIDX_CLIP_SELECTOR) | (1ULL << WIDX_CLIP_CLEAR); - window->hold_down_widgets = (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1UL << WIDX_CLIP_HEIGHT_DECREASE); - WindowInitScrollWidgets(window); } - - // Initialise the clip height slider from the current clip height value. - dynamic_cast(window)->SetClipHeight(gClipHeight); - - window_push_others_below(window); - - // Get the main viewport to set the view clipping flag. - rct_window* mainWindow = window_get_main(); - - // Turn on view clipping when the window is opened. - if (mainWindow != nullptr) - { - mainWindow->viewport->flags |= VIEWPORT_FLAG_CLIP_VIEW; - mainWindow->Invalidate(); - } - return window; } /* From 0a392841c208e2a7acdec6613507434a449b89b9 Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Sun, 3 Oct 2021 23:05:48 +0200 Subject: [PATCH 04/19] Added functions OnToolUpdate, OnToolDrag, OnToolUp to rct_window --- src/openrct2/interface/Window_internal.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/openrct2/interface/Window_internal.h b/src/openrct2/interface/Window_internal.h index 56dab05199..5a4568ce27 100644 --- a/src/openrct2/interface/Window_internal.h +++ b/src/openrct2/interface/Window_internal.h @@ -176,9 +176,18 @@ struct rct_window virtual void OnScrollDraw(int32_t scrollIndex, rct_drawpixelinfo& dpi) { } + virtual void OnToolUpdate(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + { + } virtual void OnToolDown(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { } + virtual void OnToolDrag(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + { + } + virtual void OnToolUp(rct_widgetindex, const ScreenCoordsXY&) + { + } virtual void OnToolAbort(rct_widgetindex widgetIndex) { } From 4fe21e3274d2b8b2c22d84056f18a4f9710e50cd Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Sun, 3 Oct 2021 23:07:03 +0200 Subject: [PATCH 05/19] OnToolUpdate, OnToolDrag, OnToolUp now being used --- src/openrct2/interface/Window.cpp | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/src/openrct2/interface/Window.cpp b/src/openrct2/interface/Window.cpp index 68276a7d51..94cc1dbeb5 100644 --- a/src/openrct2/interface/Window.cpp +++ b/src/openrct2/interface/Window.cpp @@ -1462,9 +1462,10 @@ void window_event_unknown_08_call(rct_window* w) void window_event_tool_update_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { - if (w->event_handlers != nullptr) - if (w->event_handlers->tool_update != nullptr) - w->event_handlers->tool_update(w, widgetIndex, screenCoords); + if (w->event_handlers == nullptr) + w->OnToolUpdate(widgetIndex, screenCoords); + else if (w->event_handlers->tool_update != nullptr) + w->event_handlers->tool_update(w, widgetIndex, screenCoords); } void window_event_tool_down_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) @@ -1477,16 +1478,18 @@ void window_event_tool_down_call(rct_window* w, rct_widgetindex widgetIndex, con void window_event_tool_drag_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { - if (w->event_handlers != nullptr) - if (w->event_handlers->tool_drag != nullptr) - w->event_handlers->tool_drag(w, widgetIndex, screenCoords); + if (w->event_handlers == nullptr) + w->OnToolDrag(widgetIndex, screenCoords); + else if (w->event_handlers->tool_drag != nullptr) + w->event_handlers->tool_drag(w, widgetIndex, screenCoords); } void window_event_tool_up_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) { - if (w->event_handlers != nullptr) - if (w->event_handlers->tool_up != nullptr) - w->event_handlers->tool_up(w, widgetIndex, screenCoords); + if (w->event_handlers == nullptr) + w->OnToolUp(widgetIndex, screenCoords); + else if (w->event_handlers->tool_up != nullptr) + w->event_handlers->tool_up(w, widgetIndex, screenCoords); } void window_event_tool_abort_call(rct_window* w, rct_widgetindex widgetIndex) From 0195ce45a2a6acb1e609260c8b63735b2501e779 Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Sun, 3 Oct 2021 23:08:52 +0200 Subject: [PATCH 06/19] Added OnToolUpdate, OnToolDrag, OnToolUp, OnPrepareDraw to new window --- src/openrct2-ui/windows/ViewClipping.cpp | 369 +---------------------- 1 file changed, 12 insertions(+), 357 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index 4d60925b7e..efc6cb535b 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -64,50 +64,7 @@ static rct_widget window_view_clipping_widgets[] = { #pragma endregion -#pragma region Members -/* -static CoordsXY _selectionStart; -static CoordsXY _previousClipSelectionA; -static CoordsXY _previousClipSelectionB; -static bool _toolActive; -static bool _dragging; -*/ -#pragma endregion - -#pragma region Events -/* -static void window_view_clipping_close_button(rct_window* w); -static void window_view_clipping_mouseup(rct_window* w, rct_widgetindex widgetIndex); -static void window_view_clipping_mousedown(rct_window*w, rct_widgetindex widgetIndex, rct_widget *widget); -static void window_view_clipping_update(rct_window* w); -static void window_view_clipping_tool_update(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords); -static void window_view_clipping_tool_down(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords); -static void window_view_clipping_tool_drag(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords); -static void window_view_clipping_tool_up(rct_window* w, rct_widgetindex, const ScreenCoordsXY&); -static void window_view_clipping_invalidate(rct_window* w); -static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi); -static void window_view_clipping_scrollgetsize(rct_window* w, int scrollIndex, int* width, int* height); -static void window_view_clipping_close(); - -static rct_window_event_list window_view_clipping_events([](auto& events) -{ - events.close = &window_view_clipping_close_button; - events.mouse_up = &window_view_clipping_mouseup; - events.mouse_down = &window_view_clipping_mousedown; - events.update = &window_view_clipping_update; - events.tool_update = &window_view_clipping_tool_update; - events.tool_down = &window_view_clipping_tool_down; - events.tool_drag = &window_view_clipping_tool_drag; - events.tool_up = &window_view_clipping_tool_up; - events.get_scroll_size = &window_view_clipping_scrollgetsize; - events.invalidate = &window_view_clipping_invalidate; - events.paint = &window_view_clipping_paint; -}); -*/ // clang-format on - -#pragma endregion - class ViewClippingWindow final : public Window { private: @@ -132,7 +89,7 @@ public: switch (widgetIndex) { case WIDX_CLOSE: - window_close(this); // Unsure about this. ~hjort96 + window_close(this); break; case WIDX_CLIP_CHECKBOX_ENABLE: // Toggle height clipping. @@ -236,7 +193,7 @@ public: widget_invalidate(this, WIDX_CLIP_HEIGHT_SLIDER); } - void OnToolUpdate(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + void OnToolUpdate(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) override { if (_dragging) { @@ -266,7 +223,7 @@ public: } } - void OnToolDrag(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) + void OnToolDrag(rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) override { if (!_dragging) { @@ -288,7 +245,7 @@ public: } } - void OnToolUp(rct_widgetindex, const ScreenCoordsXY&) + void OnToolUp(rct_widgetindex, const ScreenCoordsXY&) override { gClipSelectionA = gMapSelectPositionA; gClipSelectionB = gMapSelectPositionB; @@ -297,7 +254,7 @@ public: gfx_invalidate_screen(); } - void OnInvalidate() + void OnPrepareDraw() override { WidgetScrollUpdateThumbs(this, WIDX_CLIP_HEIGHT_SLIDER); @@ -317,14 +274,14 @@ public: } } - void OnPaint(rct_drawpixelinfo* dpi) + void OnDraw(rct_drawpixelinfo& dpi) override { - WindowDrawWidgets(this, dpi); + WindowDrawWidgets(this, &dpi); // Clip height value auto screenCoords = this->windowPos + ScreenCoordsXY{ 8, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; - DrawTextBasic(dpi, screenCoords, STR_VIEW_CLIPPING_HEIGHT_VALUE, {}, { this->colours[0] }); + DrawTextBasic(&dpi, screenCoords, STR_VIEW_CLIPPING_HEIGHT_VALUE, {}, { this->colours[0] }); screenCoords = this->windowPos + ScreenCoordsXY{ this->widgets[WIDX_CLIP_HEIGHT_VALUE].left + 1, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; @@ -336,7 +293,7 @@ public: { auto ft = Formatter(); ft.Add(static_cast(gClipHeight)); - DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); // Printing the raw value. + DrawTextBasic(&dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); // Printing the raw value. break; } case DISPLAY_TYPE::DISPLAY_UNITS: @@ -348,7 +305,7 @@ public: auto ft = Formatter(); ft.Add(static_cast(FIXED_1DP(gClipHeight, 0) / 2 - FIXED_1DP(7, 0))); DrawTextBasic( - dpi, screenCoords, STR_UNIT1DP_NO_SUFFIX, ft, + &dpi, screenCoords, STR_UNIT1DP_NO_SUFFIX, ft, { this->colours[0] }); // Printing the value in Height Units. } else @@ -363,7 +320,7 @@ public: auto ft = Formatter(); ft.Add( static_cast(FIXED_2DP(gClipHeight, 0) / 2 * 1.5f - FIXED_2DP(10, 50))); - DrawTextBasic(dpi, screenCoords, STR_UNIT2DP_SUFFIX_METRES, ft, { this->colours[0] }); + DrawTextBasic(&dpi, screenCoords, STR_UNIT2DP_SUFFIX_METRES, ft, { this->colours[0] }); break; } case MeasurementFormat::Imperial: @@ -371,7 +328,7 @@ public: auto ft = Formatter(); ft.Add( static_cast(FIXED_1DP(gClipHeight, 0) / 2.0f * 5 - FIXED_1DP(35, 0))); - DrawTextBasic(dpi, screenCoords, STR_UNIT1DP_SUFFIX_FEET, ft, { this->colours[0] }); + DrawTextBasic(&dpi, screenCoords, STR_UNIT1DP_SUFFIX_FEET, ft, { this->colours[0] }); break; } } @@ -451,305 +408,3 @@ rct_window* window_view_clipping_open() } return window; } -/* -// Done -static void window_view_clipping_set_clipheight(rct_window* w, const uint8_t clipheight) -{ - gClipHeight = clipheight; - rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; - const float clip_height_ratio = static_cast(gClipHeight) / 255; - w->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (w->scrolls[0].h_right - (widget->width() - 1)))); -} - -// Done -static void window_view_clipping_close() -{ - // Turn off view clipping when the window is closed. - rct_window* mainWindow = window_get_main(); - if (mainWindow != nullptr) - { - mainWindow->viewport->flags &= ~VIEWPORT_FLAG_CLIP_VIEW; - mainWindow->Invalidate(); - } -} - -// Done -static void window_view_clipping_close_button(rct_window* w) -{ - window_view_clipping_close(); -} - -// Done -// Returns true when the tool is active -static bool window_view_clipping_tool_is_active() -{ - if (!(input_test_flag(INPUT_FLAG_TOOL_ACTIVE))) - return false; - if (gCurrentToolWidget.window_classification != WC_VIEW_CLIPPING) - return false; - return _toolActive; -} - -// Done -static void window_view_clipping_mouseup(rct_window* w, rct_widgetindex widgetIndex) -{ - rct_window* mainWindow; - - // mouseup appears to be used for buttons, checkboxes - switch (widgetIndex) - { - case WIDX_CLOSE: - window_close(w); - break; - case WIDX_CLIP_CHECKBOX_ENABLE: - // Toggle height clipping. - mainWindow = window_get_main(); - if (mainWindow != nullptr) - { - mainWindow->viewport->flags ^= VIEWPORT_FLAG_CLIP_VIEW; - mainWindow->Invalidate(); - } - w->Invalidate(); - break; - case WIDX_CLIP_HEIGHT_VALUE: - // Toggle display of the cut height value in RAW vs UNITS - if (gClipHeightDisplayType == DISPLAY_TYPE::DISPLAY_RAW) - { - gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; - } - else - { - gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_RAW; - } - w->Invalidate(); - break; - case WIDX_CLIP_SELECTOR: - // Activate the selection tool - tool_set(w, WIDX_BACKGROUND, Tool::Crosshair); - _toolActive = true; - _dragging = false; - - // Reset clip selection to show all tiles - _previousClipSelectionA = gClipSelectionA; - _previousClipSelectionB = gClipSelectionB; - gClipSelectionA = { 0, 0 }; - gClipSelectionB = { MAXIMUM_MAP_SIZE_BIG - 1, MAXIMUM_MAP_SIZE_BIG - 1 }; - gfx_invalidate_screen(); - break; - case WIDX_CLIP_CLEAR: - if (window_view_clipping_tool_is_active()) - { - _toolActive = false; - tool_cancel(); - } - gClipSelectionA = { 0, 0 }; - gClipSelectionB = { MAXIMUM_MAP_SIZE_BIG - 1, MAXIMUM_MAP_SIZE_BIG - 1 }; - gfx_invalidate_screen(); - break; - } -} - -// Done -static void window_view_clipping_mousedown(rct_window* w, rct_widgetindex widgetIndex, rct_widget* widget) -{ - rct_window* mainWindow = window_get_main(); - - switch (widgetIndex) - { - case WIDX_CLIP_HEIGHT_INCREASE: - if (gClipHeight < 255) - window_view_clipping_set_clipheight(w, gClipHeight + 1); - if (mainWindow != nullptr) - mainWindow->Invalidate(); - break; - case WIDX_CLIP_HEIGHT_DECREASE: - if (gClipHeight > 0) - window_view_clipping_set_clipheight(w, gClipHeight - 1); - if (mainWindow != nullptr) - mainWindow->Invalidate(); - break; - } -} - -// Done -static void window_view_clipping_update(rct_window* w) -{ - const rct_widget* const widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; - const rct_scroll* const scroll = &w->scrolls[0]; - const int16_t scroll_width = widget->width() - 1; - const uint8_t clip_height = static_cast( - (static_cast(scroll->h_left) / (scroll->h_right - scroll_width)) * 255); - if (clip_height != gClipHeight) - { - gClipHeight = clip_height; - - // Update the main window accordingly. - rct_window* mainWindow = window_get_main(); - if (mainWindow != nullptr) - { - mainWindow->Invalidate(); - } - } - - // Restore previous selection if the tool has been interrupted - if (_toolActive && !window_view_clipping_tool_is_active()) - { - _toolActive = false; - gClipSelectionA = _previousClipSelectionA; - gClipSelectionB = _previousClipSelectionB; - } - - widget_invalidate(w, WIDX_CLIP_HEIGHT_SLIDER); -} - -// Done -static void window_view_clipping_tool_update(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) -{ - if (_dragging) - { - return; - } - - int32_t direction; - auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); - if (mapCoords.has_value()) - { - gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE; - map_invalidate_tile_full(gMapSelectPositionA); - gMapSelectPositionA = gMapSelectPositionB = mapCoords.value(); - map_invalidate_tile_full(mapCoords.value()); - gMapSelectType = MAP_SELECT_TYPE_FULL; - } -} - -// Done -static void window_view_clipping_tool_down(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) -{ - int32_t direction; - auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); - if (mapCoords.has_value()) - { - _dragging = true; - _selectionStart = mapCoords.value(); - } -} - -// Done -static void window_view_clipping_tool_drag(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords) -{ - if (!_dragging) - { - return; - } - - int32_t direction; - auto mapCoords = screen_pos_to_map_pos(screenCoords, &direction); - if (mapCoords) - { - map_invalidate_selection_rect(); - gMapSelectFlags |= MAP_SELECT_FLAG_ENABLE; - gMapSelectPositionA.x = std::min(_selectionStart.x, mapCoords->x); - gMapSelectPositionB.x = std::max(_selectionStart.x, mapCoords->x); - gMapSelectPositionA.y = std::min(_selectionStart.y, mapCoords->y); - gMapSelectPositionB.y = std::max(_selectionStart.y, mapCoords->y); - gMapSelectType = MAP_SELECT_TYPE_FULL; - map_invalidate_selection_rect(); - } -} - -// Done -static void window_view_clipping_tool_up(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&) -{ - gClipSelectionA = gMapSelectPositionA; - gClipSelectionB = gMapSelectPositionB; - _toolActive = false; - tool_cancel(); - gfx_invalidate_screen(); -} - -// Done -static void window_view_clipping_invalidate(rct_window* w) -{ - WidgetScrollUpdateThumbs(w, WIDX_CLIP_HEIGHT_SLIDER); - - rct_window* mainWindow = window_get_main(); - if (mainWindow != nullptr) - { - WidgetSetCheckboxValue(w, WIDX_CLIP_CHECKBOX_ENABLE, mainWindow->viewport->flags & VIEWPORT_FLAG_CLIP_VIEW); - } - - if (window_view_clipping_tool_is_active()) - { - w->pressed_widgets |= 1ULL << WIDX_CLIP_SELECTOR; - } - else - { - w->pressed_widgets &= ~(1ULL << WIDX_CLIP_SELECTOR); - } -} - -// Done -static void window_view_clipping_paint(rct_window* w, rct_drawpixelinfo* dpi) -{ - WindowDrawWidgets(w, dpi); - - // Clip height value - auto screenCoords = w->windowPos + ScreenCoordsXY{ 8, w->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; - DrawTextBasic(dpi, screenCoords, STR_VIEW_CLIPPING_HEIGHT_VALUE, {}, { w->colours[0] }); - - screenCoords = w->windowPos - + ScreenCoordsXY{ w->widgets[WIDX_CLIP_HEIGHT_VALUE].left + 1, w->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; - - switch (gClipHeightDisplayType) - { - case DISPLAY_TYPE::DISPLAY_RAW: - default: - { - auto ft = Formatter(); - ft.Add(static_cast(gClipHeight)); - DrawTextBasic(dpi, screenCoords, STR_FORMAT_INTEGER, ft, { w->colours[0] }); // Printing the raw value. - break; - } - case DISPLAY_TYPE::DISPLAY_UNITS: - // Print the value in the configured height label type: - if (gConfigGeneral.show_height_as_units == 1) - { - // Height label is Units. - auto ft = Formatter(); - ft.Add(static_cast(FIXED_1DP(gClipHeight, 0) / 2 - FIXED_1DP(7, 0))); - DrawTextBasic( - dpi, screenCoords, STR_UNIT1DP_NO_SUFFIX, ft, { w->colours[0] }); // Printing the value in Height Units. - } - else - { - // Height label is Real Values. - // Print the value in the configured measurement units. - switch (gConfigGeneral.measurement_format) - { - case MeasurementFormat::Metric: - case MeasurementFormat::SI: - { - auto ft = Formatter(); - ft.Add(static_cast(FIXED_2DP(gClipHeight, 0) / 2 * 1.5f - FIXED_2DP(10, 50))); - DrawTextBasic(dpi, screenCoords, STR_UNIT2DP_SUFFIX_METRES, ft, { w->colours[0] }); - break; - } - case MeasurementFormat::Imperial: - { - auto ft = Formatter(); - ft.Add(static_cast(FIXED_1DP(gClipHeight, 0) / 2.0f * 5 - FIXED_1DP(35, 0))); - DrawTextBasic(dpi, screenCoords, STR_UNIT1DP_SUFFIX_FEET, ft, { w->colours[0] }); - break; - } - } - } - } -} - -// Done -static void window_view_clipping_scrollgetsize(rct_window* w, int scrollIndex, int* width, int* height) -{ - *width = 1000; -} -*/ - From 9a2a12af98bc7459fc4dfad5666f346f6b775395 Mon Sep 17 00:00:00 2001 From: Jonathan Hjorth Date: Tue, 5 Oct 2021 11:09:37 +0200 Subject: [PATCH 07/19] Cleaning code --- src/openrct2-ui/windows/ViewClipping.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index efc6cb535b..abcd833148 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -141,7 +141,6 @@ public: void OnMouseDown(rct_widgetindex widgetIndex) override { - rct_window* mainWindow; switch (widgetIndex) @@ -276,7 +275,6 @@ public: void OnDraw(rct_drawpixelinfo& dpi) override { - WindowDrawWidgets(this, &dpi); // Clip height value @@ -293,7 +291,9 @@ public: { auto ft = Formatter(); ft.Add(static_cast(gClipHeight)); - DrawTextBasic(&dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); // Printing the raw value. + + // Printing the raw value. + DrawTextBasic(&dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); break; } case DISPLAY_TYPE::DISPLAY_UNITS: @@ -337,7 +337,7 @@ public: } } - ScreenSize OnScrollGetSize(int32_t scrollIndex) override //void OnScrollGetSize(int scrollIndex, int* width, int* height) + ScreenSize OnScrollGetSize(int32_t scrollIndex) override { return { 1000, 0 }; } @@ -365,7 +365,6 @@ public: mainWindow->viewport->flags |= VIEWPORT_FLAG_CLIP_VIEW; mainWindow->Invalidate(); } - } private: @@ -385,7 +384,8 @@ private: gClipHeight = clipheight; rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; const float clip_height_ratio = static_cast(gClipHeight) / 255; - this->scrolls[0].h_left = static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + this->scrolls[0].h_left = + static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); } bool IsActive() From 763c31ce5bcab3c5a37fae60cac66c8937deada3 Mon Sep 17 00:00:00 2001 From: hjort96 Date: Tue, 5 Oct 2021 20:06:17 +0200 Subject: [PATCH 08/19] Fix clang-format --- src/openrct2-ui/windows/ViewClipping.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index abcd833148..0f73b567c7 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -68,7 +68,6 @@ static rct_widget window_view_clipping_widgets[] = { class ViewClippingWindow final : public Window { private: - CoordsXY _selectionStart; CoordsXY _previousClipSelectionA; CoordsXY _previousClipSelectionB; @@ -89,7 +88,7 @@ public: switch (widgetIndex) { case WIDX_CLOSE: - window_close(this); + window_close(this); break; case WIDX_CLIP_CHECKBOX_ENABLE: // Toggle height clipping. @@ -293,7 +292,7 @@ public: ft.Add(static_cast(gClipHeight)); // Printing the raw value. - DrawTextBasic(&dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); + DrawTextBasic(&dpi, screenCoords, STR_FORMAT_INTEGER, ft, { this->colours[0] }); break; } case DISPLAY_TYPE::DISPLAY_UNITS: @@ -384,8 +383,8 @@ private: gClipHeight = clipheight; rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; const float clip_height_ratio = static_cast(gClipHeight) / 255; - this->scrolls[0].h_left = - static_cast(std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + this->scrolls[0].h_left = static_cast( + std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); } bool IsActive() @@ -396,7 +395,6 @@ private: return false; return _toolActive; } - }; rct_window* window_view_clipping_open() From 6ad41500855206b7056cc2b29654f2e19e664102 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=B6eh=20Matt?= <5415177+ZehMatt@users.noreply.github.com> Date: Wed, 6 Oct 2021 17:15:40 +0300 Subject: [PATCH 09/19] Introduce rendering engine flag for parallel drawing --- src/openrct2/drawing/IDrawingEngine.h | 5 +++++ src/openrct2/drawing/X8DrawingEngine.cpp | 2 +- src/openrct2/interface/Viewport.cpp | 6 ++++++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/openrct2/drawing/IDrawingEngine.h b/src/openrct2/drawing/IDrawingEngine.h index 41c3adb383..92e5e8b783 100644 --- a/src/openrct2/drawing/IDrawingEngine.h +++ b/src/openrct2/drawing/IDrawingEngine.h @@ -32,6 +32,11 @@ enum DRAWING_ENGINE_FLAGS * Whether or not the engine will only draw changed blocks of the screen each frame. */ DEF_DIRTY_OPTIMISATIONS = 1 << 0, + + /** + * The drawing engine is capable of processing the drawing in parallel. + */ + DEF_PARALLEL_DRAWING = 1 << 1, }; struct rct_drawpixelinfo; diff --git a/src/openrct2/drawing/X8DrawingEngine.cpp b/src/openrct2/drawing/X8DrawingEngine.cpp index 9cbbcdcf77..ddaa2d381f 100644 --- a/src/openrct2/drawing/X8DrawingEngine.cpp +++ b/src/openrct2/drawing/X8DrawingEngine.cpp @@ -284,7 +284,7 @@ rct_drawpixelinfo* X8DrawingEngine::GetDrawingPixelInfo() DRAWING_ENGINE_FLAGS X8DrawingEngine::GetFlags() { - return DEF_DIRTY_OPTIMISATIONS; + return static_cast(DEF_DIRTY_OPTIMISATIONS | DEF_PARALLEL_DRAWING); } void X8DrawingEngine::InvalidateImage([[maybe_unused]] uint32_t image) diff --git a/src/openrct2/interface/Viewport.cpp b/src/openrct2/interface/Viewport.cpp index 53200d366d..c16ddeb253 100644 --- a/src/openrct2/interface/Viewport.cpp +++ b/src/openrct2/interface/Viewport.cpp @@ -996,6 +996,12 @@ void viewport_paint( _paintJobs.reset(); } + bool useParallelDrawing = false; + if (useMultithreading && (dpi->DrawingEngine->GetFlags() & DEF_PARALLEL_DRAWING)) + { + useParallelDrawing = true; + } + // Create space to record sessions and keep track which index is being drawn size_t index = 0; if (recorded_sessions != nullptr) From fa340cb5a1ff5045e2115859b3533e25f1195b97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=B6eh=20Matt?= <5415177+ZehMatt@users.noreply.github.com> Date: Wed, 6 Oct 2021 17:24:39 +0300 Subject: [PATCH 10/19] Add parallel drawing if engine allows it --- src/openrct2/interface/Viewport.cpp | 26 +++++++++++++++++++++----- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/src/openrct2/interface/Viewport.cpp b/src/openrct2/interface/Viewport.cpp index c16ddeb253..73450b4978 100644 --- a/src/openrct2/interface/Viewport.cpp +++ b/src/openrct2/interface/Viewport.cpp @@ -931,8 +931,6 @@ static void viewport_paint_column(paint_session* session) { PaintDrawMoneyStructs(&session->DPI, session->PSStringHead); } - - PaintSessionFree(session); } /** @@ -1011,7 +1009,7 @@ void viewport_paint( recorded_sessions->resize(columnCount); } - // Splits the area into 32 pixel columns and renders them + // Generate and sort columns. for (x = alignedX; x < rightBorder; x += 32, index++) { paint_session* session = PaintSessionAlloc(&dpi1, viewFlags); @@ -1052,9 +1050,27 @@ void viewport_paint( _paintJobs->Join(); } - for (auto column : _paintColumns) + // Paint columns. + for (auto* session : _paintColumns) { - viewport_paint_column(column); + if (useParallelDrawing) + { + _paintJobs->AddTask([session]() -> void { viewport_paint_column(session); }); + } + else + { + viewport_paint_column(session); + } + } + if (useParallelDrawing) + { + _paintJobs->Join(); + } + + // Release resources. + for (auto* session : _paintColumns) + { + PaintSessionFree(session); } } From 911f168f8f20bcfb8b971e4f9580f0c0ca77700b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=B6eh=20Matt?= <5415177+ZehMatt@users.noreply.github.com> Date: Wed, 6 Oct 2021 17:28:37 +0300 Subject: [PATCH 11/19] Mark two palettes thread_local for parallel drawing support --- src/openrct2/drawing/Drawing.cpp | 4 ++-- src/openrct2/drawing/Drawing.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/openrct2/drawing/Drawing.cpp b/src/openrct2/drawing/Drawing.cpp index 520bb6ddb6..c4c9d2f466 100644 --- a/src/openrct2/drawing/Drawing.cpp +++ b/src/openrct2/drawing/Drawing.cpp @@ -94,7 +94,7 @@ int32_t gPickupPeepY; * rct2: 0x0009ABE0C */ // clang-format off -uint8_t gPeepPalette[256] = { +thread_local uint8_t gPeepPalette[256] = { 0x00, 0xF3, 0xF4, 0xF5, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, @@ -114,7 +114,7 @@ uint8_t gPeepPalette[256] = { }; /** rct2: 0x009ABF0C */ -uint8_t gOtherPalette[256] = { +thread_local uint8_t gOtherPalette[256] = { 0x00, 0xF3, 0xF4, 0xF5, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, diff --git a/src/openrct2/drawing/Drawing.h b/src/openrct2/drawing/Drawing.h index 47cb785d20..2e66236126 100644 --- a/src/openrct2/drawing/Drawing.h +++ b/src/openrct2/drawing/Drawing.h @@ -657,8 +657,8 @@ extern GamePalette gPalette; extern uint8_t gGamePalette[256 * 4]; extern uint32_t gPaletteEffectFrame; extern const FilterPaletteID GlassPaletteIds[COLOUR_COUNT]; -extern uint8_t gPeepPalette[256]; -extern uint8_t gOtherPalette[256]; +extern thread_local uint8_t gPeepPalette[256]; +extern thread_local uint8_t gOtherPalette[256]; extern uint8_t text_palette[]; extern const translucent_window_palette TranslucentWindowPalettes[COLOUR_COUNT]; From a0e7752f260fdc4caff1183189df31f7a0658163 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=B6eh=20Matt?= <5415177+ZehMatt@users.noreply.github.com> Date: Wed, 6 Oct 2021 23:37:02 +0300 Subject: [PATCH 12/19] Pass rct_drawpixelinfo explicit to avoid races --- src/openrct2-ui/UiContext.cpp | 24 +-- .../engines/opengl/OpenGLDrawingEngine.cpp | 165 ++++++++++-------- src/openrct2/drawing/Drawing.String.cpp | 4 +- src/openrct2/drawing/IDrawingContext.h | 24 ++- src/openrct2/drawing/IDrawingEngine.h | 8 +- src/openrct2/drawing/NewDrawing.cpp | 36 ++-- src/openrct2/drawing/Weather.cpp | 48 ++--- src/openrct2/drawing/X8DrawingEngine.cpp | 66 +++---- src/openrct2/drawing/X8DrawingEngine.h | 34 ++-- src/openrct2/ui/UiContext.h | 3 +- 10 files changed, 214 insertions(+), 198 deletions(-) diff --git a/src/openrct2-ui/UiContext.cpp b/src/openrct2-ui/UiContext.cpp index 9031f447a1..b327da2183 100644 --- a/src/openrct2-ui/UiContext.cpp +++ b/src/openrct2-ui/UiContext.cpp @@ -296,7 +296,7 @@ public: for (auto& w : g_window_list) { - DrawWeatherWindow(weatherDrawer, w.get(), left, right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, w.get(), left, right, top, bottom, drawFunc); } } @@ -860,8 +860,8 @@ private: } static void DrawWeatherWindow( - IWeatherDrawer* weatherDrawer, rct_window* original_w, int16_t left, int16_t right, int16_t top, int16_t bottom, - DrawWeatherFunc drawFunc) + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, rct_window* original_w, int16_t left, int16_t right, int16_t top, + int16_t bottom, DrawWeatherFunc drawFunc) { rct_window* w{}; auto itStart = window_get_iterator(original_w); @@ -881,7 +881,7 @@ private: { auto width = right - left; auto height = bottom - top; - drawFunc(weatherDrawer, left, top, width, height); + drawFunc(dpi, weatherDrawer, left, top, width, height); } } return; @@ -903,39 +903,39 @@ private: break; } - DrawWeatherWindow(weatherDrawer, original_w, left, w->windowPos.x, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, w->windowPos.x, top, bottom, drawFunc); left = w->windowPos.x; - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, bottom, drawFunc); return; } int16_t w_right = RCT_WINDOW_RIGHT(w); if (right > w_right) { - DrawWeatherWindow(weatherDrawer, original_w, left, w_right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, w_right, top, bottom, drawFunc); left = w_right; - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, bottom, drawFunc); return; } if (top < w->windowPos.y) { - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, w->windowPos.y, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, w->windowPos.y, drawFunc); top = w->windowPos.y; - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, bottom, drawFunc); return; } int16_t w_bottom = RCT_WINDOW_BOTTOM(w); if (bottom > w_bottom) { - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, w_bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, w_bottom, drawFunc); top = w_bottom; - DrawWeatherWindow(weatherDrawer, original_w, left, right, top, bottom, drawFunc); + DrawWeatherWindow(dpi, weatherDrawer, original_w, left, right, top, bottom, drawFunc); return; } } diff --git a/src/openrct2-ui/drawing/engines/opengl/OpenGLDrawingEngine.cpp b/src/openrct2-ui/drawing/engines/opengl/OpenGLDrawingEngine.cpp index ad808f966f..9216d261d8 100644 --- a/src/openrct2-ui/drawing/engines/opengl/OpenGLDrawingEngine.cpp +++ b/src/openrct2-ui/drawing/engines/opengl/OpenGLDrawingEngine.cpp @@ -57,7 +57,6 @@ class OpenGLDrawingContext final : public IDrawingContext { private: OpenGLDrawingEngine* _engine = nullptr; - rct_drawpixelinfo* _dpi = nullptr; ApplyTransparencyShader* _applyTransparencyShader = nullptr; DrawLineShader* _drawLineShader = nullptr; DrawRectShader* _drawRectShader = nullptr; @@ -101,27 +100,25 @@ public: void ResetPalette(); void StartNewDraw(); - void Clear(uint8_t paletteIndex) override; - void FillRect(uint32_t colour, int32_t x, int32_t y, int32_t w, int32_t h) override; - void FilterRect(FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) override; - void DrawLine(uint32_t colour, const ScreenLine& line) override; - void DrawSprite(uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) override; - void DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) override; - void DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uint8_t colour) override; - void DrawGlyph(uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) override; - void DrawBitmap(uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, int32_t y) override; + void Clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) override; + void FillRect(rct_drawpixelinfo* dpi, uint32_t colour, int32_t x, int32_t y, int32_t w, int32_t h) override; + void FilterRect( + rct_drawpixelinfo* dpi, FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) override; + void DrawLine(rct_drawpixelinfo* dpi, uint32_t colour, const ScreenLine& line) override; + void DrawSprite(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) override; + void DrawSpriteRawMasked(rct_drawpixelinfo* dpi, int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) override; + void DrawSpriteSolid(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint8_t colour) override; + void DrawGlyph(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) override; + void DrawBitmap( + rct_drawpixelinfo* dpi, uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, + int32_t y) override; void FlushCommandBuffers(); void FlushLines(); void FlushRectangles(); void HandleTransparency(); - - void SetDPI(rct_drawpixelinfo* dpi); - rct_drawpixelinfo* GetDPI() const - { - return _dpi; - } + void CalculcateClipping(rct_drawpixelinfo* dpi); }; class OpenGLWeatherDrawer final : public IWeatherDrawer @@ -135,7 +132,7 @@ public: } virtual void Draw( - int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, + rct_drawpixelinfo* dpi, int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, const uint8_t* weatherpattern) override { const uint8_t* pattern = weatherpattern; @@ -145,8 +142,6 @@ public: uint8_t patternStartXOffset = xStart % patternXSpace; uint8_t patternStartYOffset = yStart % patternYSpace; - const auto* dpi = _drawingContext->GetDPI(); - uint32_t pixelOffset = (dpi->pitch + dpi->width) * y + x; uint8_t patternYPos = patternStartYOffset % patternYSpace; @@ -166,7 +161,7 @@ public: int32_t pixelX = xPixelOffset % dpi->width; int32_t pixelY = (xPixelOffset / dpi->width) % dpi->height; - _drawingContext->DrawLine(patternPixel, { { pixelX, pixelY }, { pixelX + 1, pixelY + 1 } }); + _drawingContext->DrawLine(dpi, patternPixel, { { pixelX, pixelY }, { pixelX + 1, pixelY + 1 } }); } } @@ -298,6 +293,7 @@ public: assert(_screenFramebuffer != nullptr); _drawingContext->StartNewDraw(); + _drawingContext->CalculcateClipping(&_bitsDPI); } void EndDraw() override @@ -335,13 +331,16 @@ public: void PaintWindows() override { + _drawingContext->CalculcateClipping(&_bitsDPI); + window_update_all_viewports(); window_draw_all(&_bitsDPI, 0, 0, _width, _height); } void PaintWeather() override { - _drawingContext->SetDPI(&_bitsDPI); + _drawingContext->CalculcateClipping(&_bitsDPI); + DrawWeather(&_bitsDPI, &_weatherDrawer); } @@ -359,9 +358,8 @@ public: // Not applicable for this engine } - IDrawingContext* GetDrawingContext(rct_drawpixelinfo* dpi) override + IDrawingContext* GetDrawingContext() override { - _drawingContext->SetDPI(dpi); return _drawingContext; } @@ -541,13 +539,18 @@ void OpenGLDrawingContext::StartNewDraw() _swapFramebuffer->Clear(); } -void OpenGLDrawingContext::Clear(uint8_t paletteIndex) +void OpenGLDrawingContext::Clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) { - FillRect(paletteIndex, _clipLeft - _offsetX, _clipTop - _offsetY, _clipRight - _offsetX, _clipBottom - _offsetY); + CalculcateClipping(dpi); + + FillRect(dpi, paletteIndex, _clipLeft - _offsetX, _clipTop - _offsetY, _clipRight - _offsetX, _clipBottom - _offsetY); } -void OpenGLDrawingContext::FillRect(uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) +void OpenGLDrawingContext::FillRect( + rct_drawpixelinfo* dpi, uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) { + CalculcateClipping(dpi); + left += _offsetX; top += _offsetY; right += _offsetX; @@ -578,8 +581,11 @@ void OpenGLDrawingContext::FillRect(uint32_t colour, int32_t left, int32_t top, } } -void OpenGLDrawingContext::FilterRect(FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) +void OpenGLDrawingContext::FilterRect( + rct_drawpixelinfo* dpi, FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) { + CalculcateClipping(dpi); + left += _offsetX; top += _offsetY; right += _offsetX; @@ -599,8 +605,10 @@ void OpenGLDrawingContext::FilterRect(FilterPaletteID palette, int32_t left, int command.depth = _drawCount++; } -void OpenGLDrawingContext::DrawLine(uint32_t colour, const ScreenLine& line) +void OpenGLDrawingContext::DrawLine(rct_drawpixelinfo* dpi, uint32_t colour, const ScreenLine& line) { + CalculcateClipping(dpi); + DrawLineCommand& command = _commandBuffers.lines.allocate(); command.clip = { _clipLeft, _clipTop, _clipRight, _clipBottom }; @@ -609,8 +617,10 @@ void OpenGLDrawingContext::DrawLine(uint32_t colour, const ScreenLine& line) command.depth = _drawCount++; } -void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) +void OpenGLDrawingContext::DrawSprite(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) { + CalculcateClipping(dpi); + int32_t g1Id = image & 0x7FFFF; auto g1Element = gfx_get_g1_element(g1Id); if (g1Element == nullptr) @@ -618,20 +628,19 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint return; } - if (_dpi->zoom_level > 0) + if (dpi->zoom_level > 0) { if (g1Element->flags & G1_FLAG_HAS_ZOOM_SPRITE) { rct_drawpixelinfo zoomedDPI; - zoomedDPI.bits = _dpi->bits; - zoomedDPI.x = _dpi->x >> 1; - zoomedDPI.y = _dpi->y >> 1; - zoomedDPI.height = _dpi->height >> 1; - zoomedDPI.width = _dpi->width >> 1; - zoomedDPI.pitch = _dpi->pitch; - zoomedDPI.zoom_level = _dpi->zoom_level - 1; - SetDPI(&zoomedDPI); - DrawSprite((image & 0xFFF80000) | (g1Id - g1Element->zoomed_offset), x >> 1, y >> 1, tertiaryColour); + zoomedDPI.bits = dpi->bits; + zoomedDPI.x = dpi->x >> 1; + zoomedDPI.y = dpi->y >> 1; + zoomedDPI.height = dpi->height >> 1; + zoomedDPI.width = dpi->width >> 1; + zoomedDPI.pitch = dpi->pitch; + zoomedDPI.zoom_level = dpi->zoom_level - 1; + DrawSprite(&zoomedDPI, (image & 0xFFF80000) | (g1Id - g1Element->zoomed_offset), x >> 1, y >> 1, tertiaryColour); return; } if (g1Element->flags & G1_FLAG_NO_ZOOM_DRAW) @@ -644,11 +653,11 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint int32_t top = y + g1Element->y_offset; int32_t zoom_mask; - if (_dpi->zoom_level >= 0) - zoom_mask = 0xFFFFFFFF * _dpi->zoom_level; + if (dpi->zoom_level >= 0) + zoom_mask = 0xFFFFFFFF * dpi->zoom_level; else zoom_mask = 0xFFFFFFFF; - if (_dpi->zoom_level != 0 && (g1Element->flags & G1_FLAG_RLE_COMPRESSION)) + if (dpi->zoom_level != 0 && (g1Element->flags & G1_FLAG_RLE_COMPRESSION)) { top -= ~zoom_mask; } @@ -664,7 +673,7 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint int32_t right = left + g1Element->width; int32_t bottom = top + g1Element->height; - if (_dpi->zoom_level != 0 && (g1Element->flags & G1_FLAG_RLE_COMPRESSION)) + if (dpi->zoom_level != 0 && (g1Element->flags & G1_FLAG_RLE_COMPRESSION)) { bottom += top & ~zoom_mask; } @@ -678,15 +687,15 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint std::swap(top, bottom); } - left -= _dpi->x; - top -= _dpi->y; - right -= _dpi->x; - bottom -= _dpi->y; + left -= dpi->x; + top -= dpi->y; + right -= dpi->x; + bottom -= dpi->y; - left = left / _dpi->zoom_level; - top = top / _dpi->zoom_level; - right = right / _dpi->zoom_level; - bottom = bottom / _dpi->zoom_level; + left = left / dpi->zoom_level; + top = top / dpi->zoom_level; + right = right / dpi->zoom_level; + bottom = bottom / dpi->zoom_level; left += _spriteOffset.x; top += _spriteOffset.y; @@ -759,8 +768,11 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint } } -void OpenGLDrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) +void OpenGLDrawingContext::DrawSpriteRawMasked( + rct_drawpixelinfo* dpi, int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) { + CalculcateClipping(dpi); + auto g1ElementMask = gfx_get_g1_element(maskImage & 0x7FFFF); auto g1ElementColour = gfx_get_g1_element(colourImage & 0x7FFFF); if (g1ElementMask == nullptr || g1ElementColour == nullptr) @@ -790,15 +802,15 @@ void OpenGLDrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t ma std::swap(top, bottom); } - left -= _dpi->x; - top -= _dpi->y; - right -= _dpi->x; - bottom -= _dpi->y; + left -= dpi->x; + top -= dpi->y; + right -= dpi->x; + bottom -= dpi->y; - left = left / _dpi->zoom_level; - top = top / _dpi->zoom_level; - right = right / _dpi->zoom_level; - bottom = bottom / _dpi->zoom_level; + left = left / dpi->zoom_level; + top = top / dpi->zoom_level; + right = right / dpi->zoom_level; + bottom = bottom / dpi->zoom_level; left += _spriteOffset.x; top += _spriteOffset.y; @@ -819,8 +831,10 @@ void OpenGLDrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t ma command.depth = _drawCount++; } -void OpenGLDrawingContext::DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uint8_t colour) +void OpenGLDrawingContext::DrawSpriteSolid(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint8_t colour) { + CalculcateClipping(dpi); + assert((colour & 0xFF) > 0u); int32_t g1Id = image & 0x7FFFF; @@ -870,8 +884,10 @@ void OpenGLDrawingContext::DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, command.depth = _drawCount++; } -void OpenGLDrawingContext::DrawGlyph(uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) +void OpenGLDrawingContext::DrawGlyph(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) { + CalculcateClipping(dpi); + auto g1Element = gfx_get_g1_element(image & 0x7FFFF); if (g1Element == nullptr) { @@ -894,15 +910,15 @@ void OpenGLDrawingContext::DrawGlyph(uint32_t image, int32_t x, int32_t y, const std::swap(top, bottom); } - left -= _dpi->x; - top -= _dpi->y; - right -= _dpi->x; - bottom -= _dpi->y; + left -= dpi->x; + top -= dpi->y; + right -= dpi->x; + bottom -= dpi->y; - left = left / _dpi->zoom_level; - top = top / _dpi->zoom_level; - right = right / _dpi->zoom_level; - bottom = bottom / _dpi->zoom_level; + left = left / dpi->zoom_level; + top = top / dpi->zoom_level; + right = right / dpi->zoom_level; + bottom = bottom / dpi->zoom_level; left += _spriteOffset.x; top += _spriteOffset.y; @@ -923,8 +939,11 @@ void OpenGLDrawingContext::DrawGlyph(uint32_t image, int32_t x, int32_t y, const command.depth = _drawCount++; } -void OpenGLDrawingContext::DrawBitmap(uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, int32_t y) +void OpenGLDrawingContext::DrawBitmap( + rct_drawpixelinfo* dpi, uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, int32_t y) { + CalculcateClipping(dpi); + const auto texture = _textureCache->GetOrLoadBitmapTexture(image, pixels, width, height); int32_t drawOffsetX = 0; @@ -1041,7 +1060,7 @@ void OpenGLDrawingContext::HandleTransparency() _commandBuffers.transparent.clear(); } -void OpenGLDrawingContext::SetDPI(rct_drawpixelinfo* dpi) +void OpenGLDrawingContext::CalculcateClipping(rct_drawpixelinfo* dpi) { auto screenDPI = _engine->GetDPI(); auto bytesPerRow = screenDPI->GetBytesPerRow(); @@ -1059,8 +1078,6 @@ void OpenGLDrawingContext::SetDPI(rct_drawpixelinfo* dpi) _offsetY = _clipTop - dpi->y; _spriteOffset.x = _clipLeft - dpi->remX; _spriteOffset.y = _clipTop - dpi->remY; - - _dpi = dpi; } #endif /* DISABLE_OPENGL */ diff --git a/src/openrct2/drawing/Drawing.String.cpp b/src/openrct2/drawing/Drawing.String.cpp index e6f1df2dde..4450706156 100644 --- a/src/openrct2/drawing/Drawing.String.cpp +++ b/src/openrct2/drawing/Drawing.String.cpp @@ -578,9 +578,9 @@ static void ttf_draw_string_raw_ttf(rct_drawpixelinfo* dpi, std::string_view tex auto baseId = uint32_t(0x7FFFF) - 1024; auto imageId = baseId + _ttfGlId; auto drawingEngine = dpi->DrawingEngine; - auto drawingContext = drawingEngine->GetDrawingContext(dpi); + auto drawingContext = drawingEngine->GetDrawingContext(); drawingEngine->InvalidateImage(imageId); - drawingContext->DrawBitmap(imageId, surface->pixels, surface->pitch, surface->h, drawX, drawY); + drawingContext->DrawBitmap(dpi, imageId, surface->pixels, surface->pitch, surface->h, drawX, drawY); _ttfGlId++; if (_ttfGlId >= 1023) diff --git a/src/openrct2/drawing/IDrawingContext.h b/src/openrct2/drawing/IDrawingContext.h index e8fbadc702..adff81a6d6 100644 --- a/src/openrct2/drawing/IDrawingContext.h +++ b/src/openrct2/drawing/IDrawingContext.h @@ -21,15 +21,21 @@ namespace OpenRCT2::Drawing virtual ~IDrawingContext() = default; virtual OpenRCT2::Drawing::IDrawingEngine* GetEngine() abstract; - virtual void Clear(uint8_t paletteIndex) abstract; - virtual void FillRect(uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) abstract; - virtual void FilterRect(FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) abstract; - virtual void DrawLine(uint32_t colour, const ScreenLine& line) abstract; - virtual void DrawSprite(uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) abstract; - virtual void DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) abstract; - virtual void DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uint8_t colour) abstract; - virtual void DrawGlyph(uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) abstract; + virtual void Clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) abstract; + virtual void FillRect( + rct_drawpixelinfo* dpi, uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) abstract; + virtual void FilterRect( + rct_drawpixelinfo* dpi, FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) abstract; + virtual void DrawLine(rct_drawpixelinfo* dpi, uint32_t colour, const ScreenLine& line) abstract; + virtual void DrawSprite(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) abstract; + virtual void DrawSpriteRawMasked( + rct_drawpixelinfo* dpi, int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) abstract; + virtual void DrawSpriteSolid(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint8_t colour) abstract; + virtual void DrawGlyph( + rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, const PaletteMap& palette) abstract; virtual void DrawBitmap( - uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, int32_t y) abstract; + rct_drawpixelinfo* dpi, uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, + int32_t y) abstract; }; + } // namespace OpenRCT2::Drawing diff --git a/src/openrct2/drawing/IDrawingEngine.h b/src/openrct2/drawing/IDrawingEngine.h index 92e5e8b783..76552da80b 100644 --- a/src/openrct2/drawing/IDrawingEngine.h +++ b/src/openrct2/drawing/IDrawingEngine.h @@ -71,7 +71,7 @@ namespace OpenRCT2::Drawing virtual void CopyRect(int32_t x, int32_t y, int32_t width, int32_t height, int32_t dx, int32_t dy) abstract; virtual std::string Screenshot() abstract; - virtual IDrawingContext* GetDrawingContext(rct_drawpixelinfo* dpi) abstract; + virtual IDrawingContext* GetDrawingContext() abstract; virtual rct_drawpixelinfo* GetDrawingPixelInfo() abstract; virtual DRAWING_ENGINE_FLAGS GetFlags() abstract; @@ -90,11 +90,9 @@ namespace OpenRCT2::Drawing struct IWeatherDrawer { - virtual ~IWeatherDrawer() - { - } + virtual ~IWeatherDrawer() = default; virtual void Draw( - int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, + rct_drawpixelinfo* dpi, int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, const uint8_t* weatherpattern) abstract; }; } // namespace OpenRCT2::Drawing diff --git a/src/openrct2/drawing/NewDrawing.cpp b/src/openrct2/drawing/NewDrawing.cpp index c1eb196933..ed5f8c4aee 100644 --- a/src/openrct2/drawing/NewDrawing.cpp +++ b/src/openrct2/drawing/NewDrawing.cpp @@ -165,8 +165,8 @@ void gfx_clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->Clear(paletteIndex); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->Clear(dpi, paletteIndex); } } @@ -175,8 +175,8 @@ void gfx_fill_rect(rct_drawpixelinfo* dpi, const ScreenRect& rect, int32_t colou auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->FillRect(colour, rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom()); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->FillRect(dpi, colour, rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom()); } } @@ -190,8 +190,8 @@ void gfx_filter_rect(rct_drawpixelinfo* dpi, const ScreenRect& rect, FilterPalet auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->FilterRect(palette, rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom()); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->FilterRect(dpi, palette, rect.GetLeft(), rect.GetTop(), rect.GetRight(), rect.GetBottom()); } } @@ -200,8 +200,8 @@ void gfx_draw_line(rct_drawpixelinfo* dpi, const ScreenLine& line, int32_t colou auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->DrawLine(colour, line); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->DrawLine(dpi, colour, line); } } @@ -227,13 +227,13 @@ void gfx_draw_dashed_line( const int32_t lineYDist = std::abs(screenLine.GetY2() - screenLine.GetY1()); const int32_t dxPrecise = precisionFactor * lineXDist / lineSegmentCount / 2; const int32_t dyPrecise = precisionFactor * lineYDist / lineSegmentCount / 2; - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); for (int32_t i = 0, x, y; i < lineSegmentCount; ++i) { x = screenLine.GetX1() + dxPrecise * i * 2 / precisionFactor; y = screenLine.GetY1() + dyPrecise * i * 2 / precisionFactor; - dc->DrawLine(color, { { x, y }, { x + dxPrecise / precisionFactor, y + dyPrecise / precisionFactor } }); + dc->DrawLine(dpi, color, { { x, y }, { x + dxPrecise / precisionFactor, y + dyPrecise / precisionFactor } }); } } } @@ -248,8 +248,8 @@ void FASTCALL gfx_draw_sprite(rct_drawpixelinfo* dpi, int32_t image, const Scree auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->DrawSprite(image, coords.x, coords.y, tertiary_colour); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->DrawSprite(dpi, image, coords.x, coords.y, tertiary_colour); } } @@ -258,8 +258,8 @@ void FASTCALL gfx_draw_glyph(rct_drawpixelinfo* dpi, int32_t image, const Screen auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->DrawGlyph(image, coords.x, coords.y, paletteMap); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->DrawGlyph(dpi, image, coords.x, coords.y, paletteMap); } } @@ -269,8 +269,8 @@ void FASTCALL auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->DrawSpriteRawMasked(coords.x, coords.y, maskImage, colourImage); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->DrawSpriteRawMasked(dpi, coords.x, coords.y, maskImage, colourImage); } } @@ -279,8 +279,8 @@ void FASTCALL gfx_draw_sprite_solid(rct_drawpixelinfo* dpi, int32_t image, const auto drawingEngine = dpi->DrawingEngine; if (drawingEngine != nullptr) { - IDrawingContext* dc = drawingEngine->GetDrawingContext(dpi); - dc->DrawSpriteSolid(image, coords.x, coords.y, colour); + IDrawingContext* dc = drawingEngine->GetDrawingContext(); + dc->DrawSpriteSolid(dpi, image, coords.x, coords.y, colour); } } diff --git a/src/openrct2/drawing/Weather.cpp b/src/openrct2/drawing/Weather.cpp index ae9a116ef3..c47794ef00 100644 --- a/src/openrct2/drawing/Weather.cpp +++ b/src/openrct2/drawing/Weather.cpp @@ -22,10 +22,14 @@ using namespace OpenRCT2; using namespace OpenRCT2::Drawing; -static void DrawLightRain(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); -static void DrawHeavyRain(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); -static void DrawLightSnow(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); -static void DrawHeavySnow(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); +static void DrawLightRain( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); +static void DrawHeavyRain( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); +static void DrawLightSnow( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); +static void DrawHeavySnow( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); /** * @@ -76,59 +80,62 @@ void DrawWeather(rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer) * * rct2: 0x00684114 */ -static void DrawLightRain(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) +static void DrawLightRain( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) { int32_t x_start = -static_cast(gCurrentTicks) + 8; int32_t y_start = (gCurrentTicks * 3) + 7; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); x_start = -static_cast(gCurrentTicks) + 0x18; y_start = (gCurrentTicks * 4) + 0x0D; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); } /** * * rct2: 0x0068416D */ -static void DrawHeavyRain(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) +static void DrawHeavyRain( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) { int32_t x_start = -static_cast(gCurrentTicks); int32_t y_start = gCurrentTicks * 5; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); x_start = -static_cast(gCurrentTicks) + 0x10; y_start = (gCurrentTicks * 6) + 5; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); x_start = -static_cast(gCurrentTicks) + 8; y_start = (gCurrentTicks * 3) + 7; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); x_start = -static_cast(gCurrentTicks) + 0x18; y_start = (gCurrentTicks * 4) + 0x0D; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, RainPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, RainPattern); } -static void DrawLightSnow(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) +static void DrawLightSnow( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) { const uint32_t t = gCurrentTicks / 2; const int32_t negT = -static_cast(t); @@ -139,43 +146,44 @@ static void DrawLightSnow(IWeatherDrawer* weatherDrawer, int32_t left, int32_t t y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); x_start = negT + 16 + (cos(cosTick) * 6); y_start = t + 16; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); } -static void DrawHeavySnow(IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) +static void DrawHeavySnow( + rct_drawpixelinfo* dpi, IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height) { int32_t x_start = -static_cast(gCurrentTicks * 3) + 1; int32_t y_start = gCurrentTicks + 23; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); x_start = -static_cast(gCurrentTicks * 4) + 6; y_start = gCurrentTicks + 5; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); x_start = -static_cast(gCurrentTicks * 2) + 11; y_start = gCurrentTicks + 18; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); x_start = -static_cast(gCurrentTicks * 3) + 17; y_start = gCurrentTicks + 11; y_start = -y_start; x_start += left; y_start += top; - weatherDrawer->Draw(left, top, width, height, x_start, y_start, SnowPattern); + weatherDrawer->Draw(dpi, left, top, width, height, x_start, y_start, SnowPattern); } diff --git a/src/openrct2/drawing/X8DrawingEngine.cpp b/src/openrct2/drawing/X8DrawingEngine.cpp index ddaa2d381f..cb6581836f 100644 --- a/src/openrct2/drawing/X8DrawingEngine.cpp +++ b/src/openrct2/drawing/X8DrawingEngine.cpp @@ -43,13 +43,9 @@ X8WeatherDrawer::~X8WeatherDrawer() delete[] _weatherPixels; } -void X8WeatherDrawer::SetDPI(rct_drawpixelinfo* dpi) -{ - _screenDPI = dpi; -} - void X8WeatherDrawer::Draw( - int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, const uint8_t* weatherpattern) + rct_drawpixelinfo* dpi, int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, + const uint8_t* weatherpattern) { const uint8_t* pattern = weatherpattern; auto patternXSpace = *pattern++; @@ -58,10 +54,10 @@ void X8WeatherDrawer::Draw( uint8_t patternStartXOffset = xStart % patternXSpace; uint8_t patternStartYOffset = yStart % patternYSpace; - uint32_t pixelOffset = (_screenDPI->pitch + _screenDPI->width) * y + x; + uint32_t pixelOffset = (dpi->pitch + dpi->width) * y + x; uint8_t patternYPos = patternStartYOffset % patternYSpace; - uint8_t* screenBits = _screenDPI->bits; + uint8_t* screenBits = dpi->bits; // Stores the colours of changed pixels WeatherPixel* newPixels = &_weatherPixels[_weatherPixelsCount]; @@ -90,18 +86,18 @@ void X8WeatherDrawer::Draw( } } - pixelOffset += _screenDPI->pitch + _screenDPI->width; + pixelOffset += dpi->pitch + dpi->width; patternYPos++; patternYPos %= patternYSpace; } } -void X8WeatherDrawer::Restore() +void X8WeatherDrawer::Restore(rct_drawpixelinfo* dpi) { if (_weatherPixelsCount > 0) { - uint32_t numPixels = (_screenDPI->width + _screenDPI->pitch) * _screenDPI->height; - uint8_t* bits = _screenDPI->bits; + uint32_t numPixels = (dpi->width + dpi->pitch) * dpi->height; + uint8_t* bits = dpi->bits; for (uint32_t i = 0; i < _weatherPixelsCount; i++) { WeatherPixel weatherPixel = _weatherPixels[i]; @@ -201,8 +197,7 @@ void X8DrawingEngine::BeginDraw() Resize(_width, _height); } #endif - _weatherDrawer.SetDPI(&_bitsDPI); - _weatherDrawer.Restore(); + _weatherDrawer.Restore(&_bitsDPI); } } @@ -271,9 +266,8 @@ std::string X8DrawingEngine::Screenshot() return screenshot_dump_png(&_bitsDPI); } -IDrawingContext* X8DrawingEngine::GetDrawingContext(rct_drawpixelinfo* dpi) +IDrawingContext* X8DrawingEngine::GetDrawingContext() { - _drawingContext->SetDPI(dpi); return _drawingContext; } @@ -466,10 +460,8 @@ IDrawingEngine* X8DrawingContext::GetEngine() return _engine; } -void X8DrawingContext::Clear(uint8_t paletteIndex) +void X8DrawingContext::Clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) { - rct_drawpixelinfo* dpi = _dpi; - int32_t w = dpi->width / dpi->zoom_level; int32_t h = dpi->height / dpi->zoom_level; uint8_t* ptr = dpi->bits; @@ -529,10 +521,9 @@ static constexpr const uint16_t * Patterns[] = { }; // clang-format on -void X8DrawingContext::FillRect(uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) +void X8DrawingContext::FillRect( + rct_drawpixelinfo* dpi, uint32_t colour, int32_t left, int32_t top, int32_t right, int32_t bottom) { - rct_drawpixelinfo* dpi = _dpi; - if (left > right) return; if (top > bottom) @@ -650,10 +641,9 @@ void X8DrawingContext::FillRect(uint32_t colour, int32_t left, int32_t top, int3 } } -void X8DrawingContext::FilterRect(FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) +void X8DrawingContext::FilterRect( + rct_drawpixelinfo* dpi, FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) { - rct_drawpixelinfo* dpi = _dpi; - if (left > right) return; if (top > bottom) @@ -723,22 +713,23 @@ void X8DrawingContext::FilterRect(FilterPaletteID palette, int32_t left, int32_t } } -void X8DrawingContext::DrawLine(uint32_t colour, const ScreenLine& line) +void X8DrawingContext::DrawLine(rct_drawpixelinfo* dpi, uint32_t colour, const ScreenLine& line) { - gfx_draw_line_software(_dpi, line, colour); + gfx_draw_line_software(dpi, line, colour); } -void X8DrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) +void X8DrawingContext::DrawSprite(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) { - gfx_draw_sprite_software(_dpi, ImageId::FromUInt32(image, tertiaryColour), { x, y }); + gfx_draw_sprite_software(dpi, ImageId::FromUInt32(image, tertiaryColour), { x, y }); } -void X8DrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) +void X8DrawingContext::DrawSpriteRawMasked( + rct_drawpixelinfo* dpi, int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) { - gfx_draw_sprite_raw_masked_software(_dpi, { x, y }, maskImage, colourImage); + gfx_draw_sprite_raw_masked_software(dpi, { x, y }, maskImage, colourImage); } -void X8DrawingContext::DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uint8_t colour) +void X8DrawingContext::DrawSpriteSolid(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint8_t colour) { uint8_t palette[256]; std::fill_n(palette, sizeof(palette), colour); @@ -746,15 +737,10 @@ void X8DrawingContext::DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uin const auto spriteCoords = ScreenCoordsXY{ x, y }; gfx_draw_sprite_palette_set_software( - _dpi, ImageId::FromUInt32((image & 0x7FFFF) | IMAGE_TYPE_REMAP), spriteCoords, PaletteMap(palette)); + dpi, ImageId::FromUInt32((image & 0x7FFFF) | IMAGE_TYPE_REMAP), spriteCoords, PaletteMap(palette)); } -void X8DrawingContext::DrawGlyph(uint32_t image, int32_t x, int32_t y, const PaletteMap& paletteMap) +void X8DrawingContext::DrawGlyph(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, const PaletteMap& paletteMap) { - gfx_draw_sprite_palette_set_software(_dpi, ImageId::FromUInt32(image), { x, y }, paletteMap); -} - -void X8DrawingContext::SetDPI(rct_drawpixelinfo* dpi) -{ - _dpi = dpi; + gfx_draw_sprite_palette_set_software(dpi, ImageId::FromUInt32(image), { x, y }, paletteMap); } diff --git a/src/openrct2/drawing/X8DrawingEngine.h b/src/openrct2/drawing/X8DrawingEngine.h index b655cac749..d97f1a34ec 100644 --- a/src/openrct2/drawing/X8DrawingEngine.h +++ b/src/openrct2/drawing/X8DrawingEngine.h @@ -49,16 +49,14 @@ namespace OpenRCT2 size_t _weatherPixelsCapacity = MaxWeatherPixels; uint32_t _weatherPixelsCount = 0; WeatherPixel* _weatherPixels = nullptr; - rct_drawpixelinfo* _screenDPI = nullptr; public: X8WeatherDrawer(); ~X8WeatherDrawer(); - void SetDPI(rct_drawpixelinfo* dpi); void Draw( - int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, + rct_drawpixelinfo* dpi, int32_t x, int32_t y, int32_t width, int32_t height, int32_t xStart, int32_t yStart, const uint8_t* weatherpattern) override; - void Restore(); + void Restore(rct_drawpixelinfo* dpi); }; #ifdef __WARN_SUGGEST_FINAL_TYPES__ @@ -109,7 +107,7 @@ namespace OpenRCT2 void PaintWeather() override; void CopyRect(int32_t x, int32_t y, int32_t width, int32_t height, int32_t dx, int32_t dy) override; std::string Screenshot() override; - IDrawingContext* GetDrawingContext(rct_drawpixelinfo* dpi) override; + IDrawingContext* GetDrawingContext() override; rct_drawpixelinfo* GetDrawingPixelInfo() override; DRAWING_ENGINE_FLAGS GetFlags() override; void InvalidateImage(uint32_t image) override; @@ -135,26 +133,28 @@ namespace OpenRCT2 { private: X8DrawingEngine* _engine = nullptr; - rct_drawpixelinfo* _dpi = nullptr; public: explicit X8DrawingContext(X8DrawingEngine* engine); IDrawingEngine* GetEngine() override; - void Clear(uint8_t paletteIndex) override; - void FillRect(uint32_t colour, int32_t x, int32_t y, int32_t w, int32_t h) override; - void FilterRect(FilterPaletteID palette, int32_t left, int32_t top, int32_t right, int32_t bottom) override; - void DrawLine(uint32_t colour, const ScreenLine& line) override; - void DrawSprite(uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) override; - void DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) override; - void DrawSpriteSolid(uint32_t image, int32_t x, int32_t y, uint8_t colour) override; - void DrawGlyph(uint32_t image, int32_t x, int32_t y, const PaletteMap& paletteMap) override; - void DrawBitmap(uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, int32_t y) override + void Clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex) override; + void FillRect(rct_drawpixelinfo* dpi, uint32_t colour, int32_t x, int32_t y, int32_t w, int32_t h) override; + void FilterRect( + rct_drawpixelinfo* dpi, FilterPaletteID palette, int32_t left, int32_t top, int32_t right, + int32_t bottom) override; + void DrawLine(rct_drawpixelinfo* dpi, uint32_t colour, const ScreenLine& line) override; + void DrawSprite(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint32_t tertiaryColour) override; + void DrawSpriteRawMasked( + rct_drawpixelinfo* dpi, int32_t x, int32_t y, uint32_t maskImage, uint32_t colourImage) override; + void DrawSpriteSolid(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, uint8_t colour) override; + void DrawGlyph(rct_drawpixelinfo* dpi, uint32_t image, int32_t x, int32_t y, const PaletteMap& paletteMap) override; + void DrawBitmap( + rct_drawpixelinfo* dpi, uint32_t image, const void* pixels, int32_t width, int32_t height, int32_t x, + int32_t y) override { } - - void SetDPI(rct_drawpixelinfo* dpi); }; } // namespace Drawing } // namespace OpenRCT2 diff --git a/src/openrct2/ui/UiContext.h b/src/openrct2/ui/UiContext.h index c2f38d56ac..8135b209aa 100644 --- a/src/openrct2/ui/UiContext.h +++ b/src/openrct2/ui/UiContext.h @@ -29,7 +29,8 @@ namespace OpenRCT2 struct IDrawingEngineFactory; struct IWeatherDrawer; using DrawWeatherFunc = void (*)( - OpenRCT2::Drawing::IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, int32_t height); + rct_drawpixelinfo* dpi, OpenRCT2::Drawing::IWeatherDrawer* weatherDrawer, int32_t left, int32_t top, int32_t width, + int32_t height); } // namespace Drawing namespace Ui From 9d57e93df99a626a25272cc5698ace7492130461 Mon Sep 17 00:00:00 2001 From: hjort96 Date: Thu, 7 Oct 2021 16:21:19 +0200 Subject: [PATCH 13/19] Add suggestions from review. --- src/openrct2-ui/windows/ViewClipping.cpp | 33 +++++++++++++----------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index 0f73b567c7..dab9964aca 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -41,7 +41,7 @@ enum class DISPLAY_TYPE { DISPLAY_UNITS }; -static DISPLAY_TYPE gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; +// static DISPLAY_TYPE gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; #pragma region Widgets @@ -73,6 +73,7 @@ private: CoordsXY _previousClipSelectionB; bool _toolActive{ false }; bool _dragging{ false }; + static inline DISPLAY_TYPE _clipHeightDisplayType; public: void OnCloseButton() @@ -82,8 +83,6 @@ public: void OnMouseUp(rct_widgetindex widgetIndex) override { - rct_window* mainWindow; - // mouseup appears to be used for buttons, checkboxes switch (widgetIndex) { @@ -91,8 +90,9 @@ public: window_close(this); break; case WIDX_CLIP_CHECKBOX_ENABLE: + { // Toggle height clipping. - mainWindow = window_get_main(); + rct_window* mainWindow = window_get_main(); if (mainWindow != nullptr) { mainWindow->viewport->flags ^= VIEWPORT_FLAG_CLIP_VIEW; @@ -100,15 +100,16 @@ public: } this->Invalidate(); break; + } case WIDX_CLIP_HEIGHT_VALUE: // Toggle display of the cut height value in RAW vs UNITS - if (gClipHeightDisplayType == DISPLAY_TYPE::DISPLAY_RAW) + if (_clipHeightDisplayType == DISPLAY_TYPE::DISPLAY_RAW) { - gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; + _clipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; } else { - gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_RAW; + _clipHeightDisplayType = DISPLAY_TYPE::DISPLAY_RAW; } this->Invalidate(); break; @@ -163,9 +164,9 @@ public: void OnUpdate() override { - const rct_widget* const widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + const auto& widget = widgets[WIDX_CLIP_HEIGHT_SLIDER]; const rct_scroll* const scroll = &this->scrolls[0]; - const int16_t scroll_width = widget->width() - 1; + const int16_t scroll_width = widget.width() - 1; const uint8_t clip_height = static_cast( (static_cast(scroll->h_left) / (scroll->h_right - scroll_width)) * 255); if (clip_height != gClipHeight) @@ -283,7 +284,7 @@ public: screenCoords = this->windowPos + ScreenCoordsXY{ this->widgets[WIDX_CLIP_HEIGHT_VALUE].left + 1, this->widgets[WIDX_CLIP_HEIGHT_VALUE].top }; - switch (gClipHeightDisplayType) + switch (_clipHeightDisplayType) { case DISPLAY_TYPE::DISPLAY_RAW: default: @@ -298,7 +299,7 @@ public: case DISPLAY_TYPE::DISPLAY_UNITS: { // Print the value in the configured height label type: - if (gConfigGeneral.show_height_as_units == 1) + if (gConfigGeneral.show_height_as_units) { // Height label is Units. auto ft = Formatter(); @@ -350,6 +351,8 @@ public: this->hold_down_widgets = (1ULL << WIDX_CLIP_HEIGHT_INCREASE) | (1UL << WIDX_CLIP_HEIGHT_DECREASE); WindowInitScrollWidgets(this); + _clipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; + // Initialise the clip height slider from the current clip height value. this->SetClipHeight(gClipHeight); @@ -378,13 +381,13 @@ private: } } - void SetClipHeight(const uint8_t clipheight) + void SetClipHeight(const uint8_t clipHeight) { - gClipHeight = clipheight; - rct_widget* widget = &window_view_clipping_widgets[WIDX_CLIP_HEIGHT_SLIDER]; + gClipHeight = clipHeight; + const auto& widget = widgets[WIDX_CLIP_HEIGHT_SLIDER]; const float clip_height_ratio = static_cast(gClipHeight) / 255; this->scrolls[0].h_left = static_cast( - std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget->width() - 1)))); + std::ceil(clip_height_ratio * (this->scrolls[0].h_right - (widget.width() - 1)))); } bool IsActive() From dba34d2c17fb69013921a01644ce3e47745616fb Mon Sep 17 00:00:00 2001 From: hjort96 Date: Thu, 7 Oct 2021 22:38:12 +0200 Subject: [PATCH 14/19] Removed a line --- src/openrct2-ui/windows/ViewClipping.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/openrct2-ui/windows/ViewClipping.cpp b/src/openrct2-ui/windows/ViewClipping.cpp index dab9964aca..296dc786ac 100644 --- a/src/openrct2-ui/windows/ViewClipping.cpp +++ b/src/openrct2-ui/windows/ViewClipping.cpp @@ -41,8 +41,6 @@ enum class DISPLAY_TYPE { DISPLAY_UNITS }; -// static DISPLAY_TYPE gClipHeightDisplayType = DISPLAY_TYPE::DISPLAY_UNITS; - #pragma region Widgets static constexpr const rct_string_id WINDOW_TITLE = STR_VIEW_CLIPPING_TITLE; From 5f874f15c758d96d6bacd8a099b3ce20b81e2a0a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=B6eh=20Matt?= <5415177+ZehMatt@users.noreply.github.com> Date: Fri, 8 Oct 2021 01:02:45 +0300 Subject: [PATCH 15/19] Update changelog.txt --- distribution/changelog.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/distribution/changelog.txt b/distribution/changelog.txt index ad73c74f33..affec10920 100644 --- a/distribution/changelog.txt +++ b/distribution/changelog.txt @@ -32,6 +32,7 @@ - Fix: [#15496] Crash in paint_swinging_inverter_ship_structure(). - Fix: [#15514] Two different “quit to menu” menu items are available in track designer and track design manager. - Improved: [#3417] Crash dumps are now placed in their own folder. +- Improved: [#15538] Software rendering can now draw in parallel when Multithreading is enabled. - Change: [#8601] Revert ToonTower base block fix to re-enable support blocking. - Change: [#15174] [Plugin] Deprecate the type "peep" and add support to target a specific scripting api version. From 7787bb46e0561dff2aa9ae7b248ffaef81088d8c Mon Sep 17 00:00:00 2001 From: Gaven Rendell Date: Fri, 2 Apr 2021 13:40:01 -0400 Subject: [PATCH 16/19] Handle mod key edge-cases in tiling WMs This commit ignores keypresses when the mod key is held. The reasoning is that an odd interaction happens between SDL applications and tiling window managers. Tiling window managers like Xmonad and i3 usually use the mod ("windows") key and a number to change workspaces. When changing workspaces, however, the WMs still send the number key through instead of "eating" it. It's not clear why, exactly, but it seems universal. Mod+1 -> Goes to workspace #1 Mod+2 -> Goes to workspace #2 ... Mod+9 -> Goes to workspace #9 Most applications don't even see the number key being sent, so if you move to workspace 1, Firefox won't type "1" into the browser bar, Vim won't type "1" into your file, etc. But SDL applications, for whatever reason, DO see this keydown. Of course, they'll handle it like a regular key press. So if you move to workspace 1, which contains OpenRCT, it inadvertently toggles x-ray mode. I first found this bug in another SDL game, The Powder Toy. After some discussion with the devs, they fixed it like this, by ignoring keydown events when the mod key is pressed, since the mod key is reserved for the window manager anyway. It works well and should be in the next release. https://github.com/The-Powder-Toy/The-Powder-Toy/compare/c7619387ace6a24c4bd31e6899073ef3a91bcf7a...93b920a57f4d3843a8e6234e360fcf5e919181a6 I did the same thing here. --- contributors.md | 1 + src/openrct2-ui/UiContext.cpp | 6 ++++++ 2 files changed, 7 insertions(+) diff --git a/contributors.md b/contributors.md index 25c4082a91..34c3d18bde 100644 --- a/contributors.md +++ b/contributors.md @@ -178,6 +178,7 @@ The following people are not part of the development team, but have been contrib * (ocalhoun6) * Sean Payne (seanmajorpayne) * Soham Roy (sohamroy19) +* Gaven Rendell (Rendello) ## Toolchain * (Balletie) - macOS diff --git a/src/openrct2-ui/UiContext.cpp b/src/openrct2-ui/UiContext.cpp index 9031f447a1..12faf27b7a 100644 --- a/src/openrct2-ui/UiContext.cpp +++ b/src/openrct2-ui/UiContext.cpp @@ -523,6 +523,12 @@ public: #endif case SDL_KEYDOWN: { + // Ignore keydowns when mod is held. Handles edge cases + // where window managers don't eat the keypresses. + if (SDL_GetModState() & KMOD_GUI) + { + break; + } _textComposition.HandleMessage(&e); auto ie = GetInputEventFromSDLEvent(e); ie.State = InputEventState::Down; From 33fa31e6d0b2fd2f4ff899851eca143e5a2358a5 Mon Sep 17 00:00:00 2001 From: Gaven Rendell Date: Fri, 2 Apr 2021 20:14:56 -0400 Subject: [PATCH 17/19] Exclude Win/Mac from ignoring mod key --- src/openrct2-ui/UiContext.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/openrct2-ui/UiContext.cpp b/src/openrct2-ui/UiContext.cpp index 12faf27b7a..8ef79e62a5 100644 --- a/src/openrct2-ui/UiContext.cpp +++ b/src/openrct2-ui/UiContext.cpp @@ -523,12 +523,15 @@ public: #endif case SDL_KEYDOWN: { - // Ignore keydowns when mod is held. Handles edge cases - // where window managers don't eat the keypresses. +#if !(defined(__MACOSX__) || defined(__WINDOWS__)) + // Ignore winkey keydowns. Handles edge case where *NIX + // tiling window managers don't eat the keypresses when + // changing workspaces. if (SDL_GetModState() & KMOD_GUI) { break; } +#endif _textComposition.HandleMessage(&e); auto ie = GetInputEventFromSDLEvent(e); ie.State = InputEventState::Down; From 86cf0dc916d0d6430c0a6e6e9be12bd92255b9d3 Mon Sep 17 00:00:00 2001 From: Gaven Rendell Date: Sun, 4 Apr 2021 13:00:18 -0400 Subject: [PATCH 18/19] Remove Windows check --- src/openrct2-ui/UiContext.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/openrct2-ui/UiContext.cpp b/src/openrct2-ui/UiContext.cpp index 8ef79e62a5..b5510dec5e 100644 --- a/src/openrct2-ui/UiContext.cpp +++ b/src/openrct2-ui/UiContext.cpp @@ -523,10 +523,10 @@ public: #endif case SDL_KEYDOWN: { -#if !(defined(__MACOSX__) || defined(__WINDOWS__)) - // Ignore winkey keydowns. Handles edge case where *NIX - // tiling window managers don't eat the keypresses when - // changing workspaces. +#ifndef __MACOSX__ + // Ignore winkey keydowns. Handles edge case where tiling + // window managers don't eat the keypresses when changing + // workspaces. if (SDL_GetModState() & KMOD_GUI) { break; From e8b6e244982e464060072d738db98edc2970feda Mon Sep 17 00:00:00 2001 From: seanmajorpayne <4562746+seanmajorpayne@users.noreply.github.com> Date: Sat, 9 Oct 2021 19:49:26 +0900 Subject: [PATCH 19/19] Fix #15451: Guest List name filter remains after group selection --- distribution/changelog.txt | 1 + src/openrct2-ui/windows/GuestList.cpp | 10 ++++++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/distribution/changelog.txt b/distribution/changelog.txt index 432cd2d76f..7bf4bb26a2 100644 --- a/distribution/changelog.txt +++ b/distribution/changelog.txt @@ -28,6 +28,7 @@ - Fix: [#15255] Tile Inspector shows banner information on walls that do not contain one. - Fix: [#15257] Chat icon shows in scenario/track editor. Other icons don't disable when deactivated in options menu. - Fix: [#15289] Unexpected behavior with duplicated banners which also caused desyncs in multiplayer. +- Fix: [#15451] Guest list name filter remains after group selection. - Fix: [#15476] Crash when placing/clearing small scenery. - Fix: [#15487] Map animations do not work correctly when loading an exported SV6 file in vanilla RCT2. - Fix: [#15496] Crash in paint_swinging_inverter_ship_structure(). diff --git a/src/openrct2-ui/windows/GuestList.cpp b/src/openrct2-ui/windows/GuestList.cpp index 9909718c7a..e70c7c4f83 100644 --- a/src/openrct2-ui/windows/GuestList.cpp +++ b/src/openrct2-ui/windows/GuestList.cpp @@ -321,8 +321,13 @@ public: _selectedPage = 0; _numPages = 1; widgets[WIDX_TRACKING].type = WindowWidgetType::Empty; - widgets[WIDX_FILTER_BY_NAME].type = WindowWidgetType::Empty; - if (_selectedTab == TabId::Individual) + if (_selectedTab == TabId::Summarised) + { + widgets[WIDX_FILTER_BY_NAME].type = WindowWidgetType::Empty; + SetWidgetPressed(WIDX_FILTER_BY_NAME, false); + _filterName.clear(); + } + else if (_selectedTab == TabId::Individual) { widgets[WIDX_TRACKING].type = WindowWidgetType::FlatBtn; widgets[WIDX_FILTER_BY_NAME].type = WindowWidgetType::FlatBtn; @@ -576,6 +581,7 @@ public: _selectedTab = TabId::Individual; widgets[WIDX_TRACKING].type = WindowWidgetType::FlatBtn; Invalidate(); + widgets[WIDX_FILTER_BY_NAME].type = WindowWidgetType::FlatBtn; scrolls[0].v_top = 0; RefreshList(); }