Single layer image processing improvements

src/engine/h2d_file.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2021 - 2023                                             *
+ *   Copyright (C) 2021 - 2024                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -173,6 +173,9 @@ namespace fheroes2
 
     bool readImageFromH2D( H2DReader & reader, const std::string & name, Sprite & image )
     {
+        // TODO: Store in h2d images the 'isSingleLayer' state to disable and skip transform layer for such images.
+        assert( !image.singleLayer() );
+
         const std::vector<uint8_t> & data = reader.getFile( name );
         if ( data.size() < 4 + 4 + 4 + 4 + 1 ) {
             // Empty or invalid image.
@@ -191,7 +194,6 @@ namespace fheroes2
         const size_t size = static_cast<size_t>( width * height );
         image.resize( width, height );
         memcpy( image.image(), data.data() + 4 + 4 + 4 + 4, size );
-        // TODO: Store in h2d images the 'isSingleLayer' state to disable and skip transform layer for such images.
         memcpy( image.transform(), data.data() + 4 + 4 + 4 + 4 + size, size );
 
         image.setPosition( x, y );
@@ -201,7 +203,8 @@ namespace fheroes2
 
     bool writeImageToH2D( H2DWriter & writer, const std::string & name, const Sprite & image )
     {
-        assert( !image.empty() );
+        // TODO: Store in h2d images the 'isSingleLayer' state to disable and skip transform layer for such images.
+        assert( !image.empty() && !image.singleLayer() );
 
         StreamBuf stream;
         stream.putLE32( static_cast<uint32_t>( image.width() ) );

src/engine/image.cpp

@@ -519,9 +519,9 @@ namespace fheroes2
             return;
         }
 
-        const size_t size = static_cast<size_t>( width_ ) * height_;
+        const size_t size = static_cast<size_t>( width_ ) * height_ * 2;
 
-        _data.reset( new uint8_t[size * 2] );
+        _data.reset( new uint8_t[size] );
 
         _width = width_;
         _height = height_;
@@ -545,18 +545,18 @@ namespace fheroes2
             return;
         }
 
-        const size_t size = static_cast<size_t>( image._width ) * image._height;
+        const size_t size = static_cast<size_t>( image._width ) * image._height * 2;
+
+        _singleLayer = image._singleLayer;
 
         if ( image._width != _width || image._height != _height ) {
-            _data.reset( new uint8_t[size * 2] );
+            _data.reset( new uint8_t[size] );
 
             _width = image._width;
             _height = image._height;
         }
 
-        _singleLayer = image._singleLayer;
-
-        memcpy( _data.get(), image._data.get(), size * 2 );
+        memcpy( _data.get(), image._data.get(), size );
     }
 
     Sprite::Sprite( const int32_t width_, const int32_t height_, const int32_t x_ /* = 0 */, const int32_t y_ /* = 0 */ )
@@ -2722,7 +2722,18 @@ namespace fheroes2
 
             const uint8_t * gamePalette = getGamePalette();
 
