1 files changed, 163 insertions, 0 deletions
diff --git a/apps/openmb/renderer/TextureManager.cpp b/apps/openmb/renderer/TextureManager.cpp
new file mode 100644
index 0000000..bfd7e15
--- /dev/null
+++ b/apps/openmb/renderer/TextureManager.cpp
@@ -0,0 +1,163 @@
+#include "TextureManager.hpp"
+
+#include <algorithm>
+#include <iostream>
+
+namespace renderer {
+TextureManager::TextureManager ()
+    : mBasePath(), mTextures(), mCurrentCategory(), mCurrentSubcategory(), mCurrentTextureName(),
+      mCurrentTexture( nullptr ), mCurrentTextureId( 0 ), mTextureIdToPath(), mNextTextureId( 1 ) {
+}
+
+void TextureManager::scanDirectory ( const std::string& basePath ) {
+    mBasePath = basePath;
+    mTextures.clear();
+
+    if( !std::filesystem::exists( basePath ) ) {
+        std::cerr << "TextureManager: Base path does not exist: " << basePath << std::endl;
+        return;
+    }
+
+    for( const auto& categoryEntry : std::filesystem::directory_iterator( basePath ) ) {
+        if( !categoryEntry.is_directory() )
+            continue;
+
+        std::string categoryName = categoryEntry.path().filename().string();
+
+        for( const auto& subcategoryEntry : std::filesystem::directory_iterator( categoryEntry.path() ) ) {
+            if( !subcategoryEntry.is_directory() )
+                continue;
+
+            std::string subcategoryName = subcategoryEntry.path().filename().string();
+
+            for( const auto& fileEntry : std::filesystem::directory_iterator( subcategoryEntry.path() ) ) {
+                if( !fileEntry.is_regular_file() )
+                    continue;
+
+                std::string fileName  = fileEntry.path().filename().string();
+                std::string extension = fileEntry.path().extension().string();
+
+                if( extension != ".png" && extension != ".jpg" && extension != ".jpeg" && extension != ".bmp" &&
+                    extension != ".tga" )
+                    continue;
+
+                TextureEntry entry;
+                entry.mFullPath = fileEntry.path().string();
+                entry.mLoaded   = false;
+
+                mTextures[categoryName][subcategoryName][fileName] = entry;
+
+                int textureId               = mNextTextureId++;
+                mTextureIdToPath[textureId] = std::make_tuple( categoryName, subcategoryName, fileName );
+            }
+        }
+    }
+
+    std::cout << "TextureManager: Scanned " << mTextures.size() << " categories" << std::endl;
+}
+
+std::vector<std::string> TextureManager::getCategories () const {
+    std::vector<std::string> categories;
+    for( const auto& [category, _] : mTextures ) {
+        categories.push_back( category );
+    }
+    std::sort( categories.begin(), categories.end() );
+    return categories;
+}
+
+std::vector<std::string> TextureManager::getSubcategories ( const std::string& category ) const {
+    std::vector<std::string> subcategories;
+    auto                     catIt = mTextures.find( category );
+    if( catIt != mTextures.end() ) {
+        for( const auto& [subcategory, _] : catIt->second ) {
+            subcategories.push_back( subcategory );
+        }
+        std::sort( subcategories.begin(), subcategories.end() );
+    }
+    return subcategories;
+}
+
+std::vector<std::string> TextureManager::getTextureNames ( const std::string& category,
+                                                           const std::string& subcategory ) const {
+    std::vector<std::string> textureNames;
+    auto                     catIt = mTextures.find( category );
+    if( catIt != mTextures.end() ) {
+        auto subIt = catIt->second.find( subcategory );
+        if( subIt != catIt->second.end() ) {
+            for( const auto& [textureName, _] : subIt->second ) {
+                textureNames.push_back( textureName );
+            }
+            std::sort( textureNames.begin(), textureNames.end() );
+        }
+    }
+    return textureNames;
+}
+
+Texture* TextureManager::getTexture ( const std::string& category, const std::string& subcategory,
+                                      const std::string& textureName ) {
+    auto catIt = mTextures.find( category );
+    if( catIt == mTextures.end() )
+        return nullptr;
+
+    auto subIt = catIt->second.find( subcategory );
+    if( subIt == catIt->second.end() )
+        return nullptr;
+
+    auto texIt = subIt->second.find( textureName );
+    if( texIt == subIt->second.end() )
+        return nullptr;
+
+    TextureEntry& entry = texIt->second;
+
+    if( !entry.mLoaded ) {
+        if( entry.mTexture.loadFromFile( entry.mFullPath ) ) {
+            entry.mLoaded = true;
+        } else {
+            std::cerr << "TextureManager: Failed to load texture: " << entry.mFullPath << std::endl;
+            return nullptr;
+        }
+    }
+
+    return &entry.mTexture;
+}
+
+Texture* TextureManager::getCurrentTexture () {
+    if( mCurrentTexture )
+        return mCurrentTexture;
+
+    if( !mCurrentCategory.empty() && !mCurrentSubcategory.empty() && !mCurrentTextureName.empty() ) {
+        mCurrentTexture = getTexture( mCurrentCategory, mCurrentSubcategory, mCurrentTextureName );
+    }
+
+    return mCurrentTexture;
+}
+
+void TextureManager::setCurrentTexture ( const std::string& category, const std::string& subcategory,
+                                         const std::string& textureName ) {
+    mCurrentCategory    = category;
+    mCurrentSubcategory = subcategory;
+    mCurrentTextureName = textureName;
+    mCurrentTexture     = getTexture( category, subcategory, textureName );
+
+    for( const auto& [id, path] : mTextureIdToPath ) {
+        if( std::get<0>( path ) == category && std::get<1>( path ) == subcategory &&
+            std::get<2>( path ) == textureName ) {
+            mCurrentTextureId = id;
+            break;
+        }
+    }
+}
+
+int TextureManager::getCurrentTextureId () const {
+    return mCurrentTextureId;
+}
+
+Texture* TextureManager::getTextureById ( int textureId ) {
+    auto it = mTextureIdToPath.find( textureId );
+    if( it == mTextureIdToPath.end() )
+        return nullptr;
+
+    const auto& [category, subcategory, textureName] = it->second;
+    return getTexture( category, subcategory, textureName );
+}
+}   // namespace renderer