feat: improve image loading error handling

Refactor image loading to return detailed result codes instead of pointers.
Add checks for non-image files, failed loads, and images exceeding atlas size.
Update main loop to log appropriate warnings or errors for each case and exit
on oversized images. This improves robustness and user feedback during packing.

Author: reybits

src/Atlas/AtlasSize.cpp

@@ -17,8 +17,18 @@ cAtlasSize::cAtlasSize(const sConfig& config)
 {
 }
 
+bool cAtlasSize::isFitToMaxSize(const sSize& size) const
+{
+    // Include atlas BORDER
+    auto width = size.width + m_config.border * 2u;
+    auto height = size.height + m_config.border * 2u;
+
+    return !(width > m_config.maxAtlasSize || height > m_config.maxAtlasSize);
+}
+
 void cAtlasSize::addRect(const sSize& size)
 {
+    // include sprite PADDING
     auto width = size.width + m_config.padding * 2u;
     auto height = size.height + m_config.padding * 2u;
 

src/Atlas/AtlasSize.h

@@ -17,6 +17,8 @@ class cAtlasSize final
 public:
     explicit cAtlasSize(const sConfig& config);
 
+    bool isFitToMaxSize(const sSize& size) const;
+
     void addRect(const sSize& size);
     uint32_t getArea() const;
 

src/ImageList.cpp

@@ -38,25 +38,32 @@ cImageList::~cImageList()
     delete m_trim;
 }
 
-const cImage* cImageList::loadImage(const std::string& path, uint32_t trimCount)
+cImageList::Result cImageList::loadImage(const std::string& path, uint32_t trimCount)
 {
-    if (cImage::IsImage(path.c_str()))
+    if (cImage::IsImage(path.c_str()) == false)
     {
-        std::unique_ptr<cImage> image(new cImage());
+        return Result::NotAnImage;
+    }
 
-        if (image->load(path.c_str(), trimCount, m_trim) == true)
-        {
-            auto& bmp = image->getBitmap();
-            auto& size = bmp.getSize();
-            m_size.addRect(size);
+    std::unique_ptr<cImage> image(new cImage());
 
-            m_images.push_back(image.release());
+    if (image->load(path.c_str(), trimCount, m_trim) == false)
+    {
+        return Result::CannotOpen;
+    }
 
-            return m_images.back();
-        }
+    auto& bmp = image->getBitmap();
+    auto& size = bmp.getSize();
+    if (m_size.isFitToMaxSize(size) == false)
+    {
+        return Result::TooBig;
     }
 
-    return nullptr;
+    m_size.addRect(size);
+
+    m_images.push_back(image.release());
+
+    return Result::OK;
 }
 
 bool cImageList::doPacking(const char* desiredAtlasName, const char* outputResName,

src/ImageList.h

@@ -23,7 +23,14 @@ class cImageList final
     cImageList(const sConfig& config, uint32_t reserve);
     ~cImageList();
 
-    const cImage* loadImage(const std::string& path, uint32_t trimCount);
+    enum class Result
+    {
+        OK,
+        NotAnImage,
+        CannotOpen,
+        TooBig,
+    };
+    Result loadImage(const std::string& path, uint32_t trimCount);
 
     bool doPacking(const char* desiredAtlasName, const char* outputResName,
                    const char* resPathPrefix, sSize& atlasSize);

src/main.cpp

@@ -216,10 +216,26 @@ int main(int argc, char* argv[])
 
     for (const auto& f : files)
     {
-        auto image = imageList.loadImage(f.path, f.trimCount);
-        if (image == nullptr)
+        auto result = imageList.loadImage(f.path, f.trimCount);
+        switch (result)
         {
+        case cImageList::Result::OK:
+            break;
+
+        case cImageList::Result::NotAnImage:
+            cLog::Warning("File '{}' is not an image.", f.path);
+            break;
+
+        case cImageList::Result::CannotOpen:
             cLog::Warning("File '{}' not loaded.", f.path);
+            break;
+
+        case cImageList::Result::TooBig:
+            cLog::Error("Image '{}' is too large for the atlas (max size: {} x {}).",
+                        f.path,
+                        config.maxAtlasSize, config.maxAtlasSize);
+
+            return -1;
         }
     }