20447000712

Committed 22 Dec 2025 11:43PM UTC coverage: 50.458% (-0.05%) from 50.503%

Build # 20447000712

Build Type

Pull #1804

github

Committed by

web-flow

Commit Message

Merge 642be1157 into af2863637

Pull Request Pull Request #1804: Android build

Run Details

66 of 229 new or added lines in 13 files covered. (28.82%)

13 existing lines in 4 files now uncovered.

22589 of 44768 relevant lines covered (50.46%)

35177.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.07

/libs/driver/src/VideoDriver.cpp

// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
//
// SPDX-License-Identifier: GPL-2.0-or-later

#include "driver/VideoDriver.h"
#include "commonDefines.h"
#include "driver/VideoDriverLoaderInterface.h"
#include "helpers/mathFuncs.h"
#include <algorithm>
#include <stdexcept>

// Do not inline! That would break DLL compatibility:
// http://stackoverflow.com/questions/32444520/how-to-handle-destructors-in-dll-exported-interfaces
IVideoDriver::~IVideoDriver() = default;

/**
 *  Konstruktor von @p VideoDriver.
 *
 *  @param[in] CallBack DriverCallback für Rückmeldungen.
 */
VideoDriver::VideoDriver(VideoDriverLoaderInterface* CallBack)
    : CallBack(CallBack), initialized(false), isFullscreen_(false), renderSize_(0, 0), scaledRenderSize_(0, 0),
      dpiScale_(1.f), guiScale_(100), autoGuiScale_(false)
{
    std::fill(keyboard.begin(), keyboard.end(), false);
}

Position VideoDriver::GetMousePos() const
{
    return mouse_xy.pos;
}

/**
 *  Funktion zum Auslesen ob die Linke Maustaste gedrückt ist.
 *
 *  @return @p true bei Gedrückt, @p false bei Losgelassen
 */
bool VideoDriver::GetMouseStateL() const
{
    return mouse_xy.ldown;
}

/**
 *  Funktion zum Auslesen ob die Rechte Maustaste gedrückt ist.
 *
 *  @return @p true bei Gedrückt, @p false bei Losgelassen
 */
bool VideoDriver::GetMouseStateR() const
{
    return mouse_xy.rdown;
}

/**
 * Function to check if at least 1 finger is on screen.
 *
 *  @return @p true at least 1 finger, @p false when mouse used
 */
bool VideoDriver::IsTouchEvent() const
{
    return mouse_xy.num_tfingers > 0;
}

VideoMode VideoDriver::FindClosestVideoMode(const VideoMode& mode) const
{
    std::vector<VideoMode> avModes;
    ListVideoModes(avModes);
    if(avModes.empty())
        throw std::runtime_error("No supported video modes found!");
    unsigned minSizeDiff = std::numeric_limits<unsigned>::max();
    VideoMode best = avModes.front();
    for(const VideoMode& current : avModes)
    {
        const auto dw = absDiff(current.width, mode.width);
        const auto dh = absDiff(current.height, mode.height);
        unsigned sizeDiff = dw * dw + dh * dh;
        if(sizeDiff < minSizeDiff)
        {
            minSizeDiff = sizeDiff;
            best = current;
        }
    }
    return best;
}

void VideoDriver::SetNewSize(VideoMode windowSize, Extent renderSize)
{
    windowSize_ = windowSize;
    renderSize_ = renderSize;

    const auto ratioXY = PointF(renderSize_) / PointF(windowSize_.width, windowSize_.height);
    dpiScale_ = (ratioXY.x + ratioXY.y) / 2.f; // use the average ratio of both axes

    if(autoGuiScale_)
        guiScale_ = GuiScale(getGuiScaleRange().recommendedPercent);

    scaledRenderSize_ = guiScale_.screenToView<Extent>(renderSize);
}

void VideoDriver::setGuiScalePercent(unsigned percent)
{
    autoGuiScale_ = (percent == 0);
    if(autoGuiScale_)
        percent = getGuiScaleRange().recommendedPercent;

    if(guiScale_.percent() == percent)
        return;

    // translate current mouse position to screen space
    const auto screenPos = guiScale_.viewToScreen(mouse_xy.pos);

    guiScale_ = GuiScale(percent);
    scaledRenderSize_ = guiScale_.screenToView<Extent>(renderSize_);
    CallBack->WindowResized();

    // move cursor to new position in view space
    // must happen after window resize event to avoid drawing spurious hover events
    mouse_xy.pos = guiScale_.screenToView(screenPos);
    CallBack->Msg_MouseMove(mouse_xy);
}

GuiScaleRange VideoDriver::getGuiScaleRange() const
{
    constexpr auto min = 100u;
    const auto recommended = std::max(min, helpers::iround<unsigned>(dpiScale_ * 100.f));
    const auto maxScaleXY = renderSize_ / PointF(800.f, 600.f);
    const auto maxScale = std::min(maxScaleXY.x, maxScaleXY.y);
    // if the window shrinks below its minimum size of 800x600, max can be smaller than recommended
    const auto max = std::max(helpers::iround<unsigned>(maxScale * 100.f), recommended);

    return GuiScaleRange{min, max, recommended};
}

