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

Create ZoomLevel struct to add two new zoom levels

This commit is contained in:
Ted John 2020-02-20 00:18:05 +00:00
parent 9860f1e99e
commit d34dec9c27
38 changed files with 332 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/openrct2-ui/WindowManager.cpp
View File

@ -488,7 +488,7 @@ public:
return std::string(buffer);
}
void SetMainView(const ScreenCoordsXY& viewPos, int32_t zoom, int32_t rotation) override
void SetMainView(const ScreenCoordsXY& viewPos, ZoomLevel zoom, int32_t rotation) override
{
auto mainWindow = window_get_main();
if (mainWindow != nullptr)
@ -503,8 +503,8 @@ public:
if (zoomDifference != 0)
{
viewport->view_width <<= zoomDifference;
viewport->view_height <<= zoomDifference;
viewport->view_width = viewport->view_width * zoomDifference;
viewport->view_height = viewport->view_height * zoomDifference;
}
mainWindow->savedViewPos.x -= viewport->view_width >> 1;
mainWindow->savedViewPos.y -= viewport->view_height >> 1;

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

@ -623,9 +623,9 @@ 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 & (1 << 4))
if (g1Element->flags & G1_FLAG_HAS_ZOOM_SPRITE)
{
rct_drawpixelinfo zoomedDPI;
zoomedDPI.bits = _dpi->bits;
@ -639,19 +639,22 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint
DrawSprite((image & 0xFFF80000) | (g1Id - g1Element->zoomed_offset), x >> 1, y >> 1, tertiaryColour);
return;
}
if (g1Element->flags & (1 << 5))
if (g1Element->flags & G1_FLAG_NO_ZOOM_DRAW)
{
return;
}
}
uint8_t zoomLevel = (1 << _dpi->zoom_level);
int32_t left = x + g1Element->x_offset;
int32_t top = y + g1Element->y_offset;
int32_t zoom_mask = 0xFFFFFFFF << _dpi->zoom_level;
if (_dpi->zoom_level && g1Element->flags & G1_FLAG_RLE_COMPRESSION)
int32_t zoom_mask;
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))
{
top -= ~zoom_mask;
}
@ -667,7 +670,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 && g1Element->flags & G1_FLAG_RLE_COMPRESSION)
if (_dpi->zoom_level != 0 && (g1Element->flags & G1_FLAG_RLE_COMPRESSION))
{
bottom += top & ~zoom_mask;
}
@ -686,10 +689,10 @@ void OpenGLDrawingContext::DrawSprite(uint32_t image, int32_t x, int32_t y, uint
right -= _dpi->x;
bottom -= _dpi->y;
left /= zoomLevel;
top /= zoomLevel;
right /= zoomLevel;
bottom /= zoomLevel;
left = left / _dpi->zoom_level;
top = top / _dpi->zoom_level;
right = right / _dpi->zoom_level;
bottom = bottom / _dpi->zoom_level;
left += _clipLeft;
top += _clipTop;
@ -774,8 +777,6 @@ void OpenGLDrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t ma
const auto textureMask = _textureCache->GetOrLoadImageTexture(maskImage);
const auto textureColour = _textureCache->GetOrLoadImageTexture(colourImage);
uint8_t zoomLevel = (1 << _dpi->zoom_level);
int32_t drawOffsetX = g1ElementMask->x_offset;
int32_t drawOffsetY = g1ElementMask->y_offset;
int32_t drawWidth = std::min(g1ElementMask->width, g1ElementColour->width);
@ -800,10 +801,10 @@ void OpenGLDrawingContext::DrawSpriteRawMasked(int32_t x, int32_t y, uint32_t ma
right -= _dpi->x;
bottom -= _dpi->y;
left /= zoomLevel;
top /= zoomLevel;
right /= zoomLevel;
bottom /= zoomLevel;
left = left * _dpi->zoom_level;
top = top * _dpi->zoom_level;
right = right * _dpi->zoom_level;
bottom = bottom * _dpi->zoom_level;
left += _clipLeft;
top += _clipTop;
@ -1011,9 +1012,8 @@ void OpenGLDrawingContext::SetDPI(rct_drawpixelinfo* dpi)
_clipLeft = (int32_t)(bitsOffset % (screenDPI->width + screenDPI->pitch));
_clipTop = (int32_t)(bitsOffset / (screenDPI->width + screenDPI->pitch));
_clipRight = _clipLeft + (dpi->width >> dpi->zoom_level);
_clipBottom = _clipTop + (dpi->height >> dpi->zoom_level);
_clipRight = _clipLeft + (dpi->width / dpi->zoom_level);
_clipBottom = _clipTop + (dpi->height / dpi->zoom_level);
_offsetX = _clipLeft - dpi->x;
_offsetY = _clipTop - dpi->y;

9
src/openrct2-ui/input/MouseInput.cpp
View File

@ -555,8 +555,8 @@ static void input_viewport_drag_continue()
// As the user moved the mouse, don't interpret it as right click in any case.
_ticksSinceDragStart = 1000;
differentialCoords.x *= 1 << (viewport->zoom + 1);
differentialCoords.y *= 1 << (viewport->zoom + 1);
differentialCoords.x = differentialCoords.x * (viewport->zoom + 1);
differentialCoords.y = differentialCoords.y * (viewport->zoom + 1);
if (gConfigGeneral.invert_viewport_drag)
{
w->savedViewPos -= differentialCoords;
@ -1591,8 +1591,9 @@ void input_scroll_viewport(const ScreenCoordsXY& scrollScreenCoords)
const int32_t speed = gConfigGeneral.edge_scrolling_speed;
int32_t dx = scrollScreenCoords.x * (speed << viewport->zoom);
int32_t dy = scrollScreenCoords.y * (speed << viewport->zoom);
int32_t multiplier = speed * viewport->zoom;
int32_t dx = scrollScreenCoords.x * multiplier;
int32_t dy = scrollScreenCoords.y * multiplier;
if (scrollScreenCoords.x != 0)
{

4
src/openrct2-ui/interface/ViewportInteraction.cpp
View File

@ -627,8 +627,8 @@ static Peep* viewport_interaction_get_closest_peep(ScreenCoordsXY screenCoords,
if (viewport == nullptr || viewport->zoom >= 2)
return nullptr;
screenCoords.x = ((screenCoords.x - viewport->pos.x) << viewport->zoom) + viewport->viewPos.x;
screenCoords.y = ((screenCoords.y - viewport->pos.y) << viewport->zoom) + viewport->viewPos.y;
screenCoords.x = ((screenCoords.x - viewport->pos.x) * viewport->zoom) + viewport->viewPos.x;
screenCoords.y = ((screenCoords.y - viewport->pos.y) * viewport->zoom) + viewport->viewPos.y;
closestPeep = nullptr;
closestDistance = 0xFFFF;

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

@ -660,11 +660,10 @@ void window_guest_overview_resize(rct_window* w)
auto reqViewportHeight = w->height - 72;
if (viewport->width != reqViewportWidth || viewport->height != reqViewportHeight)
{
uint8_t zoom_amount = 1 << viewport->zoom;
viewport->width = reqViewportWidth;
viewport->height = reqViewportHeight;
viewport->view_width = viewport->width / zoom_amount;
viewport->view_height = viewport->height / zoom_amount;
viewport->view_width = viewport->width / viewport->zoom;
viewport->view_height = viewport->height / viewport->zoom;
}
}
window_guest_viewport_init(w);

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

@ -459,8 +459,8 @@ void window_player_overview_invalidate(rct_window* w)
viewport->pos = w->windowPos + ScreenCoordsXY{ viewportWidget->left, viewportWidget->top };
viewport->width = viewportWidget->right - viewportWidget->left;
viewport->height = viewportWidget->bottom - viewportWidget->top;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_height = viewport->height << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport->view_height = viewport->height * viewport->zoom;
}
// Only enable kick button for other players

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

@ -2148,15 +2148,14 @@ static std::optional<CoordsXY> ride_get_place_position_from_screen_position(Scre
{
if (gInputPlaceObjectModifier & PLACE_OBJECT_MODIFIER_SHIFT_Z)
{
constexpr uint16_t maxHeight = (std::numeric_limits<decltype(TileElement::base_height)>::max() - 32)
<< MAX_ZOOM_LEVEL;
uint16_t maxHeight = (std::numeric_limits<decltype(TileElement::base_height)>::max() - 32) * ZoomLevel::max();
_trackPlaceShiftZ = _trackPlaceShiftStart.y - screenCoords.y + 4;
// Scale delta by zoom to match mouse position.
auto* mainWnd = window_get_main();
if (mainWnd && mainWnd->viewport)
{
_trackPlaceShiftZ <<= mainWnd->viewport->zoom;
_trackPlaceShiftZ = _trackPlaceShiftZ * mainWnd->viewport->zoom;
}
_trackPlaceShiftZ = floor2(_trackPlaceShiftZ, 8);

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

@ -544,8 +544,8 @@ void window_staff_overview_resize(rct_window* w)
{
viewport->width = new_width;
viewport->height = new_height;
viewport->view_width = new_width << viewport->zoom;
viewport->view_height = new_height << viewport->zoom;
viewport->view_width = new_width * viewport->zoom;
viewport->view_height = new_height * viewport->zoom;
}
}

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

@ -214,7 +214,7 @@ static uint8_t get_zoom()
rct_window* w = window_get_main();
if (w != nullptr)
{
zoom = w->viewport->zoom;
zoom = static_cast<int8_t>(w->viewport->zoom);
}
return zoom;
}

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

@ -870,11 +870,11 @@ static void window_top_toolbar_invalidate(rct_window* w)
}
// Zoomed out/in disable. Not sure where this code is in the original.
if (window_get_main()->viewport->zoom == 0)
if (window_get_main()->viewport->zoom == ZoomLevel::min())
{
w->disabled_widgets |= (1 << WIDX_ZOOM_IN);
}
else if (window_get_main()->viewport->zoom >= MAX_ZOOM_LEVEL)
else if (window_get_main()->viewport->zoom >= ZoomLevel::max())
{
w->disabled_widgets |= (1 << WIDX_ZOOM_OUT);
}
@ -1217,7 +1217,7 @@ static void sub_6E1F34(
return;
}
uint16_t maxPossibleHeight = (std::numeric_limits<decltype(TileElement::base_height)>::max() - 32) << MAX_ZOOM_LEVEL;
uint16_t maxPossibleHeight = (std::numeric_limits<decltype(TileElement::base_height)>::max() - 32) * ZoomLevel::max();
bool can_raise_item = false;
if (selection.SceneryType == SCENERY_TYPE_SMALL)
@ -1310,7 +1310,7 @@ static void sub_6E1F34(
auto* mainWnd = window_get_main();
if (mainWnd && mainWnd->viewport)
{
gSceneryShiftPressZOffset <<= mainWnd->viewport->zoom;
gSceneryShiftPressZOffset = gSceneryShiftPressZOffset * mainWnd->viewport->zoom;
}
gSceneryShiftPressZOffset = floor2(gSceneryShiftPressZOffset, 8);
@ -3106,7 +3106,7 @@ static void window_top_toolbar_land_tool_drag(int16_t x, int16_t y)
if (!viewport)
return;
int16_t tile_height = -16 / (1 << viewport->zoom);
int16_t tile_height = -16 / viewport->zoom;
int32_t y_diff = y - gInputDragLast.y;
@ -3149,8 +3149,7 @@ static void window_top_toolbar_water_tool_drag(int16_t x, int16_t y)
if (!viewport)
return;
int16_t dx = -16;
dx >>= viewport->zoom;
int16_t dx = -16 / viewport->zoom;
y -= gInputDragLast.y;

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

@ -130,14 +130,14 @@ static void window_viewport_mouseup(rct_window* w, rct_widgetindex widgetIndex)
window_close(w);
break;
case WIDX_ZOOM_IN:
if (w->viewport != nullptr && w->viewport->zoom > 0)
if (w->viewport != nullptr && w->viewport->zoom > ZoomLevel::min())
{
w->viewport->zoom--;
w->Invalidate();
}
break;
case WIDX_ZOOM_OUT:
if (w->viewport != nullptr && w->viewport->zoom < 3)
if (w->viewport != nullptr && w->viewport->zoom < ZoomLevel::max())
{
w->viewport->zoom++;
w->Invalidate();
@ -205,16 +205,16 @@ static void window_viewport_invalidate(rct_window* w)
// Set disabled widgets
w->disabled_widgets = 0;
if (viewport->zoom == 0)
if (viewport->zoom == ZoomLevel::min())
w->disabled_widgets |= 1 << WIDX_ZOOM_IN;
if (viewport->zoom >= 3)
if (viewport->zoom >= ZoomLevel::max())
w->disabled_widgets |= 1 << WIDX_ZOOM_OUT;
viewport->pos = w->windowPos + ScreenCoordsXY{ viewportWidget->left, viewportWidget->top };
viewport->width = viewportWidget->right - viewportWidget->left;
viewport->height = viewportWidget->bottom - viewportWidget->top;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_height = viewport->height << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport->view_height = viewport->height * viewport->zoom;
}
static void window_viewport_paint(rct_window* w, rct_drawpixelinfo* dpi)

2
src/openrct2/audio/Audio.cpp
View File

@ -220,7 +220,7 @@ static AudioParams audio_get_params_from_location(SoundId soundId, const CoordsX
{
int16_t vx = pos2.x - viewport->viewPos.x;
int16_t vy = pos2.y - viewport->viewPos.y;
params.pan = viewport->pos.x + (vx >> viewport->zoom);
params.pan = viewport->pos.x + (vx / viewport->zoom);
params.volume = SoundVolumeAdjust[static_cast<uint8_t>(soundId)]
+ ((-1024 * viewport->zoom - 1) * (1 << volumeDown)) + 1;

24
src/openrct2/drawing/Drawing.Sprite.cpp
View File

@ -408,10 +408,10 @@ void FASTCALL gfx_bmp_sprite_to_buffer(
const uint8_t* palette_pointer, uint8_t* source_pointer, uint8_t* dest_pointer, const rct_g1_element* source_image,
rct_drawpixelinfo* dest_dpi, int32_t height, int32_t width, ImageId imageId)
{
uint16_t zoom_level = dest_dpi->zoom_level;
uint8_t zoom_amount = 1 << zoom_level;
uint32_t dest_line_width = (dest_dpi->width / zoom_amount) + dest_dpi->pitch;
uint32_t source_line_width = source_image->width * zoom_amount;
auto zoom_level = dest_dpi->zoom_level;
uint8_t zoom_amount = 1 * zoom_level;
uint32_t dest_line_width = (dest_dpi->width / zoom_level) + dest_dpi->pitch;
uint32_t source_line_width = source_image->width * zoom_level;
// Image uses the palette pointer to remap the colours of the image
if (imageId.HasPrimary())
@ -612,10 +612,10 @@ void FASTCALL gfx_draw_sprite_palette_set_software(
}
// Its used super often so we will define it to a separate variable.
int32_t zoom_level = dpi->zoom_level;
int32_t zoom_mask = 0xFFFFFFFF << zoom_level;
auto zoom_level = dpi->zoom_level;
int32_t zoom_mask = 0xFFFFFFFF * zoom_level;
if (zoom_level && g1->flags & G1_FLAG_RLE_COMPRESSION)
if (zoom_level != 0 && g1->flags & G1_FLAG_RLE_COMPRESSION)
{
x -= ~zoom_mask;
y -= ~zoom_mask;
@ -656,7 +656,7 @@ void FASTCALL gfx_draw_sprite_palette_set_software(
}
else
{
if (g1->flags & G1_FLAG_RLE_COMPRESSION && zoom_level)
if ((g1->flags & G1_FLAG_RLE_COMPRESSION) && zoom_level != 0)
{
source_start_y -= dest_start_y & ~zoom_mask;
height += dest_start_y & ~zoom_mask;
@ -675,7 +675,7 @@ void FASTCALL gfx_draw_sprite_palette_set_software(
if (height <= 0)
return;
dest_start_y >>= zoom_level;
dest_start_y = dest_start_y / zoom_level;
// This will be the width of the drawn image
int32_t width = g1->width;
@ -701,7 +701,7 @@ void FASTCALL gfx_draw_sprite_palette_set_software(
}
else
{
if (g1->flags & G1_FLAG_RLE_COMPRESSION && zoom_level)
if ((g1->flags & G1_FLAG_RLE_COMPRESSION) && zoom_level != 0)
{
source_start_x -= dest_start_x & ~zoom_mask;
}
@ -719,11 +719,11 @@ void FASTCALL gfx_draw_sprite_palette_set_software(
return;
}
dest_start_x >>= zoom_level;
dest_start_x = dest_start_x / zoom_level;
uint8_t* dest_pointer = dpi->bits;
// Move the pointer to the start point of the destination
dest_pointer += ((dpi->width >> zoom_level) + dpi->pitch) * dest_start_y + dest_start_x;
dest_pointer += ((dpi->width / zoom_level) + dpi->pitch) * dest_start_y + dest_start_x;
if (g1->flags & G1_FLAG_RLE_COMPRESSION)
{

3
src/openrct2/drawing/Drawing.h
View File

@ -12,6 +12,7 @@
#include "../common.h"
#include "../interface/Colour.h"
#include "../interface/ZoomLevel.hpp"
namespace OpenRCT2
{
@ -42,7 +43,7 @@ struct rct_drawpixelinfo
int16_t width{};
int16_t height{};
int16_t pitch{}; // note: this is actually (pitch - width)
uint16_t zoom_level{};
ZoomLevel zoom_level{};
OpenRCT2::Drawing::IDrawingEngine* DrawingEngine{};
};

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

@ -147,7 +147,7 @@ static void FASTCALL DrawRLESprite1(
const uint8_t* source_bits_pointer, uint8_t* dest_bits_pointer, const uint8_t* palette_pointer,
const rct_drawpixelinfo* dpi, int32_t source_y_start, int32_t height, int32_t source_x_start, int32_t width)
{
int32_t zoom_level = dpi->zoom_level;
auto zoom_level = static_cast<int8_t>(dpi->zoom_level);
switch (zoom_level)
{
case 0:

23
src/openrct2/drawing/LightFX.cpp
View File

@ -70,12 +70,12 @@ static uint32_t LightListCurrentCountFront;
static int16_t _current_view_x_front = 0;
static int16_t _current_view_y_front = 0;
static uint8_t _current_view_rotation_front = 0;
static uint8_t _current_view_zoom_front = 0;
static ZoomLevel _current_view_zoom_front = 0;
static int16_t _current_view_x_back = 0;
static int16_t _current_view_y_back = 0;
static uint8_t _current_view_rotation_back = 0;
static uint8_t _current_view_zoom_back = 0;
static uint8_t _current_view_zoom_back_delay = 0;
static ZoomLevel _current_view_zoom_back = 0;
static ZoomLevel _current_view_zoom_back_delay = 0;
static rct_palette gPalette_light;
@ -202,8 +202,8 @@ void lightfx_prepare_light_list()
int32_t posOnScreenX = entry->viewCoords.x - _current_view_x_front;
int32_t posOnScreenY = entry->viewCoords.y - _current_view_y_front;
posOnScreenX >>= _current_view_zoom_front;
posOnScreenY >>= _current_view_zoom_front;
posOnScreenX = posOnScreenX / _current_view_zoom_front;
posOnScreenY = posOnScreenY / _current_view_zoom_front;
if ((posOnScreenX < -128) || (posOnScreenY < -128) || (posOnScreenX > _pixelInfo.width + 128)
|| (posOnScreenY > _pixelInfo.height + 128))
@ -263,7 +263,7 @@ void lightfx_prepare_light_list()
break;
}
int32_t mapFrontDiv = 1 << _current_view_zoom_front;
int32_t mapFrontDiv = 1 * _current_view_zoom_front;
// clang-format off
static int16_t offsetPattern[26] = {
@ -397,17 +397,18 @@ void lightfx_prepare_light_list()
entry->lightIntensity = std::min<uint32_t>(
0xFF, (entry->lightIntensity * lightIntensityOccluded) / (totalSamplePoints * 100));
}
entry->lightIntensity = std::max<uint32_t>(0x00, entry->lightIntensity - _current_view_zoom_front * 5);
entry->lightIntensity = std::max<uint32_t>(
0x00, entry->lightIntensity - static_cast<int8_t>(_current_view_zoom_front) * 5);
if (_current_view_zoom_front > 0)
{
if ((entry->lightType & 0x3) < _current_view_zoom_front)
if ((entry->lightType & 0x3) < static_cast<int8_t>(_current_view_zoom_front))
{
entry->lightType = LIGHTFX_LIGHT_TYPE_NONE;
continue;
}
entry->lightType -= _current_view_zoom_front;
entry->lightType -= static_cast<int8_t>(_current_view_zoom_front);
}
}
}
@ -484,8 +485,8 @@ void lightfx_render_lights_to_frontbuffer()
{
inRectCentreX -= _current_view_x_front;
inRectCentreY -= _current_view_y_front;
inRectCentreX >>= _current_view_zoom_front;
inRectCentreY >>= _current_view_zoom_front;
inRectCentreX = inRectCentreX / _current_view_zoom_front;
inRectCentreY = inRectCentreY / _current_view_zoom_front;
}
switch (entry->lightType)

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

@ -1450,7 +1450,7 @@ int32_t scrolling_text_setup(
rct_drawpixelinfo* dpi = &session->DPI;
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
return SPR_SCROLLING_TEXT_DEFAULT;
_drawSCrollNextIndex++;

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

@ -471,8 +471,8 @@ void X8DrawingContext::Clear(uint8_t paletteIndex)
{
rct_drawpixelinfo* dpi = _dpi;
int32_t w = dpi->width >> dpi->zoom_level;
int32_t h = dpi->height >> dpi->zoom_level;
int32_t w = dpi->width / dpi->zoom_level;
int32_t h = dpi->height / dpi->zoom_level;
uint8_t* ptr = dpi->bits;
for (int32_t y = 0; y < h; y++)
@ -699,8 +699,7 @@ void X8DrawingContext::FilterRect(FILTER_PALETTE_ID palette, int32_t left, int32
// 00678B7E 00678C83
// Location in screen buffer?
uint8_t* dst = dpi->bits
+ (uint32_t)((startY >> (dpi->zoom_level)) * ((dpi->width >> dpi->zoom_level) + dpi->pitch)
+ (startX >> dpi->zoom_level));
+ (uint32_t)((startY / dpi->zoom_level) * ((dpi->width / dpi->zoom_level) + dpi->pitch) + (startX / dpi->zoom_level));
// Find colour in colour table?
uint16_t g1Index = palette_to_g1_offset[palette];
@ -708,11 +707,12 @@ void X8DrawingContext::FilterRect(FILTER_PALETTE_ID palette, int32_t left, int32
if (g1Element != nullptr)
{
auto g1Bits = g1Element->offset;
const int32_t scaled_width = width >> dpi->zoom_level;
const int32_t step = ((dpi->width >> dpi->zoom_level) + dpi->pitch);
const int32_t scaled_width = width / dpi->zoom_level;
const int32_t step = ((dpi->width / dpi->zoom_level) + dpi->pitch);
// Fill the rectangle with the colours from the colour table
for (int32_t i = 0; i < (height >> dpi->zoom_level); i++)
auto c = height / dpi->zoom_level;
for (int32_t i = 0; i < c; i++)
{
uint8_t* nextdst = dst + step * i;
for (int32_t j = 0; j < scaled_width; j++)

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

@ -348,7 +348,7 @@ static void ReleaseDPI(rct_drawpixelinfo& dpi)
dpi.height = 0;
}
static rct_viewport GetGiantViewport(int32_t mapSize, int32_t rotation, int32_t zoom)
static rct_viewport GetGiantViewport(int32_t mapSize, int32_t rotation, ZoomLevel zoom)
{
// Get the tile coordinates of each corner
auto leftTileCoords = GetEdgeTile(mapSize, rotation, EdgeType::LEFT, false);
@ -370,8 +370,8 @@ static rct_viewport GetGiantViewport(int32_t mapSize, int32_t rotation, int32_t
viewport.viewPos = { left, top };
viewport.view_width = right - left;
viewport.view_height = bottom - top;
viewport.width = viewport.view_width >> zoom;
viewport.height = viewport.view_height >> zoom;
viewport.width = viewport.view_width / zoom;
viewport.height = viewport.view_height / zoom;
viewport.zoom = zoom;
return viewport;
}
@ -403,7 +403,7 @@ void screenshot_giant()
}
int32_t rotation = get_current_rotation();
int32_t zoom = 0;
ZoomLevel zoom = 0;
auto mainWindow = window_get_main();
auto vp = window_get_viewport(mainWindow);
@ -463,7 +463,7 @@ static void benchgfx_render_screenshots(const char* inputPath, std::unique_ptr<I
// Create Viewport and DPI for every rotation and zoom.
constexpr int32_t MAX_ROTATIONS = 4;
constexpr int32_t MAX_ZOOM_LEVEL = 3;
std::array<rct_drawpixelinfo, MAX_ROTATIONS * MAX_ZOOM_LEVEL> dpis;
std::array<rct_viewport, MAX_ROTATIONS * MAX_ZOOM_LEVEL> viewports;

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

@ -46,7 +46,7 @@ rct_viewport* g_music_tracking_viewport;
static std::unique_ptr<JobPool> _paintJobs;
ScreenCoordsXY gSavedView;
uint8_t gSavedViewZoom;
ZoomLevel gSavedViewZoom;
uint8_t gSavedViewRotation;
paint_entry* gNextFreePaintStruct;
@ -253,49 +253,49 @@ static void viewport_redraw_after_shift(
if (viewport->pos.x < window->windowPos.x)
{
viewport->width = window->windowPos.x - viewport->pos.x;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
viewport->pos.x += viewport->width;
viewport->viewPos.x += viewport->width << viewport->zoom;
viewport->viewPos.x += viewport->width * viewport->zoom;
viewport->width = view_copy.width - viewport->width;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
}
else if (viewport->pos.x + viewport->width > window->windowPos.x + window->width)
{
viewport->width = window->windowPos.x + window->width - viewport->pos.x;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
viewport->pos.x += viewport->width;
viewport->viewPos.x += viewport->width << viewport->zoom;
viewport->viewPos.x += viewport->width * viewport->zoom;
viewport->width = view_copy.width - viewport->width;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
}
else if (viewport->pos.y < window->windowPos.y)
{
viewport->height = window->windowPos.y - viewport->pos.y;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
viewport->pos.y += viewport->height;
viewport->viewPos.y += viewport->height << viewport->zoom;
viewport->viewPos.y += viewport->height * viewport->zoom;
viewport->height = view_copy.height - viewport->height;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
}
else if (viewport->pos.y + viewport->height > window->windowPos.y + window->height)
{
viewport->height = window->windowPos.y + window->height - viewport->pos.y;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
viewport->pos.y += viewport->height;
viewport->viewPos.y += viewport->height << viewport->zoom;
viewport->viewPos.y += viewport->height * viewport->zoom;
viewport->height = view_copy.height - viewport->height;
viewport->view_width = viewport->width << viewport->zoom;
viewport->view_width = viewport->width * viewport->zoom;
viewport_redraw_after_shift(dpi, window, viewport, x, y);
}
@ -401,13 +401,13 @@ static void viewport_shift_pixels(
static void viewport_move(int16_t x, int16_t y, rct_window* w, rct_viewport* viewport)
{
uint8_t zoom = (1 << viewport->zoom);
auto zoom = viewport->zoom;
// Note: do not do the subtraction and then divide!
// Note: Due to arithmetic shift != /zoom a shift will have to be used
// hopefully when 0x006E7FF3 is finished this can be converted to /zoom.
int16_t x_diff = (viewport->viewPos.x >> viewport->zoom) - (x >> viewport->zoom);
int16_t y_diff = (viewport->viewPos.y >> viewport->zoom) - (y >> viewport->zoom);
int16_t x_diff = (viewport->viewPos.x / viewport->zoom) - (x / viewport->zoom);
int16_t y_diff = (viewport->viewPos.y / viewport->zoom) - (y / viewport->zoom);
viewport->viewPos = { x, y };
@ -797,10 +797,10 @@ void viewport_render(
top = std::max<int32_t>(top - viewport->pos.y, 0);
bottom = std::min<int32_t>(bottom - viewport->pos.y, viewport->height);
left <<= viewport->zoom;
right <<= viewport->zoom;
top <<= viewport->zoom;
bottom <<= viewport->zoom;
left = left * viewport->zoom;
right = right * viewport->zoom;
top = top * viewport->zoom;
bottom = bottom * viewport->zoom;
left += viewport->viewPos.x;
right += viewport->viewPos.x;
@ -896,7 +896,7 @@ void viewport_paint(
uint32_t viewFlags = viewport->flags;
uint16_t width = right - left;
uint16_t height = bottom - top;
uint16_t bitmask = 0xFFFF & (0xFFFF << viewport->zoom);
uint16_t bitmask = viewport->zoom >= 0 ? 0xFFFF & (0xFFFF * viewport->zoom) : 0xFFFF;
width &= bitmask;
height &= bitmask;
@ -906,11 +906,11 @@ void viewport_paint(
bottom = top + height;
int16_t x = (int16_t)(left - (int16_t)(viewport->viewPos.x & bitmask));
x >>= viewport->zoom;
x = x / viewport->zoom;
x += viewport->pos.x;
int16_t y = (int16_t)(top - (int16_t)(viewport->viewPos.y & bitmask));
y >>= viewport->zoom;
y = y / viewport->zoom;
y += viewport->pos.y;
rct_drawpixelinfo dpi1 = *dpi;
@ -919,7 +919,7 @@ void viewport_paint(
dpi1.y = top;
dpi1.width = width;
dpi1.height = height;
dpi1.pitch = (dpi->width + dpi->pitch) - (width >> viewport->zoom);
dpi1.pitch = (dpi->width + dpi->pitch) - (width / viewport->zoom);
dpi1.zoom_level = viewport->zoom;
// make sure, the compare operation is done in int16_t to avoid the loop becoming an infiniteloop.
@ -959,8 +959,8 @@ void viewport_paint(
{
int16_t leftPitch = x - dpi2.x;
dpi2.width -= leftPitch;
dpi2.bits += leftPitch >> dpi2.zoom_level;
dpi2.pitch += leftPitch >> dpi2.zoom_level;
dpi2.bits += leftPitch / dpi2.zoom_level;
dpi2.pitch += leftPitch / dpi2.zoom_level;
dpi2.x = x;
}
@ -969,7 +969,7 @@ void viewport_paint(
{
int16_t rightPitch = paintRight - x - 32;
paintRight -= rightPitch;
dpi2.pitch += rightPitch >> dpi2.zoom_level;
dpi2.pitch += rightPitch / dpi2.zoom_level;
}
dpi2.width = paintRight - dpi2.x;
@ -1057,8 +1057,8 @@ std::optional<CoordsXY> screen_pos_to_map_pos(const ScreenCoordsXY& screenCoords
ScreenCoordsXY screen_coord_to_viewport_coord(rct_viewport* viewport, const ScreenCoordsXY& screenCoords)
{
ScreenCoordsXY ret;
ret.x = ((screenCoords.x - viewport->pos.x) << viewport->zoom) + viewport->viewPos.x;
ret.y = ((screenCoords.y - viewport->pos.y) << viewport->zoom) + viewport->viewPos.y;
ret.x = ((screenCoords.x - viewport->pos.x) * viewport->zoom) + viewport->viewPos.x;
ret.y = ((screenCoords.y - viewport->pos.y) * viewport->zoom) + viewport->viewPos.y;
return ret;
}
@ -1415,7 +1415,7 @@ static bool is_sprite_interacted_with_palette_set(
return false;
}
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
{
if (g1->flags & G1_FLAG_NO_ZOOM_DRAW)
{
@ -1432,14 +1432,14 @@ static bool is_sprite_interacted_with_palette_set(
/* .height = */ dpi->height,
/* .width = */ dpi->width,
/* .pitch = */ dpi->pitch,
/* .zoom_level = */ (uint16_t)(dpi->zoom_level - 1),
/* .zoom_level = */ dpi->zoom_level - 1,
};
return is_sprite_interacted_with_palette_set(&zoomed_dpi, imageId - g1->zoomed_offset, x / 2, y / 2, palette);
}
}
int32_t round = 1 << dpi->zoom_level;
int32_t round = std::max(1, 1 * dpi->zoom_level);
if (g1->flags & G1_FLAG_RLE_COMPRESSION)
{
@ -1650,11 +1650,11 @@ void get_map_coordinates_from_pos_window(
if (screenCoords.x >= 0 && screenCoords.x < (int32_t)myviewport->width && screenCoords.y >= 0
&& screenCoords.y < (int32_t)myviewport->height)
{
screenCoords.x <<= myviewport->zoom;
screenCoords.y <<= myviewport->zoom;
screenCoords.x = screenCoords.x * myviewport->zoom;
screenCoords.y = screenCoords.y * myviewport->zoom;
screenCoords += myviewport->viewPos;
screenCoords.x &= (0xFFFF << myviewport->zoom) & 0xFFFF;
screenCoords.y &= (0xFFFF << myviewport->zoom) & 0xFFFF;
screenCoords.x &= (0xFFFF * myviewport->zoom) & 0xFFFF;
screenCoords.y &= (0xFFFF * myviewport->zoom) & 0xFFFF;
rct_drawpixelinfo dpi;
dpi.x = screenCoords.x;
dpi.y = screenCoords.y;
@ -1714,15 +1714,14 @@ void viewport_invalidate(rct_viewport* viewport, int32_t left, int32_t top, int3
right = std::min(right, viewportRight);
bottom = std::min(bottom, viewportBottom);
uint8_t zoom = 1 << viewport->zoom;
left -= viewportLeft;
top -= viewportTop;
right -= viewportLeft;
bottom -= viewportTop;
left /= zoom;
top /= zoom;
right /= zoom;
bottom /= zoom;
left = left / viewport->zoom;
top = top / viewport->zoom;
right = right / viewport->zoom;
bottom = bottom / viewport->zoom;
left += viewport->pos.x;
top += viewport->pos.y;
right += viewport->pos.x;

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

@ -108,7 +108,6 @@ struct InteractionInfo
};
#define MAX_VIEWPORT_COUNT WINDOW_LIMIT_MAX
#define MAX_ZOOM_LEVEL 3
/**
* A reference counter for whether something is forcing the grid lines to show. When the counter
@ -122,7 +121,7 @@ extern uint8_t gShowConstuctionRightsRefCount;
extern rct_viewport g_viewport_list[MAX_VIEWPORT_COUNT];
extern rct_viewport* g_music_tracking_viewport;
extern ScreenCoordsXY gSavedView;
extern uint8_t gSavedViewZoom;
extern ZoomLevel gSavedViewZoom;
extern uint8_t gSavedViewRotation;
extern paint_entry* gNextFreePaintStruct;

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

@ -974,12 +974,12 @@ void window_viewport_get_map_coords_by_cursor(
}
// Rebase mouse position onto centre of window, and compensate for zoom level.
int32_t rebased_x = ((w->width >> 1) - mouseCoords.x) * (1 << w->viewport->zoom),
rebased_y = ((w->height >> 1) - mouseCoords.y) * (1 << w->viewport->zoom);
int32_t rebased_x = ((w->width / 2) - mouseCoords.x) * w->viewport->zoom;
int32_t rebased_y = ((w->height / 2) - mouseCoords.y) * w->viewport->zoom;
// Compute cursor offset relative to tile.
*offset_x = (w->savedViewPos.x - (centreLoc->x + rebased_x)) * (1 << w->viewport->zoom);
*offset_y = (w->savedViewPos.y - (centreLoc->y + rebased_y)) * (1 << w->viewport->zoom);
*offset_x = (w->savedViewPos.x - (centreLoc->x + rebased_x)) * w->viewport->zoom;
*offset_y = (w->savedViewPos.y - (centreLoc->y + rebased_y)) * w->viewport->zoom;
}
void window_viewport_centre_tile_around_cursor(rct_window* w, int16_t map_x, int16_t map_y, int16_t offset_x, int16_t offset_y)
@ -998,19 +998,19 @@ void window_viewport_centre_tile_around_cursor(rct_window* w, int16_t map_x, int
auto mouseCoords = context_get_cursor_position_scaled();
// Rebase mouse position onto centre of window, and compensate for zoom level.
int32_t rebased_x = ((w->width >> 1) - mouseCoords.x) * (1 << w->viewport->zoom),
rebased_y = ((w->height >> 1) - mouseCoords.y) * (1 << w->viewport->zoom);
int32_t rebased_x = ((w->width >> 1) - mouseCoords.x) * w->viewport->zoom;
int32_t rebased_y = ((w->height >> 1) - mouseCoords.y) * w->viewport->zoom;
// Apply offset to the viewport.
w->savedViewPos = { centreLoc->x + rebased_x + (offset_x / (1 << w->viewport->zoom)),
centreLoc->y + rebased_y + (offset_y / (1 << w->viewport->zoom)) };
w->savedViewPos = { centreLoc->x + rebased_x + (offset_x / w->viewport->zoom),
centreLoc->y + rebased_y + (offset_y / w->viewport->zoom) };
}
void window_zoom_set(rct_window* w, int32_t zoomLevel, bool atCursor)
void window_zoom_set(rct_window* w, ZoomLevel zoomLevel, bool atCursor)
{
rct_viewport* v = w->viewport;
zoomLevel = std::clamp(zoomLevel, 0, MAX_ZOOM_LEVEL);
zoomLevel = std::clamp(zoomLevel, ZoomLevel::min(), ZoomLevel::max());
if (v->zoom == zoomLevel)
return;
@ -1663,8 +1663,8 @@ void window_resize_gui_scenario_editor(int32_t width, int32_t height)
mainWind->height = height;
viewport->width = width;
viewport->height = height;
viewport->view_width = width << viewport->zoom;
viewport->view_height = height << viewport->zoom;
viewport->view_width = width * viewport->zoom;
viewport->view_height = height * viewport->zoom;
if (mainWind->widgets != nullptr && mainWind->widgets[WC_MAIN_WINDOW__0].type == WWT_VIEWPORT)
{
mainWind->widgets[WC_MAIN_WINDOW__0].right = width;
@ -1734,18 +1734,12 @@ void window_update_viewport_ride_music()
g_music_tracking_viewport = viewport;
gWindowAudioExclusive = w;
switch (viewport->zoom)
{
case 0:
gVolumeAdjustZoom = 0;
break;
case 1:
gVolumeAdjustZoom = 30;
break;
default:
gVolumeAdjustZoom = 60;
break;
}
if (viewport->zoom <= 0)
gVolumeAdjustZoom = 0;
else if (viewport->zoom == 1)
gVolumeAdjustZoom = 30;
else
gVolumeAdjustZoom = 60;
break;
}
}

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

@ -14,6 +14,7 @@
#include "../ride/RideTypes.h"
#include "../world/Location.hpp"
#include "../world/ScenerySelection.h"
#include "ZoomLevel.hpp"
#include <functional>
#include <limits>
@ -97,7 +98,7 @@ struct rct_viewport
int16_t view_width;
int16_t view_height;
uint32_t flags;
uint8_t zoom;
ZoomLevel zoom;
uint8_t var_11;
uint8_t visibility; // VISIBILITY_CACHE
};
@ -674,7 +675,7 @@ void window_rotate_camera(rct_window* w, int32_t direction);
void window_viewport_get_map_coords_by_cursor(
rct_window* w, int16_t* map_x, int16_t* map_y, int16_t* offset_x, int16_t* offset_y);
void window_viewport_centre_tile_around_cursor(rct_window* w, int16_t map_x, int16_t map_y, int16_t offset_x, int16_t offset_y);
void window_zoom_set(rct_window* w, int32_t zoomLevel, bool atCursor);
void window_zoom_set(rct_window* w, ZoomLevel zoomLevel, bool atCursor);
void window_zoom_in(rct_window* w, bool atCursor);
void window_zoom_out(rct_window* w, bool atCursor);
void main_window_zoom(bool zoomIn, bool atCursor);

151
src/openrct2/interface/ZoomLevel.hpp Normal file
View File

@ -0,0 +1,151 @@
/*****************************************************************************
* Copyright (c) 2020 OpenRCT2 developers
*
* For a complete list of all authors, please refer to contributors.md
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
*
* OpenRCT2 is licensed under the GNU General Public License version 3.
*****************************************************************************/
#pragma once
#include <cstdint>
struct ZoomLevel
{
private:
int8_t _level{};
public:
constexpr ZoomLevel()
: _level()
{
}
constexpr ZoomLevel(int8_t level)
: _level(level)
{
}
constexpr ZoomLevel(const ZoomLevel& rhs)
: _level(rhs._level)
{
}
explicit operator int8_t() const
{
return _level;
}
ZoomLevel operator++(int)
{
ZoomLevel tmp(*this);
operator++();
return tmp;
}
ZoomLevel& operator++()
{
_level++;
return *this;
}
ZoomLevel operator--(int)
{
ZoomLevel tmp(*this);
operator--();
return tmp;
}
ZoomLevel& operator--()
{
_level--;
return *this;
}
ZoomLevel& operator=(const ZoomLevel& other)
{
_level = other._level;
return *this;
}
ZoomLevel& operator+=(const ZoomLevel& rhs)
{
_level += rhs._level;
return *this;
}
ZoomLevel& operator-=(const ZoomLevel& rhs)
{
_level -= rhs._level;
return *this;
}
friend ZoomLevel operator+(ZoomLevel lhs, const ZoomLevel& rhs)
{
lhs += rhs;
return lhs;
}
friend ZoomLevel operator-(ZoomLevel lhs, const ZoomLevel& rhs)
{
lhs -= rhs;
return lhs;
}
friend bool operator==(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level == rhs._level;
}
friend bool operator!=(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level != rhs._level;
}
friend bool operator>=(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level >= rhs._level;
}
friend bool operator<=(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level <= rhs._level;
}
friend bool operator>(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level > rhs._level;
}
friend bool operator<(const ZoomLevel& lhs, const ZoomLevel& rhs)
{
return lhs._level < rhs._level;
}
template<typename T> friend T operator*(const T& lhs, const ZoomLevel& rhs)
{
if (rhs._level < 0)
return lhs >> -rhs._level;
else
return lhs << rhs._level;
}
template<typename T> friend T operator/(const T& lhs, const ZoomLevel& rhs)
{
if (rhs._level < 0)
return lhs << -rhs._level;
else
return lhs >> rhs._level;
}
static constexpr ZoomLevel min()
{
return -2;
}
static constexpr ZoomLevel max()
{
return 3;
}
};

9
src/openrct2/paint/Paint.cpp
View File

@ -690,12 +690,11 @@ static uint32_t paint_ps_colourify_image(uint32_t imageId, uint8_t spriteType, u
static void draw_pixel_info_crop_by_zoom(rct_drawpixelinfo* dpi)
{
int32_t zoom = dpi->zoom_level;
dpi->x = dpi->x / dpi->zoom_level;
dpi->y = dpi->y / dpi->zoom_level;
dpi->width = dpi->width / dpi->zoom_level;
dpi->height = dpi->height / dpi->zoom_level;
dpi->zoom_level = 0;
dpi->x >>= zoom;
dpi->y >>= zoom;
dpi->width >>= zoom;
dpi->height >>= zoom;
}
paint_session* paint_session_alloc(rct_drawpixelinfo* dpi, uint32_t viewFlags)

2
src/openrct2/paint/sprite/Paint.Litter.cpp
View File

@ -70,7 +70,7 @@ void litter_paint(paint_session* session, const Litter* litter, int32_t imageDir
rct_drawpixelinfo* dpi;
dpi = &session->DPI;
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
return; // If zoomed at all no litter drawn
// litter has no sprite direction so remove that

6
src/openrct2/paint/sprite/Paint.Misc.cpp
View File

@ -44,7 +44,7 @@ void misc_paint(paint_session* session, const rct_sprite* misc, int32_t imageDir
case SPRITE_MISC_MONEY_EFFECT: // 1
{
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
{
return;
}
@ -59,7 +59,7 @@ void misc_paint(paint_session* session, const rct_sprite* misc, int32_t imageDir
case SPRITE_MISC_CRASHED_VEHICLE_PARTICLE: // 2
{
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
{
return;
}
@ -98,7 +98,7 @@ void misc_paint(paint_session* session, const rct_sprite* misc, int32_t imageDir
case SPRITE_MISC_JUMPING_FOUNTAIN_WATER: // 6
case SPRITE_MISC_JUMPING_FOUNTAIN_SNOW: // 9
{
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
{
return;
}

2
src/openrct2/paint/tile_element/Paint.Entrance.cpp
View File

@ -343,7 +343,7 @@ void entrance_paint(paint_session* session, uint8_t direction, int32_t height, c
rct_drawpixelinfo* dpi = &session->DPI;
if (session->ViewFlags & VIEWPORT_FLAG_PATH_HEIGHTS && dpi->zoom_level == 0)
if (session->ViewFlags & VIEWPORT_FLAG_PATH_HEIGHTS && dpi->zoom_level <= 0)
{
if (entrance_get_directions(tile_element) & 0xF)
{

2
src/openrct2/paint/tile_element/Paint.Path.cpp
View File

@ -304,7 +304,7 @@ static void path_bit_benches_paint(
static void path_bit_jumping_fountains_paint(
paint_session* session, rct_scenery_entry* pathBitEntry, int32_t height, uint32_t pathBitImageFlags, rct_drawpixelinfo* dpi)
{
if (dpi->zoom_level != 0)
if (dpi->zoom_level > 0)
return;
uint32_t imageId = pathBitEntry->image;

2
src/openrct2/paint/tile_element/Paint.Surface.cpp
View File

@ -942,7 +942,7 @@ void surface_paint(paint_session* session, uint8_t direction, uint16_t height, c
session->DidPassSurface = true;
session->SurfaceElement = tileElement;
const uint16_t zoomLevel = dpi->zoom_level;
const auto zoomLevel = dpi->zoom_level;
const uint8_t rotation = session->CurrentRotation;
const uint32_t terrain_type = tileElement->AsSurface()->GetSurfaceStyle();
const uint8_t surfaceShape = viewport_surface_paint_setup_get_relative_slope(tileElement, rotation);

2
src/openrct2/peep/Peep.cpp
View File

@ -1411,7 +1411,7 @@ void peep_update_crowd_noise()
// 207360000 maybe related to DSBVOLUME_MIN which is -10,000 (dB/100)
volume = 120 - std::min(visiblePeeps, 120);
volume = volume * volume * volume * volume;
volume = (((207360000 - volume) >> viewport->zoom) - 207360000) / 65536 - 150;
volume = (((207360000 - volume) / viewport->zoom) - 207360000) / 65536 - 150;
// Load and play crowd noise if needed and set volume
if (_crowdSoundChannel == nullptr)

2
src/openrct2/rct2/S6Exporter.cpp
View File

@ -363,7 +363,7 @@ void S6Exporter::Export()
_s6.saved_age = gSavedAge;
_s6.saved_view_x = gSavedView.x;
_s6.saved_view_y = gSavedView.y;
_s6.saved_view_zoom = gSavedViewZoom;
_s6.saved_view_zoom = static_cast<int8_t>(std::clamp<ZoomLevel>(gSavedViewZoom, 0, 3));
_s6.saved_view_rotation = gSavedViewRotation;
ExportMapAnimations();

4
src/openrct2/ride/Ride.cpp
View File

@ -3491,7 +3491,7 @@ int32_t ride_music_params_update(
return ride_music_params_update_label_58(position, tuneId);
}
int32_t x2 = viewport->pos.x + ((rotatedCoords.x - viewport->viewPos.x) >> viewport->zoom);
int32_t x2 = viewport->pos.x + ((rotatedCoords.x - viewport->viewPos.x) / viewport->zoom);
x2 *= 0x10000;
uint16_t screenwidth = context_get_width();
if (screenwidth < 64)
@ -3500,7 +3500,7 @@ int32_t ride_music_params_update(
}
int32_t pan_x = ((x2 / screenwidth) - 0x8000) >> 4;
int32_t y2 = viewport->pos.y + ((rotatedCoords.y - viewport->viewPos.y) >> viewport->zoom);
int32_t y2 = viewport->pos.y + ((rotatedCoords.y - viewport->viewPos.y) / viewport->zoom);
y2 *= 0x10000;
uint16_t screenheight = context_get_height();
if (screenheight < 64)

2
src/openrct2/ride/TrackPaint.cpp
View File

@ -2169,7 +2169,7 @@ void track_paint(paint_session* session, uint8_t direction, int32_t height, cons
int32_t trackSequence = tileElement->AsTrack()->GetSequenceIndex();
int32_t trackColourScheme = tileElement->AsTrack()->GetColourScheme();
if ((session->ViewFlags & VIEWPORT_FLAG_TRACK_HEIGHTS) && dpi->zoom_level == 0)
if ((session->ViewFlags & VIEWPORT_FLAG_TRACK_HEIGHTS) && dpi->zoom_level <= 0)
{
session->InteractionType = VIEWPORT_INTERACTION_ITEM_NONE;
if (TrackHeightMarkerPositions[trackType] & (1 << trackSequence))

12
src/openrct2/ride/Vehicle.cpp
View File

@ -939,7 +939,7 @@ rct_vehicle_sound_params Vehicle::CreateSoundParam(uint16_t priority) const
rct_vehicle_sound_params param;
param.priority = priority;
int32_t panX = (sprite_left / 2) + (sprite_right / 2) - g_music_tracking_viewport->viewPos.x;
panX >>= g_music_tracking_viewport->zoom;
panX = panX / g_music_tracking_viewport->zoom;
panX += g_music_tracking_viewport->pos.x;
uint16_t screenWidth = context_get_width();
@ -950,7 +950,7 @@ rct_vehicle_sound_params Vehicle::CreateSoundParam(uint16_t priority) const
param.pan_x = ((((panX * 65536) / screenWidth) - 0x8000) >> 4);
int32_t panY = (sprite_top / 2) + (sprite_bottom / 2) - g_music_tracking_viewport->viewPos.y;
panY >>= g_music_tracking_viewport->zoom;
panY = panY / g_music_tracking_viewport->zoom;
panY += g_music_tracking_viewport->pos.y;
uint16_t screenHeight = context_get_height();
@ -1049,8 +1049,12 @@ static void vehicle_sounds_update_window_setup()
g_music_tracking_viewport = viewport;
gWindowAudioExclusive = window;
const uint8_t ZoomToVolume[MAX_ZOOM_LEVEL + 1] = { 0, 35, 70, 70 };
gVolumeAdjustZoom = ZoomToVolume[viewport->zoom];
if (viewport->zoom <= 0)
gVolumeAdjustZoom = 0;
else if (viewport->zoom == 1)
gVolumeAdjustZoom = 35;
else
gVolumeAdjustZoom = 70;
}
static uint8_t vehicle_sounds_update_get_pan_volume(rct_vehicle_sound_params* sound_params)

2
src/openrct2/ride/gentle/HauntedHouse.cpp
View File

@ -63,7 +63,7 @@ static void paint_haunted_house_structure(
boundBox.offset_y, height);
rct_drawpixelinfo* dpi = &session->DPI;
if (dpi->zoom_level == 0 && frameNum != 0)
if (dpi->zoom_level <= 0 && frameNum != 0)
{
switch (direction)
{

2
src/openrct2/ui/DummyWindowManager.cpp
View File

@ -53,7 +53,7 @@ namespace OpenRCT2::Ui
{
return std::string();
}
void SetMainView(const ScreenCoordsXY& viewPos, int32_t zoom, int32_t rotation) override
void SetMainView(const ScreenCoordsXY& viewPos, ZoomLevel zoom, int32_t rotation) override
{
}
void UpdateMouseWheel() override

2
src/openrct2/ui/WindowManager.h
View File

@ -35,7 +35,7 @@ namespace OpenRCT2::Ui
virtual void HandleInput() abstract;
virtual void HandleKeyboard(bool isTitle) abstract;
virtual std::string GetKeyboardShortcutString(int32_t shortcut) abstract;
virtual void SetMainView(const ScreenCoordsXY& viewPos, int32_t zoom, int32_t rotation) abstract;
virtual void SetMainView(const ScreenCoordsXY& viewPos, ZoomLevel zoom, int32_t rotation) abstract;
virtual void UpdateMouseWheel() abstract;
virtual rct_window* GetOwner(const rct_viewport* viewport) abstract;
};