mirror of
https://github.com/OpenTTD/OpenTTD
synced 2026-01-19 10:22:39 +01:00
8b14faaa40
Normally DrawStringMultiLine does not perform any clipping, as the return value may be needed if it the text is not drawn. In some specific cases the height is already known, so it is possible to test for clipping, which can cut down on layouting time for text which won't be visible.
189 lines
9.3 KiB
C++
189 lines
9.3 KiB
C++
/*
|
|
* This file is part of OpenTTD.
|
|
* OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
|
|
* OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/** @file gfx_func.h Functions related to the gfx engine. */
|
|
|
|
/**
|
|
* @defgroup dirty Dirty
|
|
*
|
|
* Handles the repaint of some part of the screen.
|
|
*
|
|
* Some places in the code are called functions which makes something "dirty".
|
|
* This has nothing to do with making a Tile or Window darker or less visible.
|
|
* This term comes from memory caching and is used to define an object must
|
|
* be repaint. If some data of an object (like a Tile, Window, Vehicle, whatever)
|
|
* are changed which are so extensive the object must be repaint its marked
|
|
* as "dirty". The video driver repaint this object instead of the whole screen
|
|
* (this is btw. also possible if needed). This is used to avoid a
|
|
* flickering of the screen by the video driver constantly repainting it.
|
|
*
|
|
* This whole mechanism is controlled by an rectangle defined in #_invalid_rect. This
|
|
* rectangle defines the area on the screen which must be repaint. If a new object
|
|
* needs to be repainted this rectangle is extended to 'catch' the object on the
|
|
* screen. At some point (which is normally uninteresting for patch writers) this
|
|
* rectangle is send to the video drivers method
|
|
* VideoDriver::MakeDirty and it is truncated back to an empty rectangle. At some
|
|
* later point (which is uninteresting, too) the video driver
|
|
* repaints all these saved rectangle instead of the whole screen and drop the
|
|
* rectangle information. Then a new round begins by marking objects "dirty".
|
|
*
|
|
* @see VideoDriver::MakeDirty
|
|
* @see _invalid_rect
|
|
* @see _screen
|
|
*/
|
|
|
|
|
|
#ifndef GFX_FUNC_H
|
|
#define GFX_FUNC_H
|
|
|
|
#include "gfx_type.h"
|
|
#include "strings_type.h"
|
|
#include "string_type.h"
|
|
|
|
void GameLoop();
|
|
|
|
void CreateConsole();
|
|
|
|
extern uint8_t _dirkeys; ///< 1 = left, 2 = up, 4 = right, 8 = down
|
|
extern bool _fullscreen;
|
|
extern uint8_t _support8bpp;
|
|
extern CursorVars _cursor;
|
|
extern bool _ctrl_pressed; ///< Is Ctrl pressed?
|
|
extern bool _shift_pressed; ///< Is Shift pressed?
|
|
extern uint16_t _game_speed;
|
|
|
|
extern bool _left_button_down;
|
|
extern bool _left_button_clicked;
|
|
extern bool _right_button_down;
|
|
extern bool _right_button_clicked;
|
|
|
|
extern DrawPixelInfo _screen;
|
|
extern bool _screen_disable_anim; ///< Disable palette animation (important for 32bpp-anim blitter during giant screenshot)
|
|
|
|
extern std::vector<Dimension> _resolutions;
|
|
extern Dimension _cur_resolution;
|
|
extern Palette _cur_palette; ///< Current palette
|
|
|
|
void HandleToolbarHotkey(int hotkey);
|
|
void HandleKeypress(uint keycode, char32_t key);
|
|
void HandleTextInput(std::string_view str, bool marked = false,
|
|
std::optional<size_t> caret = std::nullopt,
|
|
std::optional<size_t> insert_location = std::nullopt, std::optional<size_t> replacement_end = std::nullopt);
|
|
void HandleCtrlChanged();
|
|
void HandleMouseEvents();
|
|
void UpdateWindows();
|
|
void ChangeGameSpeed(bool enable_fast_forward);
|
|
|
|
void DrawMouseCursor();
|
|
void ScreenSizeChanged();
|
|
void GameSizeChanged();
|
|
void UpdateGUIZoom();
|
|
bool AdjustGUIZoom(bool automatic);
|
|
void UndrawMouseCursor();
|
|
|
|
void RedrawScreenRect(int left, int top, int right, int bottom);
|
|
void GfxScroll(int left, int top, int width, int height, int xo, int yo);
|
|
|
|
Dimension GetSpriteSize(SpriteID sprid, Point *offset = nullptr, ZoomLevel zoom = ZOOM_LVL_GUI);
|
|
Dimension GetScaledSpriteSize(SpriteID sprid); /* widget.cpp */
|
|
void DrawSpriteViewport(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub = nullptr);
|
|
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub = nullptr, ZoomLevel zoom = ZOOM_LVL_GUI);
|
|
void DrawSpriteIgnorePadding(SpriteID img, PaletteID pal, const Rect &r, StringAlignment align); /* widget.cpp */
|
|
std::unique_ptr<uint32_t[]> DrawSpriteToRgbaBuffer(SpriteID spriteId, ZoomLevel zoom = ZOOM_LVL_GUI);
|
|
|
|
int DrawString(int left, int right, int top, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = SA_LEFT, bool underline = false, FontSize fontsize = FS_NORMAL);
|
|
int DrawString(int left, int right, int top, StringID str, TextColour colour = TC_FROMSTRING, StringAlignment align = SA_LEFT, bool underline = false, FontSize fontsize = FS_NORMAL);
|
|
int DrawStringMultiLine(int left, int right, int top, int bottom, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL);
|
|
int DrawStringMultiLine(int left, int right, int top, int bottom, StringID str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL);
|
|
bool DrawStringMultiLineWithClipping(int left, int right, int top, int bottom, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL);
|
|
|
|
void DrawCharCentered(char32_t c, const Rect &r, TextColour colour);
|
|
|
|
void GfxFillRect(int left, int top, int right, int bottom, int colour, FillRectMode mode = FILLRECT_OPAQUE);
|
|
void GfxFillPolygon(std::span<const Point> shape, int colour, FillRectMode mode = FILLRECT_OPAQUE);
|
|
void GfxDrawLine(int left, int top, int right, int bottom, int colour, int width = 1, int dash = 0);
|
|
void DrawBox(int x, int y, int dx1, int dy1, int dx2, int dy2, int dx3, int dy3);
|
|
void DrawRectOutline(const Rect &r, int colour, int width = 1, int dash = 0);
|
|
|
|
/* Versions of DrawString/DrawStringMultiLine that accept a Rect instead of separate left, right, top and bottom parameters. */
|
|
inline int DrawString(const Rect &r, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = SA_LEFT, bool underline = false, FontSize fontsize = FS_NORMAL)
|
|
{
|
|
return DrawString(r.left, r.right, r.top, str, colour, align, underline, fontsize);
|
|
}
|
|
|
|
inline int DrawString(const Rect &r, StringID str, TextColour colour = TC_FROMSTRING, StringAlignment align = SA_LEFT, bool underline = false, FontSize fontsize = FS_NORMAL)
|
|
{
|
|
return DrawString(r.left, r.right, r.top, str, colour, align, underline, fontsize);
|
|
}
|
|
|
|
inline int DrawStringMultiLine(const Rect &r, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL)
|
|
{
|
|
return DrawStringMultiLine(r.left, r.right, r.top, r.bottom, str, colour, align, underline, fontsize);
|
|
}
|
|
|
|
inline int DrawStringMultiLine(const Rect &r, StringID str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL)
|
|
{
|
|
return DrawStringMultiLine(r.left, r.right, r.top, r.bottom, str, colour, align, underline, fontsize);
|
|
}
|
|
|
|
inline bool DrawStringMultiLineWithClipping(const Rect &r, std::string_view str, TextColour colour = TC_FROMSTRING, StringAlignment align = (SA_TOP | SA_LEFT), bool underline = false, FontSize fontsize = FS_NORMAL)
|
|
{
|
|
return DrawStringMultiLineWithClipping(r.left, r.right, r.top, r.bottom, str, colour, align, underline, fontsize);
|
|
}
|
|
|
|
inline void GfxFillRect(const Rect &r, int colour, FillRectMode mode = FILLRECT_OPAQUE)
|
|
{
|
|
GfxFillRect(r.left, r.top, r.right, r.bottom, colour, mode);
|
|
}
|
|
|
|
Dimension GetStringBoundingBox(std::string_view str, FontSize start_fontsize = FS_NORMAL);
|
|
Dimension GetStringBoundingBox(StringID strid, FontSize start_fontsize = FS_NORMAL);
|
|
uint GetStringListWidth(std::span<const StringID> list, FontSize fontsize = FS_NORMAL);
|
|
Dimension GetStringListBoundingBox(std::span<const StringID> list, FontSize fontsize = FS_NORMAL);
|
|
int GetStringHeight(std::string_view str, int maxw, FontSize fontsize = FS_NORMAL);
|
|
int GetStringHeight(StringID str, int maxw);
|
|
int GetStringLineCount(std::string_view str, int maxw);
|
|
Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion);
|
|
Dimension GetStringMultiLineBoundingBox(std::string_view str, const Dimension &suggestion, FontSize fontsize = FS_NORMAL);
|
|
void LoadStringWidthTable(bool monospace = false);
|
|
|
|
void DrawDirtyBlocks();
|
|
void AddDirtyBlock(int left, int top, int right, int bottom);
|
|
void MarkWholeScreenDirty();
|
|
|
|
void CheckBlitter();
|
|
|
|
bool FillDrawPixelInfo(DrawPixelInfo *n, int left, int top, int width, int height);
|
|
|
|
inline bool FillDrawPixelInfo(DrawPixelInfo *n, const Rect &r)
|
|
{
|
|
return FillDrawPixelInfo(n, r.left, r.top, r.Width(), r.Height());
|
|
}
|
|
|
|
/* window.cpp */
|
|
void DrawOverlappedWindowForAll(int left, int top, int right, int bottom);
|
|
|
|
void SetMouseCursorBusy(bool busy);
|
|
void SetMouseCursor(CursorID cursor, PaletteID pal);
|
|
void SetAnimatedMouseCursor(const AnimCursor *table);
|
|
void CursorTick();
|
|
void UpdateCursorSize();
|
|
bool ChangeResInGame(int w, int h);
|
|
void SortResolutions();
|
|
bool ToggleFullScreen(bool fs);
|
|
|
|
/* gfx.cpp */
|
|
uint8_t GetCharacterWidth(FontSize size, char32_t key);
|
|
uint8_t GetDigitWidth(FontSize size = FS_NORMAL);
|
|
std::pair<uint8_t, uint8_t> GetBroadestDigit(FontSize size);
|
|
|
|
int GetCharacterHeight(FontSize size);
|
|
|
|
extern DrawPixelInfo *_cur_dpi;
|
|
|
|
#endif /* GFX_FUNC_H */
|