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

93.48

/src/RaZ/Script/LuaRenderSystem.cpp

#include "RaZ/Render/RenderSystem.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::registerRenderSystemTypes() {
  sol::state& state = getState();

  {
    sol::usertype<RenderSystem> renderSystem = state.new_usertype<RenderSystem>("RenderSystem",
                                                                                sol::constructors<RenderSystem(),
                                                                                                  RenderSystem(unsigned int, unsigned int)
#if !defined(RAZ_NO_WINDOW)
                                                                                                  ,
                                                                                                  RenderSystem(unsigned int, unsigned int, const std::string&),
                                                                                                  RenderSystem(unsigned int, unsigned int, const std::string&,
                                                                                                               WindowSetting),
                                                                                                  RenderSystem(unsigned int, unsigned int, const std::string&,
                                                                                                               WindowSetting, uint8_t)
#endif
                                                                                                  >(),
                                                                                sol::base_classes, sol::bases<System>());
    renderSystem["getSceneWidth"]      = &RenderSystem::getSceneWidth;
    renderSystem["getSceneHeight"]     = &RenderSystem::getSceneHeight;
#if !defined(RAZ_NO_WINDOW)
    renderSystem["hasWindow"]          = &RenderSystem::hasWindow;
    renderSystem["getWindow"]          = PickNonConstOverload<>(&RenderSystem::getWindow);
#endif
    renderSystem["getGeometryPass"]    = PickNonConstOverload<>(&RenderSystem::getGeometryPass);
    renderSystem["getRenderGraph"]     = PickNonConstOverload<>(&RenderSystem::getRenderGraph);
    renderSystem["hasCubemap"]         = &RenderSystem::hasCubemap;
    renderSystem["getCubemap"]         = [] (const RenderSystem& r) { return &r.getCubemap(); };
    renderSystem["setCubemap"]         = [] (RenderSystem& r, Cubemap& c) { r.setCubemap(std::move(c)); };
#if defined(RAZ_USE_XR)
    renderSystem["enableXr"]           = [] (RenderSystem& r, XrSystem* x) { r.enableXr(*x); };
#endif
#if !defined(RAZ_NO_WINDOW)
    renderSystem["createWindow"]       = sol::overload([] (RenderSystem& r, unsigned int w, unsigned int h) { r.createWindow(w, h); },
                                                       [] (RenderSystem& r, unsigned int w, unsigned int h, const std::string& t) { r.createWindow(w, h, t); },
                                                       [] (RenderSystem& r, unsigned int w, unsigned int h, const std::string& t,
                                                           WindowSetting s) { r.createWindow(w, h, t, s); },
                                                       PickOverload<unsigned int, unsigned int, const std::string&, WindowSetting,
                                                                    uint8_t>(&RenderSystem::createWindow));
#endif
    renderSystem["resizeViewport"]     = &RenderSystem::resizeViewport;
    renderSystem["updateLights"]       = &RenderSystem::updateLights;
    renderSystem["updateShaders"]      = &RenderSystem::updateShaders;
    renderSystem["updateMaterials"]    = sol::overload([] (const RenderSystem& r) { r.updateMaterials(); },
                                                       [] (const RenderSystem& r, const MeshRenderer* m) { r.updateMaterials(*m); });
    renderSystem["saveToImage"]        = sol::overload([] (const RenderSystem& r, const FilePath& p) { r.saveToImage(p); },
                                                       [] (const RenderSystem& r, const FilePath& p, TextureFormat f) { r.saveToImage(p, f); },
                                                       PickOverload<const FilePath&, TextureFormat, PixelDataType>(&RenderSystem::saveToImage));
    renderSystem["removeCubemap"]      = &RenderSystem::removeCubemap;

    state.new_enum<TextureFormat>("TextureFormat", {
      { "RED",           TextureFormat::RED },
      { "GREEN",         TextureFormat::GREEN },
      { "BLUE",          TextureFormat::BLUE },
      { "RG",            TextureFormat::RG },
      { "RGB",           TextureFormat::RGB },
      { "BGR",           TextureFormat::BGR },
      { "RGBA",          TextureFormat::RGBA },
      { "BGRA",          TextureFormat::BGRA },
      { "SRGB",          TextureFormat::SRGB },
      { "DEPTH",         TextureFormat::DEPTH },
      { "STENCIL",       TextureFormat::STENCIL },
      { "DEPTH_STENCIL", TextureFormat::DEPTH_STENCIL }
    });

    state.new_enum<PixelDataType>("PixelDataType", {
      { "UBYTE", PixelDataType::UBYTE },
      { "FLOAT", PixelDataType::FLOAT }
    });
  }
}

} // namespace Raz

