misc

markaren · markaren · commit 4a51d97f1015 · 2024-07-04T13:31:23.000+02:00
diff --git a/include/threepp/math/Spherical.hpp b/include/threepp/math/Spherical.hpp
@@ -3,10 +3,10 @@
 #ifndef THREEPP_SPHERICAL_HPP
 #define THREEPP_SPHERICAL_HPP
 
-#include "threepp/math/Vector3.hpp"
-
 namespace threepp {
 
+    class Vector3;
+
     class Spherical {
 
     public:
diff --git a/include/threepp/math/SphericalHarmonics3.hpp b/include/threepp/math/SphericalHarmonics3.hpp
@@ -35,7 +35,7 @@ namespace threepp {
 
         SphericalHarmonis3& lerp(const SphericalHarmonis3& sh, float alpha);
 
-        const std::vector<Vector3>& getCoefficients() const;
+        [[nodiscard]] const std::vector<Vector3>& getCoefficients() const;
 
     private:
         std::vector<Vector3> coefficients_;
diff --git a/include/threepp/math/Vector3.hpp b/include/threepp/math/Vector3.hpp
@@ -272,23 +272,23 @@ namespace threepp {
             return os;
         }
 
-        inline static Vector3 X() {
+        static Vector3 X() {
             return {1, 0, 0};
         }
 
-        inline static Vector3 Y() {
+        static Vector3 Y() {
             return {0, 1, 0};
         }
 
-        inline static Vector3 Z() {
+        static Vector3 Z() {
             return {0, 0, 1};
         }
 
-        inline static Vector3 ZEROS() {
+        static Vector3 ZEROS() {
             return {0, 0, 0};
         }
 
-        inline static Vector3 ONES() {
+        static Vector3 ONES() {
             return {1, 1, 1};
         }
     };
diff --git a/include/threepp/math/float_view.hpp b/include/threepp/math/float_view.hpp
@@ -16,123 +16,123 @@ namespace threepp {
         float_view(float value = 0)
             : value_(value) {}
 
-        inline operator float() const {
+        operator float() const {
 
             return value_;
         }
 
-        inline float_view& operator=(float v) {
+        float_view& operator=(float v) {
 
             this->value_ = v;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float operator*(float f) const {
+        float operator*(float f) const {
 
             return value_ * f;
         }
 
-        inline float operator*(const float_view& f) const {
+        float operator*(const float_view& f) const {
 
             return value_ * f.value_;
         }
 
-        inline float_view& operator*=(float f) {
+        float_view& operator*=(float f) {
 
             value_ *= f;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float operator/(float f) const {
+        float operator/(float f) const {
 
             return value_ / f;
         }
 
-        inline float_view& operator/=(float f) {
+        float_view& operator/=(float f) {
 
             value_ /= f;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float operator+(float f) const {
+        float operator+(float f) const {
 
             return value_ + f;
         }
 
-        inline float operator+(const float_view& f) const {
+        float operator+(const float_view& f) const {
 
             return value_ + f.value_;
         }
 
-        inline float_view& operator+=(float f) {
+        float_view& operator+=(float f) {
 
             value_ += f;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float operator-(float f) const {
+        float operator-(float f) const {
 
             return value_ - f;
         }
 
-        inline float operator-(const float_view& f) const {
+        float operator-(const float_view& f) const {
 
             return value_ - f.value_;
         }
 
-        inline float_view& operator-=(float f) {
+        float_view& operator-=(float f) {
 
             value_ -= f;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float_view& operator++() {
+        float_view& operator++() {
 
             value_++;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline float_view& operator--() {
+        float_view& operator--() {
 
             value_--;
             if (f_) f_.value()();
 
             return *this;
         }
 
-        inline bool operator==(float other) const {
+        bool operator==(float other) const {
 
             return value_ == other;
         }
 
-        inline bool operator!=(float other) const {
+        bool operator!=(float other) const {
 
             return value_ != other;
         }
 
-        inline bool operator==(const float_view& other) const {
+        bool operator==(const float_view& other) const {
 
             return value_ == other.value_;
         }
 
-        inline bool operator!=(const float_view& other) const {
+        bool operator!=(const float_view& other) const {
 
             return value_ != other.value_;
         }
 
-        inline constexpr float_view& clamp(float min, float max) {
+        constexpr float_view& clamp(float min, float max) {
 
             value_ = std::max(min, std::min(max, value_));
 
diff --git a/include/threepp/textures/Image.hpp b/include/threepp/textures/Image.hpp
@@ -2,7 +2,6 @@
 #ifndef THREEPP_IMAGE_HPP
 #define THREEPP_IMAGE_HPP
 
-#include <memory>
 #include <utility>
 #include <variant>
 #include <vector>
diff --git a/include/threepp/utils/StringUtils.hpp b/include/threepp/utils/StringUtils.hpp
@@ -24,7 +24,9 @@ namespace threepp::utils {
     }
 
     template<class ArrayLike>
-    inline std::string join(const ArrayLike& v, char c = '\n') {
+    std::string join(const ArrayLike& v, char c = '\n') {
+
+        if (v.empty()) return "";
 
         auto p = v.cbegin();
         std::stringstream ss;
@@ -39,21 +41,21 @@ namespace threepp::utils {
     inline void replaceAll(std::string& text, const std::string& replaceFrom, const std::string& replaceTo) {
         std::string& result = text;
         size_t start_pos = 0;
-        while (((start_pos = text.find(replaceFrom, start_pos)) != std::string::npos)) {
+        while ((start_pos = text.find(replaceFrom, start_pos)) != std::string::npos) {
             result.replace(start_pos, replaceFrom.length(), replaceTo);
             start_pos += replaceTo.length();
         }
     }
 
     inline std::string trimStart(std::string s) {
-        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+        s.erase(s.begin(), std::ranges::find_if(s, [](unsigned char ch) {
                     return !std::isspace(ch);
                 }));
         return s;
     }
 
     inline void trimStartInplace(std::string& s) {
-        s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+        s.erase(s.begin(), std::ranges::find_if(s, [](unsigned char ch) {
                     return !std::isspace(ch);
                 }));
     }
@@ -85,13 +87,13 @@ namespace threepp::utils {
     }
 
     inline std::string toLower(std::string s) {
-        std::transform(s.begin(), s.end(), s.begin(),
+        std::ranges::transform(s, s.begin(),
                        [](unsigned char c) { return std::tolower(c); });
         return s;
     }
 
     inline void toLowerInplace(std::string& s) {
-        std::transform(s.begin(), s.end(), s.begin(),
+        std::ranges::transform(s, s.begin(),
                        [](unsigned char c) { return std::tolower(c); });
     }
 
diff --git a/src/threepp/core/EventDispatcher.cpp b/src/threepp/core/EventDispatcher.cpp
@@ -16,7 +16,7 @@ bool EventDispatcher::hasEventListener(const std::string& type, const EventListe
     if (!listeners_.contains(type)) return false;
 
     auto& listenerArray = listeners_.at(type);
-    return std::find(listenerArray.begin(), listenerArray.end(), listener) != listenerArray.end();
+    return std::ranges::find(listenerArray, listener) != listenerArray.end();
 }
 
 void EventDispatcher::removeEventListener(const std::string& type, const EventListener* listener) {
@@ -26,8 +26,7 @@ void EventDispatcher::removeEventListener(const std::string& type, const EventLi
     auto& listenerArray = listeners_.at(type);
     if (listenerArray.empty()) return;
 
-    auto find = std::find(listenerArray.begin(), listenerArray.end(), listener);
-    if (find != listenerArray.end()) {
+    if (const auto find = std::ranges::find(listenerArray, listener); find != listenerArray.end()) {
         listenerArray.erase(find);
     }
 }
diff --git a/src/threepp/core/Object3D.cpp b/src/threepp/core/Object3D.cpp
@@ -10,6 +10,8 @@
 
 #include "threepp/lights/Light.hpp"
 
+#include <ranges>
+
 using namespace threepp;
 
 Object3D::Object3D()
@@ -221,26 +223,26 @@ void Object3D::add(Object3D& object) {
 
 void Object3D::remove(Object3D& object) {
 
-    {// non-owning (all children should be represented here)
-        auto find = std::find_if(children.begin(), children.end(), [&object](const auto& obj) {
+    // non-owning (all children should be represented here)
+    if (const auto find = std::ranges::find_if(children, [&object](const auto& obj) {
             return obj == &object;
         });
-        if (find != children.end()) {
-            Object3D* child = *find;
-            children.erase(find);
+        find != children.end()) {
 
-            child->parent = nullptr;
-            child->dispatchEvent("remove", child);
-        }
+        Object3D* child = *find;
+        children.erase(find);
+
+        child->parent = nullptr;
+        child->dispatchEvent("remove", child);
     }
-    {// owning
-        auto find = std::find_if(children_.begin(), children_.end(), [&object](const auto& obj) {
+
+    // owning
+    if (const auto find = std::ranges::find_if(children_, [&object](const auto& obj) {
             return obj.get() == &object;
         });
-        if (find != children_.end()) {
+        find != children_.end()) {
 
-            children_.erase(find);
-        }
+        children_.erase(find);
     }
 }
 
diff --git a/src/threepp/input/PeripheralsEventSource.cpp b/src/threepp/input/PeripheralsEventSource.cpp
@@ -10,38 +10,34 @@ void PeripheralsEventSource::setIOCapture(IOCapture* capture) {
 }
 
 void PeripheralsEventSource::addKeyListener(KeyListener& listener) {
-    auto find = std::find(keyListeners_.begin(), keyListeners_.end(), &listener);
-    if (find == keyListeners_.end()) {
+    if (const auto find = std::ranges::find(keyListeners_, &listener); find == keyListeners_.end()) {
         keyListeners_.emplace_back(&listener);
     }
 }
 
 bool PeripheralsEventSource::removeKeyListener(const KeyListener& listener) {
-    auto find = std::find(keyListeners_.begin(), keyListeners_.end(), &listener);
-    if (find != keyListeners_.end()) {
+    if (const auto find = std::ranges::find(keyListeners_, &listener); find != keyListeners_.end()) {
         keyListeners_.erase(find);
         return true;
     }
     return false;
 }
 
 void PeripheralsEventSource::addMouseListener(MouseListener& listener) {
-    auto find = std::find(mouseListeners_.begin(), mouseListeners_.end(), &listener);
-    if (find == mouseListeners_.end()) {
+    if (const auto find = std::ranges::find(mouseListeners_, &listener); find == mouseListeners_.end()) {
         mouseListeners_.emplace_back(&listener);
     }
 }
 
 bool PeripheralsEventSource::removeMouseListener(const MouseListener& listener) {
-    auto find = std::find(mouseListeners_.begin(), mouseListeners_.end(), &listener);
-    if (find != mouseListeners_.end()) {
+    if (const auto find = std::ranges::find(mouseListeners_, &listener); find != mouseListeners_.end()) {
         mouseListeners_.erase(find);
         return true;
     }
     return false;
 }
 
-void PeripheralsEventSource::onMousePressedEvent(int button, const Vector2& pos, PeripheralsEventSource::MouseAction action) {
+void PeripheralsEventSource::onMousePressedEvent(int button, const Vector2& pos, MouseAction action) {
     if (ioCapture_ && ioCapture_->preventMouseEvent()) return;
 
     auto listeners = mouseListeners_;//copy - IMPORTANT
diff --git a/src/threepp/loaders/MTLLoader.cpp b/src/threepp/loaders/MTLLoader.cpp
@@ -61,23 +61,23 @@ namespace {
         TexParams texParams{.scale = Vector2(1, 1), .offset = Vector2(0, 0)};
 
         auto items = utils::split(value, ' ');
-        auto pos = std::find(items.begin(), items.end(), "-bm");
+        auto pos = std::ranges::find(items, "-bm");
 
         if (pos != items.end()) {
 
             params.bumpScale = utils::parseFloat(*(pos + 1));
             items.erase(pos, pos + 2);
         }
 
-        pos = std::find(items.begin(), items.end(), "-s");
+        pos = std::ranges::find(items, "-s");
 
         if (pos != items.end()) {
 
             texParams.scale.set(utils::parseFloat(*(pos + 1)), utils::parseFloat(*(pos + 2)));
             items.erase(pos, pos + 4);
         }
 
-        pos = std::find(items.begin(), items.end(), "-o");
+        pos = std::ranges::find(items, "-o");
 
         if (pos != items.end()) {
 
diff --git a/src/threepp/loaders/svg/SVGFunctions.hpp b/src/threepp/loaders/svg/SVGFunctions.hpp
diff --git a/src/threepp/renderers/gl/GLPrograms.cpp b/src/threepp/renderers/gl/GLPrograms.cpp
diff --git a/tests/equals_util.hpp b/tests/equals_util.hpp
diff --git a/tests/math/Spherical_test.cpp b/tests/math/Spherical_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -272,23 +272,23 @@ namespace threepp {`
`272`	`272`	`return os;`
`273`	`273`	`}`
`274`	`274`
`275`		`- inline static Vector3 X() {`
	`275`	`+ static Vector3 X() {`
`276`	`276`	`return {1, 0, 0};`
`277`	`277`	`}`
`278`	`278`
`279`		`- inline static Vector3 Y() {`
	`279`	`+ static Vector3 Y() {`
`280`	`280`	`return {0, 1, 0};`
`281`	`281`	`}`
`282`	`282`
`283`		`- inline static Vector3 Z() {`
	`283`	`+ static Vector3 Z() {`
`284`	`284`	`return {0, 0, 1};`
`285`	`285`	`}`
`286`	`286`
`287`		`- inline static Vector3 ZEROS() {`
	`287`	`+ static Vector3 ZEROS() {`
`288`	`288`	`return {0, 0, 0};`
`289`	`289`	`}`
`290`	`290`
`291`		`- inline static Vector3 ONES() {`
	`291`	`+ static Vector3 ONES() {`
`292`	`292`	`return {1, 1, 1};`
`293`	`293`	`}`
`294`	`294`	`};`
Original file line number	Diff line number	Diff line change
`@@ -16,123 +16,123 @@ namespace threepp {`
`16`	`16`	`float_view(float value = 0)`
`17`	`17`	`: value_(value) {}`
`18`	`18`
`19`		`- inline operator float() const {`
	`19`	`+ operator float() const {`
`20`	`20`
`21`	`21`	`return value_;`
`22`	`22`	`}`
`23`	`23`
`24`		`- inline float_view& operator=(float v) {`
	`24`	`+ float_view& operator=(float v) {`
`25`	`25`
`26`	`26`	`this->value_ = v;`
`27`	`27`	`if (f_) f_.value()();`
`28`	`28`
`29`	`29`	`return *this;`
`30`	`30`	`}`
`31`	`31`
`32`		`- inline float operator*(float f) const {`
	`32`	`+ float operator*(float f) const {`
`33`	`33`
`34`	`34`	`return value_ * f;`
`35`	`35`	`}`
`36`	`36`
`37`		`- inline float operator*(const float_view& f) const {`
	`37`	`+ float operator*(const float_view& f) const {`
`38`	`38`
`39`	`39`	`return value_ * f.value_;`
`40`	`40`	`}`
`41`	`41`
`42`		`- inline float_view& operator*=(float f) {`
	`42`	`+ float_view& operator*=(float f) {`
`43`	`43`
`44`	`44`	`value_ *= f;`
`45`	`45`	`if (f_) f_.value()();`
`46`	`46`
`47`	`47`	`return *this;`
`48`	`48`	`}`
`49`	`49`
`50`		`- inline float operator/(float f) const {`
	`50`	`+ float operator/(float f) const {`
`51`	`51`
`52`	`52`	`return value_ / f;`
`53`	`53`	`}`
`54`	`54`
`55`		`- inline float_view& operator/=(float f) {`
	`55`	`+ float_view& operator/=(float f) {`
`56`	`56`
`57`	`57`	`value_ /= f;`
`58`	`58`	`if (f_) f_.value()();`
`59`	`59`
`60`	`60`	`return *this;`
`61`	`61`	`}`
`62`	`62`
`63`		`- inline float operator+(float f) const {`
	`63`	`+ float operator+(float f) const {`
`64`	`64`
`65`	`65`	`return value_ + f;`
`66`	`66`	`}`
`67`	`67`
`68`		`- inline float operator+(const float_view& f) const {`
	`68`	`+ float operator+(const float_view& f) const {`
`69`	`69`
`70`	`70`	`return value_ + f.value_;`
`71`	`71`	`}`
`72`	`72`
`73`		`- inline float_view& operator+=(float f) {`
	`73`	`+ float_view& operator+=(float f) {`
`74`	`74`
`75`	`75`	`value_ += f;`
`76`	`76`	`if (f_) f_.value()();`
`77`	`77`
`78`	`78`	`return *this;`
`79`	`79`	`}`
`80`	`80`
`81`		`- inline float operator-(float f) const {`
	`81`	`+ float operator-(float f) const {`
`82`	`82`
`83`	`83`	`return value_ - f;`
`84`	`84`	`}`
`85`	`85`
`86`		`- inline float operator-(const float_view& f) const {`
	`86`	`+ float operator-(const float_view& f) const {`
`87`	`87`
`88`	`88`	`return value_ - f.value_;`
`89`	`89`	`}`
`90`	`90`
`91`		`- inline float_view& operator-=(float f) {`
	`91`	`+ float_view& operator-=(float f) {`
`92`	`92`
`93`	`93`	`value_ -= f;`
`94`	`94`	`if (f_) f_.value()();`
`95`	`95`
`96`	`96`	`return *this;`
`97`	`97`	`}`
`98`	`98`
`99`		`- inline float_view& operator++() {`
	`99`	`+ float_view& operator++() {`
`100`	`100`
`101`	`101`	`value_++;`
`102`	`102`	`if (f_) f_.value()();`
`103`	`103`
`104`	`104`	`return *this;`
`105`	`105`	`}`
`106`	`106`
`107`		`- inline float_view& operator--() {`
	`107`	`+ float_view& operator--() {`
`108`	`108`
`109`	`109`	`value_--;`
`110`	`110`	`if (f_) f_.value()();`
`111`	`111`
`112`	`112`	`return *this;`
`113`	`113`	`}`
`114`	`114`
`115`		`- inline bool operator==(float other) const {`
	`115`	`+ bool operator==(float other) const {`
`116`	`116`
`117`	`117`	`return value_ == other;`
`118`	`118`	`}`
`119`	`119`
`120`		`- inline bool operator!=(float other) const {`
	`120`	`+ bool operator!=(float other) const {`
`121`	`121`
`122`	`122`	`return value_ != other;`
`123`	`123`	`}`
`124`	`124`
`125`		`- inline bool operator==(const float_view& other) const {`
	`125`	`+ bool operator==(const float_view& other) const {`
`126`	`126`
`127`	`127`	`return value_ == other.value_;`
`128`	`128`	`}`
`129`	`129`
`130`		`- inline bool operator!=(const float_view& other) const {`
	`130`	`+ bool operator!=(const float_view& other) const {`
`131`	`131`
`132`	`132`	`return value_ != other.value_;`
`133`	`133`	`}`
`134`	`134`
`135`		`- inline constexpr float_view& clamp(float min, float max) {`
	`135`	`+ constexpr float_view& clamp(float min, float max) {`
`136`	`136`
`137`	`137`	`value_ = std::max(min, std::min(max, value_));`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,9 @@ namespace threepp::utils {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`template<class ArrayLike>`
`27`		`- inline std::string join(const ArrayLike& v, char c = '\n') {`
	`27`	`+ std::string join(const ArrayLike& v, char c = '\n') {`
	`28`	`+`
	`29`	`+ if (v.empty()) return "";`
`28`	`30`
`29`	`31`	`auto p = v.cbegin();`
`30`	`32`	`std::stringstream ss;`
`@@ -39,21 +41,21 @@ namespace threepp::utils {`
`39`	`41`	`inline void replaceAll(std::string& text, const std::string& replaceFrom, const std::string& replaceTo) {`
`40`	`42`	`std::string& result = text;`
`41`	`43`	`size_t start_pos = 0;`
`42`		`- while (((start_pos = text.find(replaceFrom, start_pos)) != std::string::npos)) {`
	`44`	`+ while ((start_pos = text.find(replaceFrom, start_pos)) != std::string::npos) {`
`43`	`45`	`result.replace(start_pos, replaceFrom.length(), replaceTo);`
`44`	`46`	`start_pos += replaceTo.length();`
`45`	`47`	`}`
`46`	`48`	`}`
`47`	`49`
`48`	`50`	`inline std::string trimStart(std::string s) {`
`49`		`- s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {`
	`51`	`+ s.erase(s.begin(), std::ranges::find_if(s, [](unsigned char ch) {`
`50`	`52`	`return !std::isspace(ch);`
`51`	`53`	`}));`
`52`	`54`	`return s;`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`inline void trimStartInplace(std::string& s) {`
`56`		`- s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {`
	`58`	`+ s.erase(s.begin(), std::ranges::find_if(s, [](unsigned char ch) {`
`57`	`59`	`return !std::isspace(ch);`
`58`	`60`	`}));`
`59`	`61`	`}`
`@@ -85,13 +87,13 @@ namespace threepp::utils {`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`inline std::string toLower(std::string s) {`
`88`		`- std::transform(s.begin(), s.end(), s.begin(),`
	`90`	`+ std::ranges::transform(s, s.begin(),`
`89`	`91`	`[](unsigned char c) { return std::tolower(c); });`
`90`	`92`	`return s;`
`91`	`93`	`}`
`92`	`94`
`93`	`95`	`inline void toLowerInplace(std::string& s) {`
`94`		`- std::transform(s.begin(), s.end(), s.begin(),`
	`96`	`+ std::ranges::transform(s, s.begin(),`
`95`	`97`	`[](unsigned char c) { return std::tolower(c); });`
`96`	`98`	`}`
`97`	`99`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ bool EventDispatcher::hasEventListener(const std::string& type, const EventListe`
`16`	`16`	`if (!listeners_.contains(type)) return false;`
`17`	`17`
`18`	`18`	`auto& listenerArray = listeners_.at(type);`
`19`		`- return std::find(listenerArray.begin(), listenerArray.end(), listener) != listenerArray.end();`
	`19`	`+ return std::ranges::find(listenerArray, listener) != listenerArray.end();`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`void EventDispatcher::removeEventListener(const std::string& type, const EventListener* listener) {`
`@@ -26,8 +26,7 @@ void EventDispatcher::removeEventListener(const std::string& type, const EventLi`
`26`	`26`	`auto& listenerArray = listeners_.at(type);`
`27`	`27`	`if (listenerArray.empty()) return;`
`28`	`28`
`29`		`- auto find = std::find(listenerArray.begin(), listenerArray.end(), listener);`
`30`		`- if (find != listenerArray.end()) {`
	`29`	`+ if (const auto find = std::ranges::find(listenerArray, listener); find != listenerArray.end()) {`
`31`	`30`	`listenerArray.erase(find);`
`32`	`31`	`}`
`33`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,38 +10,34 @@ void PeripheralsEventSource::setIOCapture(IOCapture* capture) {`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`void PeripheralsEventSource::addKeyListener(KeyListener& listener) {`
`13`		`- auto find = std::find(keyListeners_.begin(), keyListeners_.end(), &listener);`
`14`		`- if (find == keyListeners_.end()) {`
	`13`	`+ if (const auto find = std::ranges::find(keyListeners_, &listener); find == keyListeners_.end()) {`
`15`	`14`	`keyListeners_.emplace_back(&listener);`
`16`	`15`	`}`
`17`	`16`	`}`
`18`	`17`
`19`	`18`	`bool PeripheralsEventSource::removeKeyListener(const KeyListener& listener) {`
`20`		`- auto find = std::find(keyListeners_.begin(), keyListeners_.end(), &listener);`
`21`		`- if (find != keyListeners_.end()) {`
	`19`	`+ if (const auto find = std::ranges::find(keyListeners_, &listener); find != keyListeners_.end()) {`
`22`	`20`	`keyListeners_.erase(find);`
`23`	`21`	`return true;`
`24`	`22`	`}`
`25`	`23`	`return false;`
`26`	`24`	`}`
`27`	`25`
`28`	`26`	`void PeripheralsEventSource::addMouseListener(MouseListener& listener) {`
`29`		`- auto find = std::find(mouseListeners_.begin(), mouseListeners_.end(), &listener);`
`30`		`- if (find == mouseListeners_.end()) {`
	`27`	`+ if (const auto find = std::ranges::find(mouseListeners_, &listener); find == mouseListeners_.end()) {`
`31`	`28`	`mouseListeners_.emplace_back(&listener);`
`32`	`29`	`}`
`33`	`30`	`}`
`34`	`31`
`35`	`32`	`bool PeripheralsEventSource::removeMouseListener(const MouseListener& listener) {`
`36`		`- auto find = std::find(mouseListeners_.begin(), mouseListeners_.end(), &listener);`
`37`		`- if (find != mouseListeners_.end()) {`
	`33`	`+ if (const auto find = std::ranges::find(mouseListeners_, &listener); find != mouseListeners_.end()) {`
`38`	`34`	`mouseListeners_.erase(find);`
`39`	`35`	`return true;`
`40`	`36`	`}`
`41`	`37`	`return false;`
`42`	`38`	`}`
`43`	`39`
`44`		`-void PeripheralsEventSource::onMousePressedEvent(int button, const Vector2& pos, PeripheralsEventSource::MouseAction action) {`
	`40`	`+void PeripheralsEventSource::onMousePressedEvent(int button, const Vector2& pos, MouseAction action) {`
`45`	`41`	`if (ioCapture_ && ioCapture_->preventMouseEvent()) return;`
`46`	`42`
`47`	`43`	`auto listeners = mouseListeners_;//copy - IMPORTANT`