Merge branch 'master' into lobby-dsk-control-id-codestyle

Author: tehKaiN

external/s25update

@@ -10,6 +10,9 @@
 #include <limits>
 #include <type_traits>
 
+template<typename Source, typename Target>
+constexpr bool is_float_to_int_v = std::conjunction_v<std::is_floating_point<Source>, std::is_integral<Target>>;
+
 /// Type for describing a 2D value (position, size, offset...)
 /// Note: Combining a signed with an unsigned point will result in a signed type!
 /// Allowed operations:
@@ -35,15 +38,15 @@ struct Point //-V690
     T x, y;
     constexpr Point() noexcept : x(getInvalidValue()), y(getInvalidValue()) {}
     constexpr Point(const T x, const T y) noexcept : x(x), y(y) {}
-    template<typename U, std::enable_if_t<!(std::is_integral_v<T> && std::is_floating_point_v<U>), int> = 0>
+    template<typename U, std::enable_if_t<!is_float_to_int_v<U, T>, int> = 0>
     constexpr explicit Point(const Point<U>& pt) noexcept : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y))
     {}
     /// Convert floating-point to integer by truncating
-    template<typename U, std::enable_if_t<std::is_integral_v<T> && std::is_floating_point_v<U>, int> = 0>
+    template<typename U, std::enable_if_t<is_float_to_int_v<U, T>, int> = 0>
     constexpr explicit Point(Truncate_t, const Point<U>& pt) noexcept : x(static_cast<T>(pt.x)), y(static_cast<T>(pt.y))
     {}
     /// Convert floating-point to integer with rounding (default behavior)
-    template<typename U, std::enable_if_t<std::is_integral_v<T> && std::is_floating_point_v<U>, int> = 0>
+    template<typename U, std::enable_if_t<is_float_to_int_v<U, T>, int> = 0>
     constexpr explicit Point(const Point<U>& pt) noexcept : x(helpers::iround<T>(pt.x)), y(helpers::iround<T>(pt.y))
     {}
     constexpr Point(const Point&) = default;

libs/common/include/Point.h

@@ -70,7 +70,8 @@ constexpr T interpolate(const T startVal, const T endVal, const U elapsedTime, c
 }
 
 /// Linear interpolation, similar to C++20's std::lerp()
-constexpr float lerp(const float startVal, const float endVal, const float ratio) noexcept
+template<typename T>
+constexpr T lerp(const T startVal, const T endVal, const T ratio) noexcept
 {
     return startVal + ratio * (endVal - startVal);
 }

libs/common/include/helpers/mathFuncs.h

@@ -20,13 +20,44 @@ Rect ctrlBaseImage::GetImageRect() const
     return Rect(-img_->GetOrigin(), img_->GetSize());
 }
 
-void ctrlBaseImage::DrawImage(const DrawPoint& pos) const
+void ctrlBaseImage::DrawImage(const Rect& dstArea) const
 {
-    DrawImage(pos, modulationColor_);
+    DrawImage(dstArea, modulationColor_);
 }
 
-void ctrlBaseImage::DrawImage(const DrawPoint& pos, unsigned color) const
+void ctrlBaseImage::DrawImage(const Rect& dstArea, unsigned color) const
 {
-    if(img_)
-        img_->DrawFull(pos, color);
+    if(img_ == nullptr)
+        return;
+
+    auto dst = dstArea;
+    auto imageSize = img_->GetSize();
+    auto dstSize = dstArea.getSize();
+    Rect srcArea = Rect(DrawPoint::all(0), imageSize);
+
+    if(imageSize.x > dstSize.x)
+    {
+        auto halfDelta = (imageSize.x - dstSize.x) / 2;
+        srcArea.left += halfDelta;
+        srcArea.right -= halfDelta;
+    } else if(imageSize.x < dstSize.x)
+    {
+        auto halfDelta = (dstSize.x - imageSize.x) / 2;
+        dst.left += halfDelta;
+        dst.right -= halfDelta;
+    }
+
+    if(imageSize.y > dstSize.y)
+    {
+        auto halfDelta = (imageSize.y - dstSize.y) / 2;
+        srcArea.top += halfDelta;
+        srcArea.bottom -= halfDelta;
+    } else if(imageSize.y < dstSize.y)
+    {
+        auto halfDelta = (dstSize.y - imageSize.y) / 2;
+        dst.top += halfDelta;
+        dst.bottom -= halfDelta;
+    }
+
+    img_->Draw(dst, srcArea, color);
 }

libs/s25main/controls/ctrlBaseImage.cpp

@@ -24,8 +24,10 @@ class ctrlBaseImage
     /// Swap the images of those controls
     void SwapImage(ctrlBaseImage& other);
     Rect GetImageRect() const;