1	#include "RaZ/Render/RenderSystem.hpp"
2	#include "RaZ/Script/LuaWrapper.hpp"
3	#include "RaZ/Utils/TypeUtils.hpp"
4
5	#define SOL_ALL_SAFETIES_ON 1
6	#include "sol/sol.hpp"
7
8	namespace Raz {
9
10	using namespace TypeUtils;
11
12	void LuaWrapper::registerRenderSystemTypes() {	2✔
13	sol::state& state = getState();	2✔
14
15	{
16	sol::usertype<RenderSystem> renderSystem = state.new_usertype<RenderSystem>("RenderSystem",
17	sol::constructors<RenderSystem(),	×
18	RenderSystem(unsigned int, unsigned int)
19	#if !defined(RAZ_NO_WINDOW)
20	,
21	RenderSystem(unsigned int, unsigned int, const std::string&),
22	RenderSystem(unsigned int, unsigned int, const std::string&,
23	WindowSetting),
24	RenderSystem(unsigned int, unsigned int, const std::string&,
25	WindowSetting, uint8_t)
26	#endif
27	>(),
28	sol::base_classes, sol::bases<System>());	2✔
29	renderSystem["getSceneWidth"] = &RenderSystem::getSceneWidth;	2✔
30	renderSystem["getSceneHeight"] = &RenderSystem::getSceneHeight;	2✔
31	#if !defined(RAZ_NO_WINDOW)
32	renderSystem["hasWindow"] = &RenderSystem::hasWindow;	2✔
33	renderSystem["getWindow"] = PickNonConstOverload<>(&RenderSystem::getWindow);	2✔
34	#endif
35	renderSystem["getGeometryPass"] = PickNonConstOverload<>(&RenderSystem::getGeometryPass);	2✔
36	renderSystem["getRenderGraph"] = PickNonConstOverload<>(&RenderSystem::getRenderGraph);	2✔
37	renderSystem["hasCubemap"] = &RenderSystem::hasCubemap;	2✔
38	renderSystem["getCubemap"] = [] (const RenderSystem& r) { return &r.getCubemap(); };	3✔
39	renderSystem["setCubemap"] = [] (RenderSystem& r, Cubemap& c) { r.setCubemap(std::move(c)); };	3✔
40	#if defined(RAZ_USE_XR)
41	renderSystem["enableXr"] = [] (RenderSystem& r, XrSystem* x) { r.enableXr(*x); };	2✔
42	#endif
43	#if !defined(RAZ_NO_WINDOW)
44	renderSystem["createWindow"] = sol::overload([] (RenderSystem& r, unsigned int w, unsigned int h) { r.createWindow(w, h); },	2✔
45	[] (RenderSystem& r, unsigned int w, unsigned int h, const std::string& t) { r.createWindow(w, h, t); },	×
46	[] (RenderSystem& r, unsigned int w, unsigned int h, const std::string& t,	×
47	WindowSetting s) { r.createWindow(w, h, t, s); },	1✔
48	PickOverload<unsigned int, unsigned int, const std::string&, WindowSetting,
49	uint8_t>(&RenderSystem::createWindow));	4✔
50	#endif
51	renderSystem["resizeViewport"] = &RenderSystem::resizeViewport;	2✔
52	renderSystem["updateLights"] = &RenderSystem::updateLights;	2✔
53	renderSystem["updateShaders"] = &RenderSystem::updateShaders;	2✔
54	renderSystem["updateMaterials"] = sol::overload([] (const RenderSystem& r) { r.updateMaterials(); },	3✔
55	[] (const RenderSystem& r, const MeshRenderer* m) { r.updateMaterials(*m); });	3✔
56	renderSystem["saveToImage"] = sol::overload([] (const RenderSystem& r, const FilePath& p) { r.saveToImage(p); },	3✔
57	[] (const RenderSystem& r, const FilePath& p, TextureFormat f) { r.saveToImage(p, f); },	1✔
58	PickOverload<const FilePath&, TextureFormat, PixelDataType>(&RenderSystem::saveToImage));	4✔
59	renderSystem["removeCubemap"] = &RenderSystem::removeCubemap;	2✔
60
61	state.new_enum<TextureFormat>("TextureFormat", {	2✔
62	{ "RED", TextureFormat::RED },	2✔
63	{ "GREEN", TextureFormat::GREEN },	2✔
64	{ "BLUE", TextureFormat::BLUE },	2✔
65	{ "RG", TextureFormat::RG },	2✔
66	{ "RGB", TextureFormat::RGB },	2✔
67	{ "BGR", TextureFormat::BGR },	2✔
68	{ "RGBA", TextureFormat::RGBA },	2✔
69	{ "BGRA", TextureFormat::BGRA },	2✔
70	{ "SRGB", TextureFormat::SRGB },	2✔
71	{ "DEPTH", TextureFormat::DEPTH },	2✔
72	{ "STENCIL", TextureFormat::STENCIL },	2✔
73	{ "DEPTH_STENCIL", TextureFormat::DEPTH_STENCIL }	2✔
74	});
75
76	state.new_enum<PixelDataType>("PixelDataType", {	2✔
77	{ "UBYTE", PixelDataType::UBYTE },	2✔
78	{ "FLOAT", PixelDataType::FLOAT }	2✔
79	});
80	}	2✔
81	}	2✔
82
83	} // 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