Add mipmapping support to texture atlas.

Author: Possseidon

dang-gl/CMakeLists.txt

@@ -10,8 +10,11 @@ add_library(${PROJECT_NAME}
     src/Context/StateTypes.cpp
     src/General/GLConstants.cpp
     src/Image/BorderedImage.cpp
+    src/Image/BorderedImageMipmapper.cpp
     src/Image/Image.cpp
     src/Image/ImageBorder.cpp
+    src/Image/ImageMipmapper.cpp
+    src/Image/MipmapLevels.cpp
     src/Image/Pixel.cpp
     src/Image/PixelFormat.cpp
     src/Image/PixelInternalFormat.cpp

dang-gl/include/dang-gl/Image/BorderedImageMipmapper.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "dang-gl/Image/BorderedImage.h"
+#include "dang-gl/Image/ImageMipmapper.h"
+#include "dang-gl/Image/PixelFormat.h"
+#include "dang-gl/Image/PixelType.h"
+
+#include "dang-math/vector.h"
+
+namespace dang::gl {
+
+/// @brief Mipmaps a bordered image into a new bordered image (with border set to "none").
+template <typename TCalcType = float>
+struct BorderedImageMipmapper {
+    template <std::size_t v_dim, PixelFormat v_pixel_format, PixelType v_pixel_type, std::size_t v_row_alignment>
+    auto operator()(const BorderedImage<v_dim, v_pixel_format, v_pixel_type, v_row_alignment>& bordered_image) const
+    {
+        // Mipmaps entire image including border, but sets border of result to "none".
+        using BorderedImage = BorderedImage<v_dim, v_pixel_format, v_pixel_type, v_row_alignment>;
+        return BorderedImage(image_mipmapper<TCalcType>(bordered_image.image()));
+    }
+};
+
+template <typename TCalcType = float>
+inline constexpr BorderedImageMipmapper<TCalcType> bordered_image_mipmapper;
+
+} // namespace dang::gl

dang-gl/include/dang-gl/Image/ImageMipmapper.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "dang-gl/Image/Image.h"
+#include "dang-gl/Image/PixelFormat.h"
+#include "dang-gl/Image/PixelType.h"
+
+#include "dang-math/vector.h"
+
+namespace dang::gl {
+
+/// @brief Mipmaps a regular image using a 2x2 box filter.
+/// @remark Odd pixels are copied over, which might result in bad mipmaps, if the size is odd on a lot of levels.
+template <typename TCalcType = float>
+struct ImageMipmapper {
+    template <std::size_t v_dim, PixelFormat v_pixel_format, PixelType v_pixel_type, std::size_t v_row_alignment>
+    auto operator()(const Image<v_dim, v_pixel_format, v_pixel_type, v_row_alignment>& image) const
+    {
+        using Image = Image<v_dim, v_pixel_format, v_pixel_type, v_row_alignment>;
+        using Pixel = typename Image::Pixel;
+        using Size = typename Image::Size;
+        using CalcPixel = dmath::Vector<TCalcType, Pixel::dim>;
+
+        // It is not possible to change box_size at will.
+        // To get that working more changes would be necessary.
+        constexpr std::size_t box_size = 2;
+        constexpr auto box_pixels = box_size * box_size;
+
+        auto floor_size = image.size() / box_size;
+        auto ceil_size = (image.size() - 1) / box_size + 1;
+        Image result(ceil_size);
+        for (const auto& pos : dmath::sbounds2(floor_size)) {
+            CalcPixel color;
+            for (const auto& offset : dmath::sbounds2(box_size))
+                color += static_cast<CalcPixel>(image[pos * box_size + offset]);
+            result[pos] = static_cast<Pixel>(color / box_pixels);
+        }
+
+        auto odd_width = floor_size.x() != ceil_size.x();
+        auto odd_height = floor_size.y() != ceil_size.y();
+
+        if (odd_width) {
+            auto x = floor_size.x();
+            for (std::size_t y = 0; y < floor_size.y(); y++) {
+                CalcPixel color;
+                for (std::size_t offset = 0; offset < box_size; offset++)
+                    color += static_cast<CalcPixel>(image[Size(x * box_size, y * box_size + offset)]);
+                result[Size(x, y)] = static_cast<Pixel>(color / box_size);
+            }
+        }
+
+        if (odd_height) {
+            auto y = floor_size.y();
+            for (std::size_t x = 0; x < floor_size.x(); x++) {
+                CalcPixel color;
+                for (std::size_t offset = 0; offset < box_size; offset++)
+                    color += static_cast<CalcPixel>(image[Size(x * box_size + offset, y * box_size)]);
+                result[Size(x, y)] = static_cast<Pixel>(color / box_size);
+            }
+        }
+
+        if (odd_width && odd_height)
+            result[floor_size] = image[floor_size * box_size];
+
+        return result;
+    }
+};
+
+template <typename TCalcType = float>
+inline constexpr ImageMipmapper<TCalcType> image_mipmapper;
+
+} // namespace dang::gl

dang-gl/include/dang-gl/Image/MipmapLevels.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "dang-gl/global.h"
+
+#include "dang-math/vector.h"
+
+#include "dang-utils/utils.h"
+
+namespace dang::gl {
+
+/// @brief Calculates the number of required mipmap levels for the given texture size.
+constexpr std::size_t maxMipmapLevels(std::size_t size) { return dutils::ilog2ceil(size) + 1; }
+
+/// @brief Returns the next mipmap level size.
+/// @remarks Rounds up, which is unusual for mipmaps, but necessary when used in a texture atlas.
+constexpr dmath::svec2 nextMipmapSize(const dmath::svec2& size) { return (size.maxValue() - 1) / 2 + 1; }
+
+/// @brief Combines several mipmap levels of the same image.
+template <typename TBorderedImageData>
+class MipmapLevels {
+public:
+    using BorderedImageData = TBorderedImageData;
+    using Image = typename BorderedImageData::Image;
+
+    /// @brief Only stores the given image without generating any additional mipmaps.
+    MipmapLevels(Image full_image)
+        : mipmap_levels_{std::move(full_image)}
+    {}
+
+    /// @brief Only stores the given image without generating any additional mipmaps.
+    MipmapLevels(BorderedImageData full_image)
+        : mipmap_levels_{std::move(full_image)}
+    {}
+
+    /// @brief Stores the given image and all mipmap levels using the provided mipmapper.
+    template <typename TMipmapper>
+    MipmapLevels(Image full_image, TMipmapper mipmapper)
+        : mipmap_levels_(generateMipmapLevels(std::move(full_image), mipmapper))
+    {}
+
+    /// @brief Stores the given bordered image and all mipmap levels using the provided mipmapper.
+    template <typename TMipmapper>
+    MipmapLevels(BorderedImageData full_image, TMipmapper mipmapper)
+        : mipmap_levels_(generateMipmapLevels(std::move(full_image), mipmapper))
+    {}
+
+    /// @brief The full image with the highest resolution.
+    auto& fullImage() { return mipmap_levels_.front(); }
+    /// @brief The full image with the highest resolution.
+    const auto& fullImage() const { return mipmap_levels_.front(); }
+
+    /// @brief The total number of mipmap levels, including the original, full size image.
+    auto count() const { return mipmap_levels_.size(); }
+
+    /// @brief A specific mipmap level with the given index, where 0 gives the original, full size image.
+    auto& operator[](std::size_t index) { return mipmap_levels_[index]; }
+    /// @brief A specific mipmap level with the given index, where 0 gives the original, full size image.
+    const auto& operator[](std::size_t index) const { return mipmap_levels_[index]; }
+
+    auto begin() { return mipmap_levels_.begin(); }
+    auto begin() const { return mipmap_levels_.begin(); }
+    auto end() { return mipmap_levels_.end(); }
+    auto end() const { return mipmap_levels_.end(); }
+
+private:
+    /// @brief Uses the given mipmapper to generate a vector of all mipmap levels for the given image.
+    template <typename TMipmapper>
+    static auto generateMipmapLevels(BorderedImageData&& full_image, TMipmapper mipmapper)
+    {
+        auto count = maxMipmapLevels(full_image.size().maxValue());
+        std::vector<BorderedImageData> mipmap_levels{std::move(full_image)};
+        for (std::size_t index = 1; index < count; index++) {
+            const auto& prev = mipmap_levels.back();
+            auto mipmapped = mipmapper(prev);
+            ensureSizeHalved(prev.size(), mipmapped.size());
+            mipmap_levels.push_back(std::move(mipmapped));
+        }
+        return mipmap_levels;
+    }
+
+    /// @brief Throws an exception if "halved" isn't the correct next mipmap level size for "original".
+    static void ensureSizeHalved(dmath::svec2 original, dmath::svec2 halved)
+    {
+        if (halved != nextMipmapSize(original))
+            throw std::invalid_argument("mipmapper did not properly half the image size");
+    }
+
+    std::vector<BorderedImageData> mipmap_levels_;
+};
+
+} // namespace dang::gl

dang-gl/include/dang-gl/Texturing/TextureAtlasBase.h

@@ -24,28 +24,24 @@ class BasicFrozenTextureAtlas;
 template <typename TTextureBase>
 class TextureAtlasBase : public TTextureBase {
 public:
-    using BorderedImageData = typename TTextureBase::BorderedImageData;
+    using TextureBase = TTextureBase;
+    using BorderedImageData = typename TextureBase::BorderedImageData;
     using Tiles = TextureAtlasTiles<BorderedImageData>;
     using TileHandle = typename Tiles::TileHandle;
-    using Frozen = BasicFrozenTextureAtlas<TTextureBase>;
+    using MipmapLevels = typename Tiles::MipmapLevels;
+    using Frozen = BasicFrozenTextureAtlas<TextureBase>;
 
     TextureAtlasBase(const TextureAtlasLimits& limits)
         : tiles_(limits)
     {}
 
-    [[nodiscard]] TileHandle add(BorderedImageData bordered_image_data)
-    {
-        return tiles_.add(std::move(bordered_image_data));
-    }
+    [[nodiscard]] TileHandle add(MipmapLevels mipmap_levels) { return tiles_.add(std::move(mipmap_levels)); }
 
-    void add(std::string name, BorderedImageData bordered_image_data)
-    {
-        tiles_.add(std::move(name), std::move(bordered_image_data));
-    }
+    void add(std::string name, MipmapLevels mipmap_levels) { tiles_.add(std::move(name), std::move(mipmap_levels)); }
 
-    [[nodiscard]] TileHandle addWithHandle(std::string name, BorderedImageData bordered_image_data)
+    [[nodiscard]] TileHandle addWithHandle(std::string name, MipmapLevels mipmap_levels)
     {
-        return tiles_.addWithHandle(std::move(name), std::move(bordered_image_data));
+        return tiles_.addWithHandle(std::move(name), std::move(mipmap_levels));
     }
 
     [[nodiscard]] bool exists(const TileHandle& tile_handle) const { return tiles_.exists(tile_handle); }
@@ -82,19 +78,20 @@ class TextureAtlasBase : public TTextureBase {
 template <typename TTextureBase>
 class BasicFrozenTextureAtlas : public TTextureBase {
 public:
-    using BorderedImageData = typename TTextureBase::BorderedImageData;
+    using TextureBase = TTextureBase;
+    using BorderedImageData = typename TextureBase::BorderedImageData;
     using Tiles = FrozenTextureAtlasTiles<BorderedImageData>;
     using TileHandle = typename Tiles::TileHandle;
 
-    friend class TextureAtlasBase<TTextureBase>;
+    friend class TextureAtlasBase<TextureBase>;
 
     [[nodiscard]] bool exists(const TileHandle& tile_handle) const { return tiles_.exists(tile_handle); }
     [[nodiscard]] bool exists(const std::string& name) const { return tiles_.exists(name); }
     [[nodiscard]] TileHandle operator[](const std::string& name) const { return tiles_[name]; }
 
 private:
-    BasicFrozenTextureAtlas(Tiles&& tiles, TTextureBase&& texture)
-        : TTextureBase(std::move(texture))
+    BasicFrozenTextureAtlas(Tiles&& tiles, TextureBase&& texture)
+        : TextureBase(std::move(texture))
         , tiles_(std::move(tiles))
     {}