-    void DrawImage(const DrawPoint& pos) const;
-    void DrawImage(const DrawPoint& pos, unsigned color) const;
+
+    /// Draw the image on specified rectangular area. The image is centered inside dstArea and cropped to its size.
+    void DrawImage(const Rect& dstArea) const;
+    void DrawImage(const Rect& dstArea, unsigned color) const;
 
 private:
     ITexture* img_;

libs/s25main/controls/ctrlBaseImage.h

@@ -17,7 +17,7 @@ ctrlImage::~ctrlImage() = default;
  */
 void ctrlImage::Draw_()
 {
-    DrawImage(GetDrawPos());
+    DrawImage(Rect(GetDrawPos(), GetImageRect().getSize()));
 }
 
 bool ctrlImage::Msg_MouseMove(const MouseCoords& mc)

libs/s25main/controls/ctrlImage.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "ctrlImageButton.h"
+#include <ogl/ITexture.h>
 
 ctrlImageButton::ctrlImageButton(Window* parent, unsigned id, const DrawPoint& pos, const Extent& size,
                                  const TextureColor tc, ITexture* const image, const std::string& tooltip)
@@ -11,11 +12,27 @@ ctrlImageButton::ctrlImageButton(Window* parent, unsigned id, const DrawPoint& p
 
 void ctrlImageButton::DrawContent() const
 {
-    DrawPoint pos = GetDrawPos() + DrawPoint(GetSize()) / 2;
+    // Adding of origin compensates for its substraction inside ITexture::Draw()
+    auto pos = GetDrawPos() + GetImage()->GetOrigin();
+    auto size = GetSize();
+
+    if(hasBorder)
+    {
+        // Ensure that 3D border is not drawn on
+        const unsigned borderThickness = 2;
+        pos += DrawPoint::all(borderThickness);
+        size -= Extent::all(2 * borderThickness);
+    }
+
     if((state == ButtonState::Pressed || isChecked) && isEnabled)
+    {
         pos += DrawPoint::all(2);
+        size -= Extent::all(2);
+    }
+
+    Rect drawRect(pos, size);
     if(!isEnabled && GetModulationColor() == COLOR_WHITE)
-        DrawImage(pos, 0xFF555555);
+        DrawImage(drawRect, 0xFF555555);
     else
-        DrawImage(pos);
+        DrawImage(drawRect);
 }

libs/s25main/controls/ctrlImageButton.cpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "Point.h"
+#include "Rect.h"
 
 class ITexture
 {
@@ -15,4 +16,8 @@ class ITexture
     virtual Position GetOrigin() const = 0;
     virtual Extent GetSize() const = 0;
     virtual void DrawFull(const Position& dstPos, unsigned color = 0xFFFFFFFFu) = 0;
+
+    /// Draws portion of image specified by srcArea on area defined by dstArea.
+    /// In case of srcArea and dstArea size mismatch, scaling will occur.
+    virtual void Draw(Rect dstArea, Rect srcArea, unsigned color = 0xFFFFFFFFu) = 0;
 };

libs/s25main/ogl/ITexture.h

@@ -26,14 +26,14 @@ class glArchivItem_Bitmap : public virtual libsiedler2::baseArchivItem_Bitmap, p
     void DrawPart(const Rect& destArea, const DrawPoint& offset, unsigned color = COLOR_WHITE);
     /// Draw a rectangular part of the texture from the origin of it
     void DrawPart(const Rect& destArea, unsigned color = COLOR_WHITE);
-    /// Draw only percent% of the height of the image
+    /// Draw only percent% of the height of the image, counting from the bottom of the image
     void DrawPercent(const DrawPoint& dstPos, unsigned percent, unsigned color = COLOR_WHITE);
-
-protected:
     /// Draw the texture.
     /// src_w/h default to the full bitmap size
     /// dst_w/h default the src_w/h
-    void Draw(Rect dstArea, Rect srcArea, unsigned color = COLOR_WHITE);
+    void Draw(Rect dstArea, Rect srcArea, unsigned color = COLOR_WHITE) override;
+
+protected:
     void FillTexture() override;
     Extent CalcTextureSize() const override;
 };

libs/s25main/ogl/glArchivItem_Bitmap.h

@@ -42,6 +42,11 @@ void glArchivItem_Bitmap_Player::drawForPlayer(const DrawPoint& dst, unsigned pl
     DrawFull(dst, COLOR_WHITE, playerColor);
 }
 
+void glArchivItem_Bitmap_Player::Draw(Rect dstArea, Rect srcArea, unsigned color /*= COLOR_WHITE*/)
+{
+    Draw(dstArea, srcArea, color, COLOR_WHITE);
+}
+
 void glArchivItem_Bitmap_Player::Draw(Rect dstArea, Rect srcArea, unsigned color /*= COLOR_WHITE*/,
                                       unsigned player_color /*= COLOR_WHITE*/)
 {