-            if ( in.singleLayer() && out.singleLayer() ) {
+            if ( in.singleLayer() ) {
+                if ( !out.singleLayer() ) {
+                    // In this case we make the output image fully non-transparent in the given output area.
+
+                    uint8_t * transformY = out.transform() + outY * widthOut + outX;
+                    const uint8_t * transformYEnd = transformY + heightRoiOut * widthOut;
+
+                    for ( ; transformY != transformYEnd; transformY += widthOut ) {
+                        memset( transformY, static_cast<uint8_t>( 0 ), widthRoiOut );
+                    }
+                }
+
                 for ( int32_t y = 0; y < heightRoiOut; ++y, imageOutY += widthOut ) {
                     const double posY = static_cast<double>( y * heightRoiIn ) / heightRoiOut;
                     const int32_t startY = static_cast<int32_t>( posY );
@@ -2763,52 +2774,63 @@ namespace fheroes2
             }
             else {
                 const uint8_t * transformInY = in.transform() + offsetInY;
-                uint8_t * transformOutY = out.transform() + offsetOutY;
+                const bool isOutNotSingleLayer = !out.singleLayer();
+                uint8_t * transformOutY = isOutNotSingleLayer ? ( out.transform() + offsetOutY ) : nullptr;
 
-                for ( int32_t y = 0; y < heightRoiOut; ++y, imageOutY += widthOut, transformOutY += widthOut ) {
+                for ( int32_t y = 0; y < heightRoiOut; ++y, imageOutY += widthOut ) {
                     const double posY = static_cast<double>( y * heightRoiIn ) / heightRoiOut;
                     const int32_t startY = static_cast<int32_t>( posY );
                     const double coeffY = posY - startY;
 
                     uint8_t * imageOutX = imageOutY;
                     uint8_t * transformOutX = transformOutY;
 
-                    for ( int32_t x = 0; x < widthRoiOut; ++x, ++imageOutX, ++transformOutX ) {
+                    for ( int32_t x = 0; x < widthRoiOut; ++x, ++imageOutX ) {
                         const double posX = positionX[x];
                         const int32_t startX = static_cast<int32_t>( posX );
                         const int32_t offsetIn = startY * widthIn + startX;
 
                         const uint8_t * imageInX = imageInY + offsetIn;
                         const uint8_t * transformInX = transformInY + offsetIn;
 
-                        if ( posX < widthIn - 1 && posY < heightRoiIn - 1 ) {
-                            if ( *transformInX == 0 && *( transformInX + 1 ) == 0 && *( transformInX + widthRoiIn ) == 0 && *( transformInX + widthRoiIn + 1 ) == 0 ) {
-                                const double coeffX = posX - startX;
-                                const double coeff1 = ( 1 - coeffX ) * ( 1 - coeffY );
-                                const double coeff2 = coeffX * ( 1 - coeffY );
-                                const double coeff3 = ( 1 - coeffX ) * coeffY;
-                                const double coeff4 = coeffX * coeffY;
+                        if ( posX < widthIn - 1 && posY < heightRoiIn - 1 && *transformInX == 0 && *( transformInX + 1 ) == 0 && *( transformInX + widthRoiIn ) == 0
+                             && *( transformInX + widthRoiIn + 1 ) == 0 ) {
+                            const double coeffX = posX - startX;
+                            const double coeff1 = ( 1 - coeffX ) * ( 1 - coeffY );
+                            const double coeff2 = coeffX * ( 1 - coeffY );
+                            const double coeff3 = ( 1 - coeffX ) * coeffY;
+                            const double coeff4 = coeffX * coeffY;
 
-                                const uint8_t * id1 = gamePalette + static_cast<uint32_t>( *imageInX ) * 3;
-                                const uint8_t * id2 = gamePalette + static_cast<uint32_t>( *( imageInX + 1 ) ) * 3;
-                                const uint8_t * id3 = gamePalette + static_cast<uint32_t>( *( imageInX + widthIn ) ) * 3;
-                                const uint8_t * id4 = gamePalette + static_cast<uint32_t>( *( imageInX + widthIn + 1 ) ) * 3;
+                            const uint8_t * id1 = gamePalette + static_cast<uint32_t>( *imageInX ) * 3;
+                            const uint8_t * id2 = gamePalette + static_cast<uint32_t>( *( imageInX + 1 ) ) * 3;
+                            const uint8_t * id3 = gamePalette + static_cast<uint32_t>( *( imageInX + widthIn ) ) * 3;
+                            const uint8_t * id4 = gamePalette + static_cast<uint32_t>( *( imageInX + widthIn + 1 ) ) * 3;
 
-                                const double red = *id1 * coeff1 + *id2 * coeff2 + *id3 * coeff3 + *id4 * coeff4 + 0.5;
-                                const double green = *( id1 + 1 ) * coeff1 + *( id2 + 1 ) * coeff2 + *( id3 + 1 ) * coeff3 + *( id4 + 1 ) * coeff4 + 0.5;
-                                const double blue = *( id1 + 2 ) * coeff1 + *( id2 + 2 ) * coeff2 + *( id3 + 2 ) * coeff3 + *( id4 + 2 ) * coeff4 + 0.5;
+                            const double red = *id1 * coeff1 + *id2 * coeff2 + *id3 * coeff3 + *id4 * coeff4 + 0.5;
+                            const double green = *( id1 + 1 ) * coeff1 + *( id2 + 1 ) * coeff2 + *( id3 + 1 ) * coeff3 + *( id4 + 1 ) * coeff4 + 0.5;
+                            const double blue = *( id1 + 2 ) * coeff1 + *( id2 + 2 ) * coeff2 + *( id3 + 2 ) * coeff3 + *( id4 + 2 ) * coeff4 + 0.5;
 
-                                *imageOutX = GetPALColorId( static_cast<uint8_t>( red ), static_cast<uint8_t>( green ), static_cast<uint8_t>( blue ) );
-                            }
-                            else {
+                            *imageOutX = GetPALColorId( static_cast<uint8_t>( red ), static_cast<uint8_t>( green ), static_cast<uint8_t>( blue ) );
+                        }
+                        else {
+                            if ( isOutNotSingleLayer || *transformInX == 0 ) {
+                                // Output image is double-layer or single-layer with non-transparent current pixel.
                                 *imageOutX = *imageInX;
                             }
+                            else if ( *transformInX != 1 ) {
+                                // Apply a transformation.
+                                *imageOutX = *( transformTable + ( *transformInX ) * 256 + *imageOutX );
+                            }
                         }
-                        else {
-                            *imageOutX = *imageInX;
+
+                        if ( isOutNotSingleLayer ) {
+                            *transformOutX = *transformInX;
+                            ++transformOutX;
                         }
+                    }
 
-                        *transformOutX = *transformInX;
+                    if ( !isOutNotSingleLayer ) {
+                        transformOutY += widthOut;
                     }
                 }
             }
@@ -2823,7 +2845,18 @@ namespace fheroes2
                 positionX[x] = ( x * widthRoiIn ) / widthRoiOut;
             }
 
-            if ( in.singleLayer() && out.singleLayer() ) {
+            if ( in.singleLayer() ) {
+                if ( !out.singleLayer() ) {
+                    // In this case we make the output image fully non-transparent in the given output area.
+
+                    uint8_t * transformY = out.transform() + outY * widthOut + outX;
+                    const uint8_t * transformYEnd = transformY + heightRoiOut * widthOut;
+
+                    for ( ; transformY != transformYEnd; transformY += widthOut ) {
+                        memset( transformY, static_cast<uint8_t>( 0 ), widthRoiOut );
+                    }
+                }
+
                 for ( ; imageOutY != imageOutYEnd; imageOutY += widthOut, ++idY ) {
                     uint8_t * imageOutX = imageOutY;
 
@@ -2836,7 +2869,34 @@ namespace fheroes2
                     }
                 }
             }
+            else if ( out.singleLayer() ) {
+                const uint8_t * transformInY = in.transform() + offsetInY;
+
+                for ( ; imageOutY != imageOutYEnd; imageOutY += widthOut, ++idY ) {
+                    uint8_t * imageOutX = imageOutY;
+
+                    const int32_t offset = ( ( idY * heightRoiIn ) / heightRoiOut ) * widthIn;
+                    const uint8_t * imageInX = imageInY + offset;
+                    const uint8_t * transformInX = transformInY + offset;
+
+                    for ( const int32_t posX : positionX ) {
+                        const uint8_t * transformIn = transformInX + posX;
+                        if ( *transformIn > 0 ) {
+                            if ( *transformIn != 1 ) {
+                                // Apply a transformation.
+                                *imageOutX = *( transformTable + ( *transformIn ) * 256 + *imageOutX );
+                            }
+                        }
+                        else {
+                            *imageOutX = *( imageInX + posX );
+                        }
+
+                        ++imageOutX;
+                    }
+                }
+            }
             else {
+                // Both 'in' and 'out' are double-layer.
                 const uint8_t * transformInY = in.transform() + offsetInY;
                 uint8_t * transformOutY = out.transform() + offsetOutY;
 

src/engine/image.h

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2020 - 2023                                             *
+ *   Copyright (C) 2020 - 2024                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -28,7 +28,7 @@
 
 namespace fheroes2
 {
-    // Image contains image layer and transform layer.
+    // Image always contains an image layer and if image is not a single-layer then 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
@@ -77,13 +77,14 @@ namespace fheroes2
         }
 
         void reset(); // makes image fully transparent (transform layer is set to 1)
+
         void clear(); // makes the image empty
 
         // Fill 'image' layer with given value, setting '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.
+        // The whole image still consists of 2 layers but transform layer might be ignored in computations
         bool singleLayer() const
         {
             return _singleLayer;

src/engine/image_tool.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2020 - 2023                                             *
+ *   Copyright (C) 2020 - 2024                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -155,6 +155,12 @@ namespace fheroes2
 
     bool Load( const std::string & path, Image & image )
     {
+        if ( image.singleLayer() ) {
+            // Output image should be double-layer!
+            assert( 0 );
+            return false;
+        }
+
         std::unique_ptr<SDL_Surface, std::function<void( SDL_Surface * )>> surface( nullptr, SDL_FreeSurface );
         std::unique_ptr<SDL_Surface, std::function<void( SDL_Surface * )>> loadedSurface( nullptr, SDL_FreeSurface );
 

src/engine/localevent.cpp

@@ -1238,14 +1238,14 @@ 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;
+
+    assert( display.singleLayer() );
+
+    temp._disableTransformLayer();
 
     fheroes2::Copy( display, temp );
     display.release();
-    display.resize( temp.width(), temp.height() );
     fheroes2::Copy( temp, display );
 }
 

src/engine/screen.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2020 - 2023                                             *
+ *   Copyright (C) 2020 - 2024                                             *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
@@ -359,6 +359,12 @@ namespace
 
         SDL_Surface * generateIconSurface( const fheroes2::Image & icon )
         {
+            if ( icon.empty() || icon.singleLayer() ) {
+                // What are you trying to do? Icon should have not empty both image and transform layers.
+                assert( 0 );
+                return nullptr;
+            }
+
             SDL_Surface * surface = SDL_CreateRGBSurface( 0, icon.width(), icon.height(), 32, 0xFF, 0xFF00, 0xFF0000, 0xFF000000 );
             if ( surface == nullptr ) {
                 ERROR_LOG( "Failed to create a surface of " << icon.width() << " x " << icon.height() << " size for cursor. The error: " << SDL_GetError() )
@@ -432,7 +438,7 @@ 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!
                 assert( 0 );
                 return;
@@ -1343,10 +1349,9 @@ namespace fheroes2
         }
 
         Image::resize( info.gameWidth, info.gameHeight );
-        _screenSize = { info.screenWidth, info.screenHeight };
+        Image::reset();
 
-        // 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 ) );
+        _screenSize = { info.screenWidth, info.screenHeight };
     }
 
     Display & Display::instance()

src/engine/zzlib.cpp

@@ -1,6 +1,6 @@
 /***************************************************************************
  *   fheroes2: https://github.com/ihhub/fheroes2                           *
- *   Copyright (C) 2019 - 2023                                             *
+ *   Copyright (C) 2019 - 2024                                             *
  *                                                                         *
  *   Free Heroes2 Engine: http://sourceforge.net/projects/fheroes2         *
  *   Copyright (C) 2009 by Andrey Afletdinov <[email protected]>          *
@@ -195,27 +195,30 @@ bool ZStreamBuf::write( const std::string & fn, const bool append /* = false */
 
 fheroes2::Image CreateImageFromZlib( int32_t width, int32_t height, const uint8_t * imageData, size_t imageSize, 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;
 }