Reduce memory usage: do not allocate memory for the transform layer for single layer images

src/engine/h2d_file.cpp

@@ -173,6 +173,11 @@ namespace fheroes2
 
     bool readImageFromH2D( H2DReader & reader, const std::string & name, Sprite & image )
     {
+        // TODO: Add the transform layer presence flag in H2D images and read H2D single-layer images properly without the transform layer.
+
+        // Currently all H2D images are double-layer images so the out 'image' should not be single-layer.
+        assert( !image.singleLayer() );
+
         const std::vector<uint8_t> & data = reader.getFile( name );
         if ( data.size() < 4 + 4 + 4 + 4 + 1 ) {
             // Empty or invalid image.
@@ -201,7 +206,10 @@ namespace fheroes2
 
     bool writeImageToH2D( H2DWriter & writer, const std::string & name, const Sprite & image )
     {
-        assert( !image.empty() );
+        // TODO: Add the transform layer presence flag in H2D images and write single-layer images properly without the transform layer.
+
+        // Currently all H2D images are double-layer images so the out 'image' should not be single-layer.
+        assert( !image.empty() && !image.singleLayer() );
 
         StreamBuf stream;
         stream.putLE32( static_cast<uint32_t>( image.width() ) );

src/engine/image.cpp

@@ -448,7 +448,8 @@ namespace fheroes2
     }
 
     Image::Image( Image && image_ ) noexcept
-        : _data( std::move( image_._data ) )
+        : _imageData( std::move( image_._imageData ) )
+        , _transformData( std::move( image_._transformData ) )
     {
         std::swap( _singleLayer, image_._singleLayer );
         std::swap( _width, image_._width );
@@ -469,26 +470,18 @@ namespace fheroes2
         if ( this != &image_ ) {
             std::swap( _width, image_._width );
             std::swap( _height, image_._height );
-            std::swap( _data, image_._data );
+            std::swap( _imageData, image_._imageData );
+            std::swap( _transformData, image_._transformData );
             std::swap( _singleLayer, image_._singleLayer );
         }
 
         return *this;
     }
 
-    uint8_t * Image::image()
-    {
-        return _data.get();
-    }
-
-    const uint8_t * Image::image() const
-    {
-        return _data.get();
-    }
-
     void Image::clear()
     {
-        _data.reset();
+        _imageData.reset();
+        _transformData.reset();
 
         _width = 0;
         _height = 0;
@@ -499,7 +492,11 @@ namespace fheroes2
         if ( !empty() ) {
             const size_t totalSize = static_cast<size_t>( _width ) * _height;
             memset( image(), value, totalSize );
-            memset( transform(), static_cast<uint8_t>( 0 ), totalSize );
+
+            if ( !_singleLayer ) {
+                // Set the transform layer not to skip all data.
+                memset( transform(), static_cast<uint8_t>( 0 ), totalSize );
+            }
         }
     }
 
@@ -515,27 +512,44 @@ namespace fheroes2
             return;
         }
 
-        const size_t size = static_cast<size_t>( width_ ) * height_;
+        size_t size = static_cast<size_t>( width_ ) * height_;
+        _imageData.reset( new uint8_t[size] );
 
-        _data.reset( new uint8_t[size * 2] );
+        if ( !_singleLayer ) {
+            // For double-layer images we also allocate memory for the second (transform) layer.
+            _transformData.reset( new uint8_t[size] );
+        }
 
         _width = width_;
         _height = height_;
     }
 
