17345118961

Committed 30 Aug 2025 02:47PM UTC coverage: 74.197% (-0.1%) from 74.324%

Build # 17345118961

Build Type

push

github

Committed by

Razakhel

Commit Message

[CI] Changed the used Ubuntu & macOS images

- Bumped Ubuntu to 24.04, making available GCC 13.3.0 (previously 11.4.4) & Clang 18.1.3 (previously 14.0.0)

- Forced macOS to 15, making available Apple Clang 17.0 (previously 15.0)

Run Details

8319 of 11212 relevant lines covered (74.2%)

1740.9 hits per line

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

86.76

/src/RaZ/Script/LuaOverlayBase.cpp

#include "RaZ/Render/Overlay.hpp"
#include "RaZ/Render/Texture.hpp"
#include "RaZ/Script/LuaWrapper.hpp"
#include "RaZ/Utils/TypeUtils.hpp"

#define SOL_ALL_SAFETIES_ON 1
#include "sol/sol.hpp"

namespace Raz {

using namespace TypeUtils;

void LuaWrapper::registerOverlayBaseTypes() {
  sol::state& state = getState();

  {
    sol::usertype<Overlay> overlay = state.new_usertype<Overlay>("Overlay",
                                                                 sol::constructors<Overlay()>());
    overlay["isEmpty"]          = &Overlay::isEmpty;
    overlay["addWindow"]        = sol::overload([] (Overlay& o, std::string t) { return &o.addWindow(std::move(t)); },
                                                [] (Overlay& o, std::string t, const Vec2f& s) { return &o.addWindow(std::move(t), s); },
                                                PickOverload<std::string, const Vec2f&, const Vec2f&>(&Overlay::addWindow));
    overlay["hasKeyboardFocus"] = &Overlay::hasKeyboardFocus;
    overlay["hasMouseFocus"]    = &Overlay::hasMouseFocus;
    overlay["render"]           = &Overlay::render;
  }

  {
    sol::usertype<OverlayWindow> overlayWindow = state.new_usertype<OverlayWindow>("OverlayWindow",
                                                                                   sol::constructors<OverlayWindow(std::string),
                                                                                                     OverlayWindow(std::string, const Vec2f&),
                                                                                                     OverlayWindow(std::string, const Vec2f&, const Vec2f&)>());
    overlayWindow["isEnabled"]       = &OverlayWindow::isEnabled;
    overlayWindow["enable"]          = sol::overload([] (OverlayWindow& r) { r.enable(); },
                                                     PickOverload<bool>(&OverlayWindow::enable));
    overlayWindow["disable"]         = &OverlayWindow::disable;
    overlayWindow["addLabel"]        = &OverlayWindow::addLabel;
    overlayWindow["addColoredLabel"] = sol::overload([] (OverlayWindow& w, std::string t, const Color& c) { return &w.addColoredLabel(std::move(t), c); },
                                                     PickOverload<std::string, const Color&, float>(&OverlayWindow::addColoredLabel),
                                                     [] (OverlayWindow& w, std::string t,
                                                         float r, float g, float b) { return &w.addColoredLabel(std::move(t), r, g, b); },
                                                     PickOverload<std::string, float, float, float, float>(&OverlayWindow::addColoredLabel));
    overlayWindow["addButton"]       = &OverlayWindow::addButton;
    overlayWindow["addCheckbox"]     = &OverlayWindow::addCheckbox;
    overlayWindow["addSlider"]       = &OverlayWindow::addSlider;
    overlayWindow["addTextbox"]      = sol::overload([] (OverlayWindow& w, std::string l,
                                                         std::function<void(const std::string&)> c) { return &w.addTextbox(std::move(l),
                                                                                                                           std::move(c)); },
                                                     PickOverload<std::string, std::function<void(const std::string&)>,
                                                                  std::string>(&OverlayWindow::addTextbox));
    overlayWindow["addTextArea"]     = sol::overload([] (OverlayWindow& w, std::string l,
                                                         std::function<void(const std::string&)> c) { return &w.addTextArea(std::move(l), std::move(c)); },
                                                     [] (OverlayWindow& w, std::string l, std::function<void(const std::string&)> c,
                                                         std::string t) { return &w.addTextArea(std::move(l), std::move(c), std::move(t)); },
                                                     PickOverload<std::string, std::function<void(const std::string&)>,
                                                                  std::string, float>(&OverlayWindow::addTextArea));
    overlayWindow["addListBox"]      = sol::overload([] (OverlayWindow& w, std::string l, std::vector<std::string> e,
                                                         std::function<void(const std::string&, std::size_t)> c) { return &w.addListBox(std::move(l),
                                                                                                                                        std::move(e),
                                                                                                                                        std::move(c)); },
                                                     PickOverload<std::string, std::vector<std::string>, std::function<void(const std::string&, std::size_t)>,
                                                                  std::size_t>(&OverlayWindow::addListBox));
    overlayWindow["addDropdown"]     = sol::overload([] (OverlayWindow& w, std::string l, std::vector<std::string> e,
                                                         std::function<void(const std::string&, std::size_t)> c) { return &w.addDropdown(std::move(l),
                                                                                                                                         std::move(e),
                                                                                                                                         std::move(c)); },
                                                     PickOverload<std::string, std::vector<std::string>, std::function<void(const std::string&, std::size_t)>,
                                                                  std::size_t>(&OverlayWindow::addDropdown));
    overlayWindow["addColorPicker"]  = &OverlayWindow::addColorPicker;
    overlayWindow["addTexture"]      = sol::overload(PickOverload<const Texture2D&, unsigned int, unsigned int>(&OverlayWindow::addTexture),
                                                     PickOverload<const Texture2D&>(&OverlayWindow::addTexture));
    overlayWindow["addProgressBar"]  = sol::overload([] (OverlayWindow& w, int min, int max) { return &w.addProgressBar(min, max); },
                                                     PickOverload<int, int, bool>(&OverlayWindow::addProgressBar));
    overlayWindow["addPlot"]         = sol::overload([] (OverlayWindow& w, std::string l, std::size_t c) { return &w.addPlot(std::move(l), c); },
                                                     [] (OverlayWindow& w, std::string l, std::size_t c,
                                                         std::string x) { return &w.addPlot(std::move(l), c, std::move(x)); },
                                                     [] (OverlayWindow& w, std::string l, std::size_t c, std::string x,
                                                         std::string y) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y)); },
                                                     [] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y,
                                                         float min) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min); },
                                                     [] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y, float min,
                                                         float max) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min, max); },
                                                     [] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y, float min, float max,
                                                         bool lock) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min, max, lock); },
                                                     PickOverload<std::string, std::size_t, std::string, std::string,
                                                                  float, float, bool, float>(&OverlayWindow::addPlot));
    overlayWindow["addSeparator"]    = &OverlayWindow::addSeparator;
    overlayWindow["addFrameTime"]    = &OverlayWindow::addFrameTime;
    overlayWindow["addFpsCounter"]   = &OverlayWindow::addFpsCounter;
    overlayWindow["render"]          = &OverlayWindow::render;
  }
}

} // namespace Raz