1	// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
2	//
3	// SPDX-License-Identifier: GPL-2.0-or-later
4
5	#include "driver/VideoDriver.h"
6	#include "commonDefines.h"
7	#include "driver/VideoDriverLoaderInterface.h"
8	#include "helpers/mathFuncs.h"
9	#include <algorithm>
10	#include <stdexcept>
11
12	// Do not inline! That would break DLL compatibility:
13	// http://stackoverflow.com/questions/32444520/how-to-handle-destructors-in-dll-exported-interfaces
14	IVideoDriver::~IVideoDriver() = default;	4✔
15
16	/**
17	* Konstruktor von @p VideoDriver.
18	*
19	* @param[in] CallBack DriverCallback für Rückmeldungen.
20	*/
21	VideoDriver::VideoDriver(VideoDriverLoaderInterface* CallBack)	4✔
22	: CallBack(CallBack), initialized(false), isFullscreen_(false), renderSize_(0, 0), scaledRenderSize_(0, 0),
23	dpiScale_(1.f), guiScale_(100), autoGuiScale_(false)	4✔
24	{
25	std::fill(keyboard.begin(), keyboard.end(), false);	4✔
26	}	4✔
27
28	Position VideoDriver::GetMousePos() const	262✔
29	{
30	return mouse_xy.pos;	262✔
31	}
32
33	/**
34	* Funktion zum Auslesen ob die Linke Maustaste gedrückt ist.
35	*
36	* @return @p true bei Gedrückt, @p false bei Losgelassen
37	*/
38	bool VideoDriver::GetMouseStateL() const	110✔
39	{
40	return mouse_xy.ldown;	110✔
41	}
42
43	/**
44	* Funktion zum Auslesen ob die Rechte Maustaste gedrückt ist.
45	*
46	* @return @p true bei Gedrückt, @p false bei Losgelassen
47	*/
48	bool VideoDriver::GetMouseStateR() const	×
49	{
50	return mouse_xy.rdown;	×
51	}
52
53	/**
54	* Function to check if at least 1 finger is on screen.
55	*
56	* @return @p true at least 1 finger, @p false when mouse used
57	*/
NEW 58	bool VideoDriver::IsTouchEvent() const	×
59	{
NEW 60	return mouse_xy.num_tfingers > 0;	×
61	}
62
63	VideoMode VideoDriver::FindClosestVideoMode(const VideoMode& mode) const	7✔
64	{
65	std::vector<VideoMode> avModes;	7✔
66	ListVideoModes(avModes);	7✔
67	if(avModes.empty())	7✔
68	throw std::runtime_error("No supported video modes found!");	×
69	unsigned minSizeDiff = std::numeric_limits<unsigned>::max();	7✔
70	VideoMode best = avModes.front();	7✔
71	for(const VideoMode& current : avModes)	28✔
72	{
73	const auto dw = absDiff(current.width, mode.width);	21✔
74	const auto dh = absDiff(current.height, mode.height);	21✔
75	unsigned sizeDiff = dw * dw + dh * dh;	21✔
76	if(sizeDiff < minSizeDiff)	21✔
77	{
78	minSizeDiff = sizeDiff;	15✔
79	best = current;	15✔
80	}
81	}
82	return best;	14✔
83	}
84
85	void VideoDriver::SetNewSize(VideoMode windowSize, Extent renderSize)	21✔
86	{
87	windowSize_ = windowSize;	21✔
88	renderSize_ = renderSize;	21✔
89
90	const auto ratioXY = PointF(renderSize_) / PointF(windowSize_.width, windowSize_.height);	21✔
91	dpiScale_ = (ratioXY.x + ratioXY.y) / 2.f; // use the average ratio of both axes	21✔
92
93	if(autoGuiScale_)	21✔
94	guiScale_ = GuiScale(getGuiScaleRange().recommendedPercent);	1✔
95
96	scaledRenderSize_ = guiScale_.screenToView<Extent>(renderSize);	21✔
97	}	21✔
98
99	void VideoDriver::setGuiScalePercent(unsigned percent)	7✔
100	{
101	autoGuiScale_ = (percent == 0);	7✔
102	if(autoGuiScale_)	7✔
103	percent = getGuiScaleRange().recommendedPercent;	1✔
104
105	if(guiScale_.percent() == percent)	7✔
106	return;	1✔
107
108	// translate current mouse position to screen space
109	const auto screenPos = guiScale_.viewToScreen(mouse_xy.pos);	6✔
110
111	guiScale_ = GuiScale(percent);	6✔
112	scaledRenderSize_ = guiScale_.screenToView<Extent>(renderSize_);	6✔
113	CallBack->WindowResized();	6✔
114
115	// move cursor to new position in view space
116	// must happen after window resize event to avoid drawing spurious hover events
117	mouse_xy.pos = guiScale_.screenToView(screenPos);	6✔
118	CallBack->Msg_MouseMove(mouse_xy);	6✔
119	}
120
121	GuiScaleRange VideoDriver::getGuiScaleRange() const	6✔
122	{
123	constexpr auto min = 100u;	6✔
124	const auto recommended = std::max(min, helpers::iround<unsigned>(dpiScale_ * 100.f));	6✔
125	const auto maxScaleXY = renderSize_ / PointF(800.f, 600.f);	6✔
126	const auto maxScale = std::min(maxScaleXY.x, maxScaleXY.y);	6✔
127	// if the window shrinks below its minimum size of 800x600, max can be smaller than recommended
128	const auto max = std::max(helpers::iround<unsigned>(maxScale * 100.f), recommended);	6✔
129
130	return GuiScaleRange{min, max, recommended};	6✔
131	}

Return-To-The-Roots / s25client / 20447000712

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous