lint-0.1.0
checks.x86_64-linux.lint
· build #73
· raw
unpackPhase
1unpacking source archive /nix/store/cr46smbpqz380cj4wiyaqk7mki02dlpj-source2source root is sourceconfigurePhase
3-- The C compiler identification is Clang 23.1.34-- The CXX compiler identification is Clang 23.1.35-- Detecting C compiler ABI info6-- Detecting C compiler ABI info - done7-- Check for working C compiler: /nix/store/q5hx5j4n0c1nyxaxfgd1dzca3r3q3c25-clang-wrapper-23.1.3/bin/clang - skipped8-- Detecting C compile features9-- Detecting C compile features - done10-- Detecting CXX compiler ABI info11-- Detecting CXX compiler ABI info - done12-- Check for working CXX compiler: /nix/store/q5hx5j4n0c1nyxaxfgd1dzca3r3q3c25-clang-wrapper-23.1.3/bin/clang++ - skipped13-- Detecting CXX compile features14-- Detecting CXX compile features - done15-- Found Vulkan: /nix/store/la62431p5qf1ggr3rdzql9dksv5fhicc-vulkan-loader-1.4.363.0/lib/libvulkan.so (found version "1.4.363") missing components: glslc glslangValidator16-- Performing Test CMAKE_HAVE_LIBC_PTHREAD17-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success18-- Found Threads: TRUE19-- Found PkgConfig: /nix/store/s70gz6bvz74c36xigh5m2ab2cqli08cv-pkg-config-wrapper-0.29.2/bin/pkg-config (found version "0.29.2")20-- Checking for module 'stb'21-- Found stb, version 122-- Found Fontconfig: /nix/store/p3y4rk4gjnhs80339qq7jixjbhplqc16-fontconfig-2.18.3-lib/lib/libfontconfig.so (found version "2.18.3")23-- Found Freetype: /nix/store/zj7yb55h1zpmxmw6dp817n6y0370wji0-freetype-2.14.3/lib/libfreetype.so (found version "2.14.3")24-- Configuring done (15.9s)25-- Generating done (0.3s)26-- Build files have been written to: /build/source/buildbuildPhase
27Running clang-tidy in 16 threads for 46 files out of 46 in compilation database ...28[ 1/46][8.9s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/src/string.cpp29[ 2/46][34.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/event.cpp30[ 3/46][36.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/tests/binary_reader.cpp31/build/source/wren_utils/include/wren/utils/binary_reader.hpp:12:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]32 12 | BinaryReader(const std::span<const std::byte>& data)33 | ^34 | explicit 3536[ 4/46][41.2s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_math/tests/matrix.cpp37/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]38 27 | Mat(const data_t& data) : data_(data) {}39 | ^40 | explicit 41/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]42 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {43 | ^44 | explicit 45/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]46 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}47 | ^48 | explicit 49/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]50 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}51 | ^52 | explicit 53/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]54 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {55 | ^56 | explicit 57/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]58 34 | constexpr Vec(std::array<T, N> data) : data(data) {}59 | ^60 | explicit 61/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]62 36 | constexpr Vec(float scalar) {63 | ^64 | explicit 65/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]66 43 | constexpr Vec(Args... args)67 | ^68 | explicit 69/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]70 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}71 | ^72 | explicit 73/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]74 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}75 | ^76 | explicit 77/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]78 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}79 | ^80 | explicit 81/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]82 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}83 | ^84 | explicit 85/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]86 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}87 | ^88 | explicit 89/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]90 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}91 | ^92 | explicit 9394[ 5/46][3.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/src/string_reader.cpp95/build/source/wren_utils/include/wren/utils/string_reader.hpp:9:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]96 9 | StringReader(const std::string_view& input) : input_(input) {}97 | ^98 | explicit 99100[ 6/46][51.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/src/filesystem.cpp101/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]102 23 | Err(T error, std::source_location loc = std::source_location::current())103 | ^104 | explicit 105/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]106 25 | Err(const std::error_code& ec,107 | ^108 | explicit 109110[ 7/46][42.4s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/tests/enums.cpp111[ 8/46][38.9s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_physics/tests/raycast.cpp112/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]113 27 | Mat(const data_t& data) : data_(data) {}114 | ^115 | explicit 116/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]117 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {118 | ^119 | explicit 120/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]121 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}122 | ^123 | explicit 124/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]125 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}126 | ^127 | explicit 128/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]129 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {130 | ^131 | explicit 132/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]133 15 | Quaternion(Vec<T, 3> euler_angles) {134 | ^135 | explicit 136/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]137 34 | constexpr Vec(std::array<T, N> data) : data(data) {}138 | ^139 | explicit 140/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]141 36 | constexpr Vec(float scalar) {142 | ^143 | explicit 144/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]145 43 | constexpr Vec(Args... args)146 | ^147 | explicit 148/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]149 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}150 | ^151 | explicit 152/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]153 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}154 | ^155 | explicit 156/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]157 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}158 | ^159 | explicit 160/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]161 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}162 | ^163 | explicit 164/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]165 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}166 | ^167 | explicit 168/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]169 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}170 | ^171 | explicit 172173[ 9/46][28.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/input.cpp174[10/46][127.2s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/utils/device.cpp175/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]176 23 | Err(T error, std::source_location loc = std::source_location::current())177 | ^178 | explicit 179/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]180 25 | Err(const std::error_code& ec,181 | ^182 | explicit 183184[11/46][130.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/scene/deserialization.cpp185/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]186 27 | Mat(const data_t& data) : data_(data) {}187 | ^188 | explicit 189/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]190 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {191 | ^192 | explicit 193/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]194 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}195 | ^196 | explicit 197/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]198 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}199 | ^200 | explicit 201/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]202 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {203 | ^204 | explicit 205/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]206 15 | Quaternion(Vec<T, 3> euler_angles) {207 | ^208 | explicit 209/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]210 34 | constexpr Vec(std::array<T, N> data) : data(data) {}211 | ^212 | explicit 213/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]214 36 | constexpr Vec(float scalar) {215 | ^216 | explicit 217/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]218 43 | constexpr Vec(Args... args)219 | ^220 | explicit 221/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]222 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}223 | ^224 | explicit 225/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]226 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}227 | ^228 | explicit 229/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]230 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}231 | ^232 | explicit 233/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]234 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}235 | ^236 | explicit 237/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]238 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}239 | ^240 | explicit 241/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]242 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}243 | ^244 | explicit 245/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]246 23 | Err(T error, std::source_location loc = std::source_location::current())247 | ^248 | explicit 249/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]250 25 | Err(const std::error_code& ec,251 | ^252 | explicit 253/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]254 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}255 | ^256 | explicit 257258[12/46][131.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/utils/vulkan.cpp259/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]260 23 | Err(T error, std::source_location loc = std::source_location::current())261 | ^262 | explicit 263/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]264 25 | Err(const std::error_code& ec,265 | ^266 | explicit 267268[13/46][134.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_vk/src/buffer.cpp269/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]270 23 | Err(T error, std::source_location loc = std::source_location::current())271 | ^272 | explicit 273/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]274 25 | Err(const std::error_code& ec,275 | ^276 | explicit 277/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]278 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}279 | ^280 | explicit 281282[14/46][25.4s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/scene/components/collider.cpp283/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]284 27 | Mat(const data_t& data) : data_(data) {}285 | ^286 | explicit 287/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]288 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {289 | ^290 | explicit 291/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]292 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}293 | ^294 | explicit 295/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]296 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}297 | ^298 | explicit 299/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]300 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {301 | ^302 | explicit 303/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]304 15 | Quaternion(Vec<T, 3> euler_angles) {305 | ^306 | explicit 307/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]308 34 | constexpr Vec(std::array<T, N> data) : data(data) {}309 | ^310 | explicit 311/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]312 36 | constexpr Vec(float scalar) {313 | ^314 | explicit 315/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]316 43 | constexpr Vec(Args... args)317 | ^318 | explicit 319/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]320 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}321 | ^322 | explicit 323/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]324 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}325 | ^326 | explicit 327/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]328 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}329 | ^330 | explicit 331/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]332 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}333 | ^334 | explicit 335/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]336 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}337 | ^338 | explicit 339/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]340 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}341 | ^342 | explicit 343344[15/46][139.0s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/mesh.cpp345/build/source/wren/src/mesh.cpp:25:9: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]346 25 | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |347 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~348/build/source/wren/src/mesh.cpp:46:9: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]349 46 | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |350 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~351/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]352 27 | Mat(const data_t& data) : data_(data) {}353 | ^354 | explicit 355/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]356 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {357 | ^358 | explicit 359/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]360 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}361 | ^362 | explicit 363/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]364 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}365 | ^366 | explicit 367/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]368 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {369 | ^370 | explicit 371/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]372 34 | constexpr Vec(std::array<T, N> data) : data(data) {}373 | ^374 | explicit 375/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]376 36 | constexpr Vec(float scalar) {377 | ^378 | explicit 379/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]380 43 | constexpr Vec(Args... args)381 | ^382 | explicit 383/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]384 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}385 | ^386 | explicit 387/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]388 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}389 | ^390 | explicit 391/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]392 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}393 | ^394 | explicit 395/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]396 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}397 | ^398 | explicit 399/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]400 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}401 | ^402 | explicit 403/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]404 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}405 | ^406 | explicit 407/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]408 23 | Err(T error, std::source_location loc = std::source_location::current())409 | ^410 | explicit 411/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]412 25 | Err(const std::error_code& ec,413 | ^414 | explicit 415/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]416 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}417 | ^418 | explicit 419420[16/46][139.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_text/src/font.cpp421/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]422 26 | PassResources(std::string target_prefix)423 | ^424 | explicit 425/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]426 27 | Mat(const data_t& data) : data_(data) {}427 | ^428 | explicit 429/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]430 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {431 | ^432 | explicit 433/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]434 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}435 | ^436 | explicit 437/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]438 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}439 | ^440 | explicit 441/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]442 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {443 | ^444 | explicit 445/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]446 34 | constexpr Vec(std::array<T, N> data) : data(data) {}447 | ^448 | explicit 449/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]450 36 | constexpr Vec(float scalar) {451 | ^452 | explicit 453/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]454 43 | constexpr Vec(Args... args)455 | ^456 | explicit 457/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]458 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}459 | ^460 | explicit 461/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]462 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}463 | ^464 | explicit 465/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]466 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}467 | ^468 | explicit 469/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]470 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}471 | ^472 | explicit 473/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]474 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}475 | ^476 | explicit 477/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]478 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}479 | ^480 | explicit 481/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]482 23 | Err(T error, std::source_location loc = std::source_location::current())483 | ^484 | explicit 485/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]486 25 | Err(const std::error_code& ec,487 | ^488 | explicit 489/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]490 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}491 | ^492 | explicit 493494[17/46][140.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/render_pass.cpp495/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]496 26 | PassResources(std::string target_prefix)497 | ^498 | explicit 499/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]500 27 | Mat(const data_t& data) : data_(data) {}501 | ^502 | explicit 503/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]504 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {505 | ^506 | explicit 507/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]508 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}509 | ^510 | explicit 511/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]512 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}513 | ^514 | explicit 515/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]516 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {517 | ^518 | explicit 519/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]520 34 | constexpr Vec(std::array<T, N> data) : data(data) {}521 | ^522 | explicit 523/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]524 36 | constexpr Vec(float scalar) {525 | ^526 | explicit 527/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]528 43 | constexpr Vec(Args... args)529 | ^530 | explicit 531/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]532 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}533 | ^534 | explicit 535/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]536 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}537 | ^538 | explicit 539/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]540 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}541 | ^542 | explicit 543/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]544 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}545 | ^546 | explicit 547/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]548 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}549 | ^550 | explicit 551/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]552 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}553 | ^554 | explicit 555/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]556 23 | Err(T error, std::source_location loc = std::source_location::current())557 | ^558 | explicit 559/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]560 25 | Err(const std::error_code& ec,561 | ^562 | explicit 563/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]564 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}565 | ^566 | explicit 567568[18/46][142.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_gui/src/instance.cpp569/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]570 26 | PassResources(std::string target_prefix)571 | ^572 | explicit 573/build/source/wren_gui/include/wren/gui/instance.hpp:31:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]574 31 | Instance(const Context::Ref& context);575 | ^576 | explicit 577/build/source/wren_gui/src/instance.cpp:111:11: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]578 111 | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |579 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~580/build/source/wren_gui/src/instance.cpp:132:11: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]581 132 | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |582 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~583/build/source/wren_gui/src/instance.cpp:168:55: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]584 168 | pen_x += static_cast<float>(character->advance >> 6);585 | ~~ ^586/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]587 27 | Mat(const data_t& data) : data_(data) {}588 | ^589 | explicit 590/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]591 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {592 | ^593 | explicit 594/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]595 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}596 | ^597 | explicit 598/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]599 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}600 | ^601 | explicit 602/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]603 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {604 | ^605 | explicit 606/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]607 34 | constexpr Vec(std::array<T, N> data) : data(data) {}608 | ^609 | explicit 610/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]611 36 | constexpr Vec(float scalar) {612 | ^613 | explicit 614/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]615 43 | constexpr Vec(Args... args)616 | ^617 | explicit 618/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]619 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}620 | ^621 | explicit 622/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]623 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}624 | ^625 | explicit 626/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]627 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}628 | ^629 | explicit 630/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]631 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}632 | ^633 | explicit 634/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]635 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}636 | ^637 | explicit 638/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]639 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}640 | ^641 | explicit 642/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]643 23 | Err(T error, std::source_location loc = std::source_location::current())644 | ^645 | explicit 646/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]647 25 | Err(const std::error_code& ec,648 | ^649 | explicit 650/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]651 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}652 | ^653 | explicit 654655[19/46][144.3s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_vk/src/shader.cpp656/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]657 34 | constexpr Vec(std::array<T, N> data) : data(data) {}658 | ^659 | explicit 660/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]661 36 | constexpr Vec(float scalar) {662 | ^663 | explicit 664/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]665 43 | constexpr Vec(Args... args)666 | ^667 | explicit 668/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]669 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}670 | ^671 | explicit 672/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]673 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}674 | ^675 | explicit 676/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]677 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}678 | ^679 | explicit 680/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]681 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}682 | ^683 | explicit 684/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]685 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}686 | ^687 | explicit 688/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]689 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}690 | ^691 | explicit 692/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]693 23 | Err(T error, std::source_location loc = std::source_location::current())694 | ^695 | explicit 696/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]697 25 | Err(const std::error_code& ec,698 | ^699 | explicit 700/build/source/wren_utils/include/wren/utils/string_reader.hpp:9:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]701 9 | StringReader(const std::string_view& input) : input_(input) {}702 | ^703 | explicit 704705[20/46][144.9s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/inspector_panel.cpp706/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]707 27 | Mat(const data_t& data) : data_(data) {}708 | ^709 | explicit 710/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]711 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {712 | ^713 | explicit 714/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]715 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}716 | ^717 | explicit 718/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]719 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}720 | ^721 | explicit 722/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]723 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {724 | ^725 | explicit 726/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]727 15 | Quaternion(Vec<T, 3> euler_angles) {728 | ^729 | explicit 730/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]731 34 | constexpr Vec(std::array<T, N> data) : data(data) {}732 | ^733 | explicit 734/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]735 36 | constexpr Vec(float scalar) {736 | ^737 | explicit 738/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]739 43 | constexpr Vec(Args... args)740 | ^741 | explicit 742/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]743 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}744 | ^745 | explicit 746/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]747 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}748 | ^749 | explicit 750/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]751 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}752 | ^753 | explicit 754/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]755 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}756 | ^757 | explicit 758/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]759 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}760 | ^761 | explicit 762/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]763 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}764 | ^765 | explicit 766/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]767 23 | Err(T error, std::source_location loc = std::source_location::current())768 | ^769 | explicit 770/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]771 25 | Err(const std::error_code& ec,772 | ^773 | explicit 774/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]775 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}776 | ^777 | explicit 778779[21/46][6.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_math/src/geometry.cpp780/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]781 27 | Mat(const data_t& data) : data_(data) {}782 | ^783 | explicit 784/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]785 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {786 | ^787 | explicit 788/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]789 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}790 | ^791 | explicit 792/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]793 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}794 | ^795 | explicit 796/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]797 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {798 | ^799 | explicit 800/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]801 34 | constexpr Vec(std::array<T, N> data) : data(data) {}802 | ^803 | explicit 804/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]805 36 | constexpr Vec(float scalar) {806 | ^807 | explicit 808/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]809 43 | constexpr Vec(Args... args)810 | ^811 | explicit 812/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]813 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}814 | ^815 | explicit 816/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]817 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}818 | ^819 | explicit 820/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]821 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}822 | ^823 | explicit 824/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]825 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}826 | ^827 | explicit 828/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]829 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}830 | ^831 | explicit 832/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]833 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}834 | ^835 | explicit 836837[22/46][137.2s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/graph.cpp838/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]839 26 | PassResources(std::string target_prefix)840 | ^841 | explicit 842/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]843 27 | Mat(const data_t& data) : data_(data) {}844 | ^845 | explicit 846/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]847 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {848 | ^849 | explicit 850/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]851 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}852 | ^853 | explicit 854/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]855 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}856 | ^857 | explicit 858/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]859 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {860 | ^861 | explicit 862/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]863 34 | constexpr Vec(std::array<T, N> data) : data(data) {}864 | ^865 | explicit 866/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]867 36 | constexpr Vec(float scalar) {868 | ^869 | explicit 870/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]871 43 | constexpr Vec(Args... args)872 | ^873 | explicit 874/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]875 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}876 | ^877 | explicit 878/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]879 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}880 | ^881 | explicit 882/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]883 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}884 | ^885 | explicit 886/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]887 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}888 | ^889 | explicit 890/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]891 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}892 | ^893 | explicit 894/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]895 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}896 | ^897 | explicit 898/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]899 23 | Err(T error, std::source_location loc = std::source_location::current())900 | ^901 | explicit 902/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]903 25 | Err(const std::error_code& ec,904 | ^905 | explicit 906/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]907 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}908 | ^909 | explicit 910911[23/46][23.7s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/scene/scene.cpp912/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]913 27 | Mat(const data_t& data) : data_(data) {}914 | ^915 | explicit 916/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]917 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {918 | ^919 | explicit 920/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]921 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}922 | ^923 | explicit 924/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]925 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}926 | ^927 | explicit 928/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]929 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {930 | ^931 | explicit 932/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]933 15 | Quaternion(Vec<T, 3> euler_angles) {934 | ^935 | explicit 936/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]937 34 | constexpr Vec(std::array<T, N> data) : data(data) {}938 | ^939 | explicit 940/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]941 36 | constexpr Vec(float scalar) {942 | ^943 | explicit 944/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]945 43 | constexpr Vec(Args... args)946 | ^947 | explicit 948/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]949 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}950 | ^951 | explicit 952/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]953 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}954 | ^955 | explicit 956/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]957 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}958 | ^959 | explicit 960/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]961 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}962 | ^963 | explicit 964/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]965 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}966 | ^967 | explicit 968/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]969 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}970 | ^971 | explicit 972973[24/46][20.3s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_utils/tests/string_reader.cpp974/build/source/wren_utils/include/wren/utils/string_reader.hpp:9:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]975 9 | StringReader(const std::string_view& input) : input_(input) {}976 | ^977 | explicit 978979[25/46][152.9s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/editor.cpp980/build/source/editor/src/editor.cpp:111:7: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]981 111 | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |982 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~983 112 | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |984 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~985 113 | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus |986 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~987/build/source/editor/src/editor.cpp:141:7: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]988 141 | if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable) {989 | ^~~~~~~~~~~~~~ ~990/build/source/editor/src/editor.cpp:151:33: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]991 151 | dockspace_flags | ImGuiDockNodeFlags_DockSpace);992 | ^~~~~~~~~~~~~~~ ~993/build/source/editor/src/editor.hpp:32:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]994 32 | Editor(const std::shared_ptr<wren::Context>& ctx);995 | ^996 | explicit 997/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]998 26 | PassResources(std::string target_prefix)999 | ^1000 | explicit 1001/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1002 27 | Mat(const data_t& data) : data_(data) {}1003 | ^1004 | explicit 1005/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1006 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1007 | ^1008 | explicit 1009/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1010 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1011 | ^1012 | explicit 1013/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1014 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1015 | ^1016 | explicit 1017/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1018 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1019 | ^1020 | explicit 1021/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1022 15 | Quaternion(Vec<T, 3> euler_angles) {1023 | ^1024 | explicit 1025/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1026 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1027 | ^1028 | explicit 1029/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1030 36 | constexpr Vec(float scalar) {1031 | ^1032 | explicit 1033/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1034 43 | constexpr Vec(Args... args)1035 | ^1036 | explicit 1037/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1038 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1039 | ^1040 | explicit 1041/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1042 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1043 | ^1044 | explicit 1045/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1046 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1047 | ^1048 | explicit 1049/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1050 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1051 | ^1052 | explicit 1053/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1054 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1055 | ^1056 | explicit 1057/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1058 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1059 | ^1060 | explicit 1061/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1062 23 | Err(T error, std::source_location loc = std::source_location::current())1063 | ^1064 | explicit 1065/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1066 25 | Err(const std::error_code& ec,1067 | ^1068 | explicit 1069/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1070 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1071 | ^1072 | explicit 10731074[26/46][119.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/texture.cpp1075/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1076 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1077 | ^1078 | explicit 1079/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1080 36 | constexpr Vec(float scalar) {1081 | ^1082 | explicit 1083/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1084 43 | constexpr Vec(Args... args)1085 | ^1086 | explicit 1087/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1088 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1089 | ^1090 | explicit 1091/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1092 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1093 | ^1094 | explicit 1095/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1096 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1097 | ^1098 | explicit 1099/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1100 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1101 | ^1102 | explicit 1103/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1104 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1105 | ^1106 | explicit 1107/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1108 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1109 | ^1110 | explicit 1111/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1112 23 | Err(T error, std::source_location loc = std::source_location::current())1113 | ^1114 | explicit 1115/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1116 25 | Err(const std::error_code& ec,1117 | ^1118 | explicit 1119/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1120 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1121 | ^1122 | explicit 11231124[27/46][32.3s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_math/tests/geometry.cpp1125/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1126 27 | Mat(const data_t& data) : data_(data) {}1127 | ^1128 | explicit 1129/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1130 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1131 | ^1132 | explicit 1133/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1134 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1135 | ^1136 | explicit 1137/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1138 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1139 | ^1140 | explicit 1141/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1142 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1143 | ^1144 | explicit 1145/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1146 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1147 | ^1148 | explicit 1149/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1150 36 | constexpr Vec(float scalar) {1151 | ^1152 | explicit 1153/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1154 43 | constexpr Vec(Args... args)1155 | ^1156 | explicit 1157/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1158 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1159 | ^1160 | explicit 1161/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1162 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1163 | ^1164 | explicit 1165/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1166 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1167 | ^1168 | explicit 1169/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1170 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1171 | ^1172 | explicit 1173/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1174 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1175 | ^1176 | explicit 1177/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1178 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1179 | ^1180 | explicit 11811182[28/46][16.5s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/scene_panel.cpp1183/build/source/editor/src/scene_panel.cpp:35:7: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]1184 35 | entity_node_flags |= ImGuiTreeNodeFlags_Selected;1185 | ^~~~~~~~~~~~~~~~~ ~~1186/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1187 27 | Mat(const data_t& data) : data_(data) {}1188 | ^1189 | explicit 1190/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1191 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1192 | ^1193 | explicit 1194/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1195 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1196 | ^1197 | explicit 1198/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1199 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1200 | ^1201 | explicit 1202/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1203 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1204 | ^1205 | explicit 1206/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1207 15 | Quaternion(Vec<T, 3> euler_angles) {1208 | ^1209 | explicit 1210/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1211 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1212 | ^1213 | explicit 1214/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1215 36 | constexpr Vec(float scalar) {1216 | ^1217 | explicit 1218/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1219 43 | constexpr Vec(Args... args)1220 | ^1221 | explicit 1222/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1223 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1224 | ^1225 | explicit 1226/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1227 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1228 | ^1229 | explicit 1230/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1231 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1232 | ^1233 | explicit 1234/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1235 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1236 | ^1237 | explicit 1238/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1239 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1240 | ^1241 | explicit 1242/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1243 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1244 | ^1245 | explicit 12461247[29/46][116.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/graphics_context.cpp1248/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1249 23 | Err(T error, std::source_location loc = std::source_location::current())1250 | ^1251 | explicit 1252/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1253 25 | Err(const std::error_code& ec,1254 | ^1255 | explicit 12561257[30/46][7.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_vk/src/memory.cpp1258[31/46][28.3s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_math/tests/vector.cpp1259/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1260 27 | Mat(const data_t& data) : data_(data) {}1261 | ^1262 | explicit 1263/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1264 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1265 | ^1266 | explicit 1267/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1268 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1269 | ^1270 | explicit 1271/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1272 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1273 | ^1274 | explicit 1275/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1276 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1277 | ^1278 | explicit 1279/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1280 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1281 | ^1282 | explicit 1283/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1284 36 | constexpr Vec(float scalar) {1285 | ^1286 | explicit 1287/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1288 43 | constexpr Vec(Args... args)1289 | ^1290 | explicit 1291/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1292 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1293 | ^1294 | explicit 1295/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1296 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1297 | ^1298 | explicit 1299/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1300 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1301 | ^1302 | explicit 1303/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1304 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1305 | ^1306 | explicit 1307/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1308 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1309 | ^1310 | explicit 1311/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1312 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1313 | ^1314 | explicit 13151316[32/46][19.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_physics/src/ray.cpp1317/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1318 27 | Mat(const data_t& data) : data_(data) {}1319 | ^1320 | explicit 1321/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1322 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1323 | ^1324 | explicit 1325/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1326 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1327 | ^1328 | explicit 1329/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1330 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1331 | ^1332 | explicit 1333/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1334 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1335 | ^1336 | explicit 1337/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1338 15 | Quaternion(Vec<T, 3> euler_angles) {1339 | ^1340 | explicit 1341/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1342 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1343 | ^1344 | explicit 1345/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1346 36 | constexpr Vec(float scalar) {1347 | ^1348 | explicit 1349/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1350 43 | constexpr Vec(Args... args)1351 | ^1352 | explicit 1353/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1354 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1355 | ^1356 | explicit 1357/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1358 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1359 | ^1360 | explicit 1361/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1362 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1363 | ^1364 | explicit 1365/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1366 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1367 | ^1368 | explicit 1369/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1370 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1371 | ^1372 | explicit 1373/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1374 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1375 | ^1376 | explicit 13771378[33/46][40.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_vk/src/vulkan.cpp1379[34/46][112.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/scene/serialization.cpp1380/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1381 27 | Mat(const data_t& data) : data_(data) {}1382 | ^1383 | explicit 1384/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1385 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1386 | ^1387 | explicit 1388/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1389 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1390 | ^1391 | explicit 1392/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1393 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1394 | ^1395 | explicit 1396/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1397 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1398 | ^1399 | explicit 1400/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1401 15 | Quaternion(Vec<T, 3> euler_angles) {1402 | ^1403 | explicit 1404/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1405 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1406 | ^1407 | explicit 1408/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1409 36 | constexpr Vec(float scalar) {1410 | ^1411 | explicit 1412/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1413 43 | constexpr Vec(Args... args)1414 | ^1415 | explicit 1416/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1417 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1418 | ^1419 | explicit 1420/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1421 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1422 | ^1423 | explicit 1424/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1425 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1426 | ^1427 | explicit 1428/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1429 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1430 | ^1431 | explicit 1432/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1433 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1434 | ^1435 | explicit 1436/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1437 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1438 | ^1439 | explicit 1440/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1441 23 | Err(T error, std::source_location loc = std::source_location::current())1442 | ^1443 | explicit 1444/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1445 25 | Err(const std::error_code& ec,1446 | ^1447 | explicit 1448/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1449 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1450 | ^1451 | explicit 14521453[35/46][62.4s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/render_target.cpp1454/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1455 26 | PassResources(std::string target_prefix)1456 | ^1457 | explicit 1458/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1459 27 | Mat(const data_t& data) : data_(data) {}1460 | ^1461 | explicit 1462/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1463 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1464 | ^1465 | explicit 1466/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1467 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1468 | ^1469 | explicit 1470/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1471 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1472 | ^1473 | explicit 1474/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1475 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1476 | ^1477 | explicit 1478/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1479 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1480 | ^1481 | explicit 1482/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1483 36 | constexpr Vec(float scalar) {1484 | ^1485 | explicit 1486/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1487 43 | constexpr Vec(Args... args)1488 | ^1489 | explicit 1490/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1491 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1492 | ^1493 | explicit 1494/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1495 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1496 | ^1497 | explicit 1498/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1499 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1500 | ^1501 | explicit 1502/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1503 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1504 | ^1505 | explicit 1506/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1507 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1508 | ^1509 | explicit 1510/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1511 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1512 | ^1513 | explicit 1514/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1515 23 | Err(T error, std::source_location loc = std::source_location::current())1516 | ^1517 | explicit 1518/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1519 25 | Err(const std::error_code& ec,1520 | ^1521 | explicit 1522/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1523 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1524 | ^1525 | explicit 15261527[36/46][59.0s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/utils/queue.cpp1528/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1529 23 | Err(T error, std::source_location loc = std::source_location::current())1530 | ^1531 | explicit 1532/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1533 25 | Err(const std::error_code& ec,1534 | ^1535 | explicit 15361537[37/46][51.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/renderer.cpp1538/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1539 26 | PassResources(std::string target_prefix)1540 | ^1541 | explicit 1542/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1543 27 | Mat(const data_t& data) : data_(data) {}1544 | ^1545 | explicit 1546/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1547 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1548 | ^1549 | explicit 1550/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1551 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1552 | ^1553 | explicit 1554/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1555 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1556 | ^1557 | explicit 1558/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1559 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1560 | ^1561 | explicit 1562/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1563 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1564 | ^1565 | explicit 1566/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1567 36 | constexpr Vec(float scalar) {1568 | ^1569 | explicit 1570/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1571 43 | constexpr Vec(Args... args)1572 | ^1573 | explicit 1574/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1575 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1576 | ^1577 | explicit 1578/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1579 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1580 | ^1581 | explicit 1582/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1583 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1584 | ^1585 | explicit 1586/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1587 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1588 | ^1589 | explicit 1590/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1591 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1592 | ^1593 | explicit 1594/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1595 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1596 | ^1597 | explicit 1598/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1599 23 | Err(T error, std::source_location loc = std::source_location::current())1600 | ^1601 | explicit 1602/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1603 25 | Err(const std::error_code& ec,1604 | ^1605 | explicit 1606/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1607 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1608 | ^1609 | explicit 16101611[38/46][65.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/filesystem_panel.cpp1612/build/source/editor/src/filesystem_panel.cpp:17:31: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]1613 17 | if (!file.is_directory()) flags |= ImGuiTreeNodeFlags_Leaf;1614 | ^~~~~ ~~1615/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1616 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1617 | ^1618 | explicit 1619/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1620 36 | constexpr Vec(float scalar) {1621 | ^1622 | explicit 1623/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1624 43 | constexpr Vec(Args... args)1625 | ^1626 | explicit 1627/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1628 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1629 | ^1630 | explicit 1631/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1632 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1633 | ^1634 | explicit 1635/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1636 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1637 | ^1638 | explicit 1639/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1640 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1641 | ^1642 | explicit 1643/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1644 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1645 | ^1646 | explicit 1647/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1648 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1649 | ^1650 | explicit 1651/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1652 23 | Err(T error, std::source_location loc = std::source_location::current())1653 | ^1654 | explicit 1655/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1656 25 | Err(const std::error_code& ec,1657 | ^1658 | explicit 16591660[39/46][51.8s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/assets/manager.cpp1661/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1662 26 | PassResources(std::string target_prefix)1663 | ^1664 | explicit 1665/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1666 27 | Mat(const data_t& data) : data_(data) {}1667 | ^1668 | explicit 1669/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1670 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1671 | ^1672 | explicit 1673/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1674 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1675 | ^1676 | explicit 1677/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1678 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1679 | ^1680 | explicit 1681/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1682 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1683 | ^1684 | explicit 1685/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1686 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1687 | ^1688 | explicit 1689/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1690 36 | constexpr Vec(float scalar) {1691 | ^1692 | explicit 1693/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1694 43 | constexpr Vec(Args... args)1695 | ^1696 | explicit 1697/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1698 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1699 | ^1700 | explicit 1701/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1702 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1703 | ^1704 | explicit 1705/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1706 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1707 | ^1708 | explicit 1709/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1710 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1711 | ^1712 | explicit 1713/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1714 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1715 | ^1716 | explicit 1717/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1718 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1719 | ^1720 | explicit 1721/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1722 23 | Err(T error, std::source_location loc = std::source_location::current())1723 | ^1724 | explicit 1725/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1726 25 | Err(const std::error_code& ec,1727 | ^1728 | explicit 1729/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1730 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1731 | ^1732 | explicit 17331734[40/46][60.7s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren_vk/src/image.cpp1735/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1736 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1737 | ^1738 | explicit 1739/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1740 36 | constexpr Vec(float scalar) {1741 | ^1742 | explicit 1743/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1744 43 | constexpr Vec(Args... args)1745 | ^1746 | explicit 1747/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1748 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1749 | ^1750 | explicit 1751/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1752 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1753 | ^1754 | explicit 1755/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1756 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1757 | ^1758 | explicit 1759/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1760 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1761 | ^1762 | explicit 1763/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1764 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1765 | ^1766 | explicit 1767/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1768 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1769 | ^1770 | explicit 1771/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1772 23 | Err(T error, std::source_location loc = std::source_location::current())1773 | ^1774 | explicit 1775/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1776 25 | Err(const std::error_code& ec,1777 | ^1778 | explicit 17791780[41/46][64.6s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/window.cpp1781/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1782 23 | Err(T error, std::source_location loc = std::source_location::current())1783 | ^1784 | explicit 1785/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1786 25 | Err(const std::error_code& ec,1787 | ^1788 | explicit 17891790[42/46][45.5s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/mesh_loader.cpp1791/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1792 27 | Mat(const data_t& data) : data_(data) {}1793 | ^1794 | explicit 1795/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1796 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1797 | ^1798 | explicit 1799/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1800 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1801 | ^1802 | explicit 1803/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1804 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1805 | ^1806 | explicit 1807/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1808 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1809 | ^1810 | explicit 1811/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1812 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1813 | ^1814 | explicit 1815/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1816 36 | constexpr Vec(float scalar) {1817 | ^1818 | explicit 1819/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1820 43 | constexpr Vec(Args... args)1821 | ^1822 | explicit 1823/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1824 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1825 | ^1826 | explicit 1827/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1828 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1829 | ^1830 | explicit 1831/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1832 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1833 | ^1834 | explicit 1835/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1836 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1837 | ^1838 | explicit 1839/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1840 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1841 | ^1842 | explicit 1843/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1844 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1845 | ^1846 | explicit 1847/build/source/wren_utils/include/wren/utils/binary_reader.hpp:12:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1848 12 | BinaryReader(const std::span<const std::byte>& data)1849 | ^1850 | explicit 1851/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1852 23 | Err(T error, std::source_location loc = std::source_location::current())1853 | ^1854 | explicit 1855/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1856 25 | Err(const std::error_code& ec,1857 | ^1858 | explicit 1859/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1860 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1861 | ^1862 | explicit 18631864[43/46][64.4s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/ui.cpp1865/build/source/editor/src/ui.cpp:252:3: error: use of a signed integer operand with a binary bitwise operator [bugprone-signed-bitwise,-warnings-as-errors]1866 252 | io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;1867 | ^~~~~~~~~~~~~~ ~~1868/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1869 26 | PassResources(std::string target_prefix)1870 | ^1871 | explicit 1872/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1873 27 | Mat(const data_t& data) : data_(data) {}1874 | ^1875 | explicit 1876/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1877 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1878 | ^1879 | explicit 1880/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1881 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1882 | ^1883 | explicit 1884/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1885 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1886 | ^1887 | explicit 1888/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1889 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1890 | ^1891 | explicit 1892/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1893 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1894 | ^1895 | explicit 1896/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1897 36 | constexpr Vec(float scalar) {1898 | ^1899 | explicit 1900/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1901 43 | constexpr Vec(Args... args)1902 | ^1903 | explicit 1904/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1905 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1906 | ^1907 | explicit 1908/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1909 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1910 | ^1911 | explicit 1912/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1913 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1914 | ^1915 | explicit 1916/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1917 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1918 | ^1919 | explicit 1920/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1921 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1922 | ^1923 | explicit 1924/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1925 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}1926 | ^1927 | explicit 1928/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1929 23 | Err(T error, std::source_location loc = std::source_location::current())1930 | ^1931 | explicit 1932/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1933 25 | Err(const std::error_code& ec,1934 | ^1935 | explicit 1936/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1937 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}1938 | ^1939 | explicit 19401941[44/46][74.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/wren/src/application.cpp1942/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1943 26 | PassResources(std::string target_prefix)1944 | ^1945 | explicit 1946/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1947 27 | Mat(const data_t& data) : data_(data) {}1948 | ^1949 | explicit 1950/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1951 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {1952 | ^1953 | explicit 1954/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1955 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}1956 | ^1957 | explicit 1958/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1959 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}1960 | ^1961 | explicit 1962/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1963 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {1964 | ^1965 | explicit 1966/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1967 34 | constexpr Vec(std::array<T, N> data) : data(data) {}1968 | ^1969 | explicit 1970/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1971 36 | constexpr Vec(float scalar) {1972 | ^1973 | explicit 1974/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1975 43 | constexpr Vec(Args... args)1976 | ^1977 | explicit 1978/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1979 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}1980 | ^1981 | explicit 1982/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1983 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}1984 | ^1985 | explicit 1986/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1987 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}1988 | ^1989 | explicit 1990/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1991 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}1992 | ^1993 | explicit 1994/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1995 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}1996 | ^1997 | explicit 1998/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]1999 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}2000 | ^2001 | explicit 2002/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2003 23 | Err(T error, std::source_location loc = std::source_location::current())2004 | ^2005 | explicit 2006/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2007 25 | Err(const std::error_code& ec,2008 | ^2009 | explicit 2010/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2011 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}2012 | ^2013 | explicit 20142015[45/46][69.3s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/examples/nand/main.cpp2016/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2017 26 | PassResources(std::string target_prefix)2018 | ^2019 | explicit 2020/build/source/wren_gui/include/wren/gui/instance.hpp:31:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2021 31 | Instance(const Context::Ref& context);2022 | ^2023 | explicit 2024/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2025 27 | Mat(const data_t& data) : data_(data) {}2026 | ^2027 | explicit 2028/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2029 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {2030 | ^2031 | explicit 2032/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2033 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}2034 | ^2035 | explicit 2036/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2037 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}2038 | ^2039 | explicit 2040/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2041 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {2042 | ^2043 | explicit 2044/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2045 15 | Quaternion(Vec<T, 3> euler_angles) {2046 | ^2047 | explicit 2048/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2049 34 | constexpr Vec(std::array<T, N> data) : data(data) {}2050 | ^2051 | explicit 2052/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2053 36 | constexpr Vec(float scalar) {2054 | ^2055 | explicit 2056/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2057 43 | constexpr Vec(Args... args)2058 | ^2059 | explicit 2060/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2061 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}2062 | ^2063 | explicit 2064/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2065 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}2066 | ^2067 | explicit 2068/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2069 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}2070 | ^2071 | explicit 2072/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2073 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}2074 | ^2075 | explicit 2076/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2077 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}2078 | ^2079 | explicit 2080/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2081 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}2082 | ^2083 | explicit 2084/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2085 23 | Err(T error, std::source_location loc = std::source_location::current())2086 | ^2087 | explicit 2088/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2089 25 | Err(const std::error_code& ec,2090 | ^2091 | explicit 2092/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2093 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}2094 | ^2095 | explicit 20962097[46/46][50.1s] /nix/store/065b08l7x6wkfl80si3yyjcjk87ivmya-clang-tools-23.1.3/bin/clang-tidy --use-color -p=build -quiet /build/source/editor/src/main.cpp2098/build/source/editor/src/editor.hpp:32:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2099 32 | Editor(const std::shared_ptr<wren::Context>& ctx);2100 | ^2101 | explicit 2102/build/source/wren/include/wren/render_pass.hpp:26:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2103 26 | PassResources(std::string target_prefix)2104 | ^2105 | explicit 2106/build/source/wren_math/include/wren/math/matrix.hpp:27:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2107 27 | Mat(const data_t& data) : data_(data) {}2108 | ^2109 | explicit 2110/build/source/wren_math/include/wren/math/matrix.hpp:28:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2111 28 | Mat(const std::array<std::array<T, Cols>, Rows>& rows) {2112 | ^2113 | explicit 2114/build/source/wren_math/include/wren/math/matrix.hpp:88:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2115 88 | Mat4f(const Mat<float, 4, 4>& other) : Mat<float, 4, 4>(other) {}2116 | ^2117 | explicit 2118/build/source/wren_math/include/wren/math/matrix.hpp:89:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2119 89 | Mat4f(const data_t& data) : Mat<float, 4, 4>(data) {}2120 | ^2121 | explicit 2122/build/source/wren_math/include/wren/math/matrix.hpp:90:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2123 90 | Mat4f(const Mat<float, 3, 3>& other) : Mat(identity()) {2124 | ^2125 | explicit 2126/build/source/wren_math/include/wren/math/quaternion.hpp:15:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2127 15 | Quaternion(Vec<T, 3> euler_angles) {2128 | ^2129 | explicit 2130/build/source/wren_math/include/wren/math/vector.hpp:34:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2131 34 | constexpr Vec(std::array<T, N> data) : data(data) {}2132 | ^2133 | explicit 2134/build/source/wren_math/include/wren/math/vector.hpp:36:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2135 36 | constexpr Vec(float scalar) {2136 | ^2137 | explicit 2138/build/source/wren_math/include/wren/math/vector.hpp:43:13: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2139 43 | constexpr Vec(Args... args)2140 | ^2141 | explicit 2142/build/source/wren_math/include/wren/math/vector.hpp:170:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2143 170 | Vec2f(const Vec<float, 2>& other) : Vec<float, 2>(other) {}2144 | ^2145 | explicit 2146/build/source/wren_math/include/wren/math/vector.hpp:183:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2147 183 | Vec2i(const Vec<int, 2>& other) : Vec<int, 2>(other) {}2148 | ^2149 | explicit 2150/build/source/wren_math/include/wren/math/vector.hpp:195:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2151 195 | constexpr Vec3f(const auto& other) : Vec<float, 3>(other) {}2152 | ^2153 | explicit 2154/build/source/wren_math/include/wren/math/vector.hpp:198:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2155 198 | constexpr Vec3f(const Vec<float, 3>& other) : Vec<float, 3>(other) {}2156 | ^2157 | explicit 2158/build/source/wren_math/include/wren/math/vector.hpp:214:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2159 214 | constexpr Vec4f(const auto& other) : Vec<float, 4>(other) {}2160 | ^2161 | explicit 2162/build/source/wren_math/include/wren/math/vector.hpp:219:13: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2163 219 | constexpr Vec4f(const Vec<float, 4>& other) : Vec<float, 4>(other) {}2164 | ^2165 | explicit 2166/build/source/wren_utils/include/wren/utils/result.hpp:23:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2167 23 | Err(T error, std::source_location loc = std::source_location::current())2168 | ^2169 | explicit 2170/build/source/wren_utils/include/wren/utils/result.hpp:25:3: error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2171 25 | Err(const std::error_code& ec,2172 | ^2173 | explicit 2174/build/source/wren_vk/include/wren/vk/buffer.hpp:29:3: error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [cppcoreguidelines-explicit-constructor,-warnings-as-errors]2175 29 | Buffer(const VmaAllocator& allocator) : allocator_(allocator) {}2176 | ^2177 | explicit 2178