1	#include "RaZ/Render/Overlay.hpp"
2	#include "RaZ/Render/Texture.hpp"
3	#include "RaZ/Script/LuaWrapper.hpp"
4	#include "RaZ/Utils/TypeUtils.hpp"
5
6	#define SOL_ALL_SAFETIES_ON 1
7	#include "sol/sol.hpp"
8
9	namespace Raz {
10
11	using namespace TypeUtils;
12
13	void LuaWrapper::registerOverlayBaseTypes() {	2✔
14	sol::state& state = getState();	2✔
15
16	{
17	sol::usertype<Overlay> overlay = state.new_usertype<Overlay>("Overlay",
18	sol::constructors<Overlay()>());	2✔
19	overlay["isEmpty"] = &Overlay::isEmpty;	2✔
20	overlay["addWindow"] = sol::overload([] (Overlay& o, std::string t) { return &o.addWindow(std::move(t)); },	3✔
21	[] (Overlay& o, std::string t, const Vec2f& s) { return &o.addWindow(std::move(t), s); },	1✔
22	PickOverload<std::string, const Vec2f&, const Vec2f&>(&Overlay::addWindow));	4✔
23	overlay["hasKeyboardFocus"] = &Overlay::hasKeyboardFocus;	2✔
24	overlay["hasMouseFocus"] = &Overlay::hasMouseFocus;	2✔
25	overlay["render"] = &Overlay::render;	2✔
26	}	2✔
27
28	{
29	sol::usertype<OverlayWindow> overlayWindow = state.new_usertype<OverlayWindow>("OverlayWindow",
30	sol::constructors<OverlayWindow(std::string),	×
31	OverlayWindow(std::string, const Vec2f&),
32	OverlayWindow(std::string, const Vec2f&, const Vec2f&)>());	2✔
33	overlayWindow["isEnabled"] = &OverlayWindow::isEnabled;	2✔
34	overlayWindow["enable"] = sol::overload([] (OverlayWindow& r) { r.enable(); },	3✔
35	PickOverload<bool>(&OverlayWindow::enable));	4✔
36	overlayWindow["disable"] = &OverlayWindow::disable;	2✔
37	overlayWindow["addLabel"] = &OverlayWindow::addLabel;	2✔
38	overlayWindow["addColoredLabel"] = sol::overload([] (OverlayWindow& w, std::string t, const Color& c) { return &w.addColoredLabel(std::move(t), c); },	3✔
39	PickOverload<std::string, const Color&, float>(&OverlayWindow::addColoredLabel),	2✔
40	[] (OverlayWindow& w, std::string t,	×
41	float r, float g, float b) { return &w.addColoredLabel(std::move(t), r, g, b); },	×
42	PickOverload<std::string, float, float, float, float>(&OverlayWindow::addColoredLabel));	4✔
43	overlayWindow["addButton"] = &OverlayWindow::addButton;	2✔
44	overlayWindow["addCheckbox"] = &OverlayWindow::addCheckbox;	2✔
45	overlayWindow["addSlider"] = &OverlayWindow::addSlider;	2✔
46	overlayWindow["addTextbox"] = sol::overload([] (OverlayWindow& w, std::string l,	2✔
47	std::function<void(const std::string&)> c) { return &w.addTextbox(std::move(l),	3✔
48	std::move(c)); },	3✔
49	PickOverload<std::string, std::function<void(const std::string&)>,
50	std::string>(&OverlayWindow::addTextbox));	4✔
51	overlayWindow["addTextArea"] = sol::overload([] (OverlayWindow& w, std::string l,	2✔
52	std::function<void(const std::string&)> c) { return &w.addTextArea(std::move(l), std::move(c)); },	1✔
53	[] (OverlayWindow& w, std::string l, std::function<void(const std::string&)> c,	×
54	std::string t) { return &w.addTextArea(std::move(l), std::move(c), std::move(t)); },	1✔
55	PickOverload<std::string, std::function<void(const std::string&)>,
56	std::string, float>(&OverlayWindow::addTextArea));	4✔
57	overlayWindow["addListBox"] = sol::overload([] (OverlayWindow& w, std::string l, std::vector<std::string> e,	2✔
58	std::function<void(const std::string&, std::size_t)> c) { return &w.addListBox(std::move(l),	3✔
59	std::move(e),	1✔
60	std::move(c)); },	3✔
61	PickOverload<std::string, std::vector<std::string>, std::function<void(const std::string&, std::size_t)>,
62	std::size_t>(&OverlayWindow::addListBox));	4✔
63	overlayWindow["addDropdown"] = sol::overload([] (OverlayWindow& w, std::string l, std::vector<std::string> e,	2✔
64	std::function<void(const std::string&, std::size_t)> c) { return &w.addDropdown(std::move(l),	3✔
65	std::move(e),	1✔
66	std::move(c)); },	3✔
67	PickOverload<std::string, std::vector<std::string>, std::function<void(const std::string&, std::size_t)>,
68	std::size_t>(&OverlayWindow::addDropdown));	4✔
69	overlayWindow["addColorPicker"] = &OverlayWindow::addColorPicker;	2✔
70	overlayWindow["addTexture"] = sol::overload(PickOverload<const Texture2D&, unsigned int, unsigned int>(&OverlayWindow::addTexture),	2✔
71	PickOverload<const Texture2D&>(&OverlayWindow::addTexture));	4✔
72	overlayWindow["addProgressBar"] = sol::overload([] (OverlayWindow& w, int min, int max) { return &w.addProgressBar(min, max); },	3✔
73	PickOverload<int, int, bool>(&OverlayWindow::addProgressBar));	4✔
74	overlayWindow["addPlot"] = sol::overload([] (OverlayWindow& w, std::string l, std::size_t c) { return &w.addPlot(std::move(l), c); },	3✔
75	[] (OverlayWindow& w, std::string l, std::size_t c,	×
76	std::string x) { return &w.addPlot(std::move(l), c, std::move(x)); },	1✔
77	[] (OverlayWindow& w, std::string l, std::size_t c, std::string x,	×
78	std::string y) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y)); },	1✔
79	[] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y,	×
80	float min) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min); },	1✔
81	[] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y, float min,	×
82	float max) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min, max); },	1✔
83	[] (OverlayWindow& w, std::string l, std::size_t c, std::string x, std::string y, float min, float max,	×
84	bool lock) { return &w.addPlot(std::move(l), c, std::move(x), std::move(y), min, max, lock); },	1✔
85	PickOverload<std::string, std::size_t, std::string, std::string,
86	float, float, bool, float>(&OverlayWindow::addPlot));	4✔
87	overlayWindow["addSeparator"] = &OverlayWindow::addSeparator;	2✔
88	overlayWindow["addFrameTime"] = &OverlayWindow::addFrameTime;	2✔
89	overlayWindow["addFpsCounter"] = &OverlayWindow::addFpsCounter;	2✔
90	overlayWindow["render"] = &OverlayWindow::render;	2✔
91	}	2✔
92	}	2✔
93
94	} // namespace Raz

Razakhel / RaZ / 17345118961

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