Reorganize source files into logical subdirectories

Co-authored-by: Hirek193 <23196899+Hirek193@users.noreply.github.com>
2026-07-21 18:19:19 +02:00 · 2026-03-14 19:01:57 +00:00
parent f981f81d55
commit 0531086bb9
221 changed files with 131 additions and 108 deletions
--- a/model/ResourceManager.h
+++ b/model/ResourceManager.h
@@ -0,0 +1,81 @@
+/*
+This Source Code Form is subject to the
+terms of the Mozilla Public License, v.
+2.0. If a copy of the MPL was not
+distributed with this file, You can
+obtain one at
+http://mozilla.org/MPL/2.0/.
+*/
+
+#pragma once
+
+enum class resource_state {
+    none,
+    loading,
+    good,
+    failed
+};
+
+using resource_timestamp = std::chrono::steady_clock::time_point;
+
+// takes containers providing access to specific element through operator[]
+// with elements of std::pair<resource *, resource_timestamp>
+// the element should provide method release() freeing resources owned by the element
+template <class Container_>
+class garbage_collector {
+
+public:
+// constructor:
+    garbage_collector( Container_ &Container, unsigned int const Secondstolive, std::size_t const Sweepsize, std::string const Resourcename = "resource" ) :
+        m_unusedresourcetimetolive{ std::chrono::seconds{ Secondstolive } },
+        m_unusedresourcesweepsize{ Sweepsize },
+        m_resourcename{ Resourcename },
+        m_container{ Container }
+    {}
+
+// methods:
+    // performs resource sweep. returns: number of released resources
+    int
+        sweep() {
+            m_resourcetimestamp = std::chrono::steady_clock::now();
+            // garbage collection sweep is limited to a number of records per call, to reduce impact on framerate
+            auto const sweeplastindex =
+                std::min(
+                    m_resourcesweepindex + m_unusedresourcesweepsize,
+                    m_container.size() );
+            auto const blanktimestamp { std::chrono::steady_clock::time_point() };
+            int releasecount{ 0 };
+            for( auto resourceindex = m_resourcesweepindex; resourceindex < sweeplastindex; ++resourceindex ) {
+                if( ( m_container[ resourceindex ].second != blanktimestamp )
+                 && ( m_resourcetimestamp - m_container[ resourceindex ].second > m_unusedresourcetimetolive ) ) {
+
+                    m_container[ resourceindex ].first->release();
+                    m_container[ resourceindex ].second = blanktimestamp;
+                    ++releasecount;
+                }
+            }
+/*
+            if( releasecount ) {
+                WriteLog( "Resource garbage sweep released " + std::to_string( releasecount ) + " " + ( releasecount == 1 ? m_resourcename : m_resourcename + "s" ) );
+            }
+*/
+            m_resourcesweepindex = (
+                m_resourcesweepindex + m_unusedresourcesweepsize >= m_container.size() ?
+                    0 : // if the next sweep chunk is beyond actual data, so start anew
+                    m_resourcesweepindex + m_unusedresourcesweepsize );
+    
+            return releasecount; }
+
+    std::chrono::steady_clock::time_point
+        timestamp() const {
+            return m_resourcetimestamp; }
+
+private:
+// members:
+    std::chrono::nanoseconds const m_unusedresourcetimetolive;
+    typename Container_::size_type const m_unusedresourcesweepsize;
+    std::string const m_resourcename;
+    Container_ &m_container;
+    typename Container_::size_type m_resourcesweepindex { 0 };
+    std::chrono::steady_clock::time_point m_resourcetimestamp { std::chrono::steady_clock::now() };
+};