+    uint8_t * Image::image()
+    {
+        return _imageData.get();
+    }
+
+    const uint8_t * Image::image() const
+    {
+        return _imageData.get();
+    }
+
     void Image::reset()
     {
         if ( !empty() ) {
             const size_t totalSize = static_cast<size_t>( _width ) * _height;
             memset( image(), static_cast<uint8_t>( 0 ), totalSize );
-            // Set the transform layer to skip all data.
-            memset( transform(), static_cast<uint8_t>( 1 ), totalSize );
+
+            if ( !_singleLayer ) {
+                // Set the transform layer to skip all data.
+                memset( transform(), static_cast<uint8_t>( 1 ), totalSize );
+            }
         }
     }
 
     void Image::copy( const Image & image )
     {
-        if ( !image._data ) {
+        if ( !image._imageData ) {
             clear();
 
             return;
@@ -544,15 +558,36 @@ namespace fheroes2
         const size_t size = static_cast<size_t>( image._width ) * image._height;
 
         if ( image._width != _width || image._height != _height ) {
-            _data.reset( new uint8_t[size * 2] );
+            _imageData.reset( new uint8_t[size] );
 
             _width = image._width;
             _height = image._height;
+
+            if ( !image._singleLayer ) {
+                _transformData.reset( new uint8_t[size] );
+            }
+            else if ( !_singleLayer ) {
+                _transformData.reset();
+            }
+
+            _singleLayer = image._singleLayer;
+        }
+        else if ( _singleLayer != image._singleLayer ) {
+            _singleLayer = image._singleLayer;
+
+            if ( _singleLayer ) {
+                _transformData.reset( new uint8_t[size] );
+            }
+            else {
+                _transformData.reset();
+            }
         }
 
-        _singleLayer = image._singleLayer;
+        memcpy( _imageData.get(), image._imageData.get(), size );
 
-        memcpy( _data.get(), image._data.get(), size * 2 );
+        if ( !_singleLayer ) {
+            memcpy( _transformData.get(), image._transformData.get(), size );
+        }
     }
 
     Sprite::Sprite( const int32_t width_, const int32_t height_, const int32_t x_ /* = 0 */, const int32_t y_ /* = 0 */ )
@@ -2662,6 +2697,9 @@ namespace fheroes2
             return;
         }
 
+        // 'in' and' out' images should have the same layers.
+        assert( in.singleLayer() == out.singleLayer() );
+
         const int32_t widthIn = in.width();
         const int32_t widthOut = out.width();
 

src/engine/image.h

@@ -19,6 +19,7 @@
  ***************************************************************************/
 #pragma once
 
+#include <cassert>
 #include <cstdint>
 #include <memory>
 #include <utility>
@@ -28,7 +29,7 @@
 
 namespace fheroes2
 {
-    // Image contains image layer and transform layer.
+    // Image contains always contains an image layer and if image is not a single-layer than also a transform layer:
     // - image layer contains visible pixels which are copy to a destination image
     // - transform layer is used to apply some transformation to an image on which we draw the current one. For example, shadowing
     class Image
@@ -63,27 +64,35 @@ namespace fheroes2
 
         uint8_t * transform()
         {
-            return _data.get() + width() * height();
+            // Why do you want to get transform layer from the single-layer image?
+            assert( !_singleLayer );
+
+            return _transformData.get();
         }
 
         const uint8_t * transform() const
         {
-            return _data.get() + width() * height();
+            // Why do you want to get transform layer from the single-layer image?
+            assert( !_singleLayer );
+
+            return _transformData.get();
         }
 
         bool empty() const
         {
-            return !_data;
+            return !_imageData;
         }
 
-        void reset(); // makes image fully transparent (transform layer is set to 1)
-        void clear(); // makes the image empty
+        // Set all data in the image layer to 0 and make double-layer images fully transparent (transform layer is set to 1).
+        void reset();
+
+        // Make the image empty.
+        void clear();
 
-        // Fill 'image' layer with given value, setting 'transform' layer to 0.
+        // Fill 'image' layer with given value, setting the double-layer images 'transform' layer to 0.
         void fill( const uint8_t value );
 
-        // This is an optional indicator for image processing functions.
-        // The whole image still consists of 2 layers but transform layer might be ignored in computations.
+        // This is an indicator for image processing functions. The single-layer image does not contain transform layer.
         bool singleLayer() const
         {
             return _singleLayer;
@@ -93,6 +102,9 @@ namespace fheroes2
         // The name of this method starts from _ on purpose to do not mix with other public methods.
         void _disableTransformLayer()
         {
+            // Free the transform layer memory preserving the image layer data.
+            _transformData.reset();
+
             _singleLayer = true;
         }
 
@@ -101,9 +113,11 @@ namespace fheroes2
 
         int32_t _width{ 0 };
         int32_t _height{ 0 };
-        std::unique_ptr<uint8_t[]> _data; // holds 2 image layers
 
-        // Only for images which are not used for any other operations except displaying on screen.
+        std::unique_ptr<uint8_t[]> _imageData;
+        std::unique_ptr<uint8_t[]> _transformData;
+
+        // Image may be set as single-layer only for images which are not used for any other operations except displaying on screen.
         bool _singleLayer{ false };
     };
 

src/engine/image_tool.cpp

@@ -344,6 +344,10 @@ namespace fheroes2
 
         while ( true ) {
             if ( 0 == *data ) { // 0x00 - end of row
+                if ( noTransformLayer && ( static_cast<int32_t>( posX ) < width ) ) {
+                    noTransformLayer = false;
+                }
+
                 imageData += width;
                 imageTransform += width;
                 posX = 0;

src/engine/localevent.cpp

@@ -1401,10 +1401,8 @@ void LocalEvent::HandleRenderDeviceResetEvent()
 {
     // All textures has to be recreated. The only way to do it is to reset everything and render it back.
     fheroes2::Display & display = fheroes2::Display::instance();
-    fheroes2::Image temp( display.width(), display.height() );
-    if ( display.singleLayer() ) {
-        temp._disableTransformLayer();
-    }
+    fheroes2::Image temp;
+    temp._disableTransformLayer();
 
     fheroes2::Copy( display, temp );
     display.release();

src/engine/screen.cpp

@@ -378,6 +378,8 @@ namespace
                 return nullptr;
             }
 
+            assert( !icon.singleLayer() );
+
             const uint32_t width = icon.width();
             const uint32_t height = icon.height();
 
@@ -446,8 +448,9 @@ namespace
 
         void update( const fheroes2::Image & image, int32_t offsetX, int32_t offsetY ) override
         {
-            if ( image.empty() ) {
+            if ( image.empty() || image.singleLayer() ) {
                 // What are you trying to do? Set an invisible cursor? Use hide() method!
+                // Cursor image should have the transform layer.
                 assert( 0 );
                 return;
             }
@@ -1573,8 +1576,10 @@ namespace fheroes2
     void Display::setResolution( ResolutionInfo info )
     {
         if ( width() > 0 && height() > 0 && info.gameWidth == width() && info.gameHeight == height() && info.screenWidth == _screenSize.width
-             && info.screenHeight == _screenSize.height ) // nothing to resize
+             && info.screenHeight == _screenSize.height ) {
+            // Nothing to resize.
             return;
+        }
 
         const bool isFullScreen = _engine->isFullScreen();
 
@@ -1590,9 +1595,6 @@ namespace fheroes2
 
         Image::resize( info.gameWidth, info.gameHeight );
         _screenSize = { info.screenWidth, info.screenHeight };
-
-        // To detect some UI artifacts by invalid code let's put all transform data into pixel skipping mode.
-        std::fill( transform(), transform() + width() * height(), static_cast<uint8_t>( 1 ) );
     }
 
     Display & Display::instance()

src/engine/zzlib.cpp

@@ -23,7 +23,6 @@
 
 #include "zzlib.h"
 
-#include <algorithm>
 #include <cstring>
 #include <ostream>
 #include <vector>
@@ -193,29 +192,32 @@ bool ZStreamBuf::write( const std::string & fn, const bool append /* = false */
     return !sf.fail();
 }
 
-fheroes2::Image CreateImageFromZlib( int32_t width, int32_t height, const uint8_t * imageData, size_t imageSize, bool doubleLayer )
+fheroes2::Image CreateImageFromZlib( const int32_t width, const int32_t height, const uint8_t * imageData, const size_t imageSize, const bool doubleLayer )
 {
-    if ( imageData == nullptr || imageSize == 0 || width <= 0 || height <= 0 )
-        return fheroes2::Image();
+    if ( imageData == nullptr || imageSize == 0 || width <= 0 || height <= 0 ) {
+        return {};
+    }
 
     const std::vector<uint8_t> & uncompressedData = zlibDecompress( imageData, imageSize );
     if ( doubleLayer && ( uncompressedData.size() & 1 ) == 1 ) {
-        return fheroes2::Image();
+        return {};
     }
 
     const size_t uncompressedSize = doubleLayer ? uncompressedData.size() / 2 : uncompressedData.size();
 
-    if ( static_cast<size_t>( width * height ) != uncompressedSize )
-        return fheroes2::Image();
+    if ( static_cast<size_t>( width ) * height != uncompressedSize ) {
+        return {};
+    }
 
-    fheroes2::Image out( width, height );
+    fheroes2::Image out;
+    if ( !doubleLayer ) {
+        out._disableTransformLayer();
+    }
+    out.resize( width, height );
 
     std::memcpy( out.image(), uncompressedData.data(), uncompressedSize );
     if ( doubleLayer ) {
         std::memcpy( out.transform(), uncompressedData.data() + uncompressedSize, uncompressedSize );
     }
-    else {
-        std::fill( out.transform(), out.transform() + uncompressedSize, static_cast<uint8_t>( 0 ) );
-    }
     return out;
 }

src/engine/zzlib.h

@@ -47,6 +47,6 @@ class ZStreamBuf : public StreamBuf
     bool write( const std::string & fn, const bool append = false ) const;
 };
 
-fheroes2::Image CreateImageFromZlib( int32_t width, int32_t height, const uint8_t * imageData, size_t imageSize, bool doubleLayer );
+fheroes2::Image CreateImageFromZlib( const int32_t width, const int32_t height, const uint8_t * imageData, const size_t imageSize, const bool doubleLayer );
 
 #endif