Use no GL-Types in TextureAtlasTiles anymore.

- Use std::size_t everywhere.
- Get rid of a load of static_casts.
  - Those are now in the OpenGL specializations.
- Fix ensureTextureSize for zero sized textures.
- Added support for MipmapLevels in tests.

Author: Possseidon

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

@@ -73,22 +73,27 @@ class TextureAtlasMultiTexture {
     Texture2DArray& texture(TSubTextureEnum sub_texture) { return textures_[sub_texture]; }
 
 protected:
-    bool resize(GLsizei required_size, GLsizei layers, GLsizei mipmap_levels)
+    bool resize(std::size_t required_size, std::size_t layers, std::size_t mipmap_levels)
     {
         assert(textures_.front().size().x() == textures_.front().size().y());
         if (required_size == textures_.front().size().x() && layers == textures_.front().size().z())
             return false;
         // /!\ Resets all texture parameters!
-        for (auto& texture : textures_)
-            texture = Texture2DArray(
-                {required_size, required_size, layers}, mipmap_levels, pixel_format_internal_v<v_pixel_format>);
+        for (auto& texture : textures_) {
+            texture = Texture2DArray(svec3(static_cast<GLsizei>(required_size),
+                                           static_cast<GLsizei>(required_size),
+                                           static_cast<GLsizei>(layers)),
+                                     static_cast<GLsizei>(mipmap_levels),
+                                     pixel_format_internal_v<v_pixel_format>);
+        }
         return true;
     };
 
-    void modify(const BorderedImageData& bordered_image_data, ivec3 offset, GLint mipmap_level)
+    void modify(const BorderedImageData& bordered_image_data, dmath::svec3 offset, std::size_t mipmap_level)
     {
         for (auto sub_texture : dutils::enumerate<TSubTextureEnum>)
-            textures_[sub_texture].modify(bordered_image_data[sub_texture], offset, mipmap_level);
+            textures_[sub_texture].modify(
+                bordered_image_data[sub_texture], static_cast<GLint>(offset), static_cast<GLint>(mipmap_level));
     };
 
 private:
@@ -116,8 +121,8 @@ class MultiTextureAtlas
     using Base = TextureAtlasBase<
         detail::TextureAtlasMultiTexture<TSubTextureEnum, v_pixel_format, v_pixel_type, v_row_alignment>>;
 
-    explicit MultiTextureAtlas(std::optional<GLsizei> max_texture_size = std::nullopt,
-                               std::optional<GLsizei> max_layer_count = std::nullopt)
+    explicit MultiTextureAtlas(std::optional<std::size_t> max_texture_size = std::nullopt,
+                               std::optional<std::size_t> max_layer_count = std::nullopt)
         : Base(TextureAtlasUtils::checkLimits(max_texture_size, max_layer_count))
     {}
 };

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

@@ -26,20 +26,23 @@ class TextureAtlasSingleTexture {
     Texture2DArray& texture() { return texture_; }
 
 protected:
-    bool resize(GLsizei required_size, GLsizei layers, GLsizei mipmap_levels)
+    bool resize(std::size_t required_size, std::size_t layers, std::size_t mipmap_levels)
     {
         assert(texture_.size().x() == texture_.size().y());
         if (required_size == texture_.size().x() && layers == texture_.size().z())
             return false;
         // /!\ Resets all texture parameters!
-        texture_ = Texture2DArray(
-            {required_size, required_size, layers}, mipmap_levels, pixel_format_internal_v<v_pixel_format>);
+        texture_ = Texture2DArray(svec3(static_cast<GLsizei>(required_size),
+                                        static_cast<GLsizei>(required_size),
+                                        static_cast<GLsizei>(layers)),
+                                  static_cast<GLsizei>(mipmap_levels),
+                                  pixel_format_internal_v<v_pixel_format>);
         return true;
     };
 
-    void modify(const BorderedImageData& bordered_image_data, ivec3 offset, GLint mipmap_level)
+    void modify(const BorderedImageData& bordered_image_data, dmath::svec3 offset, std::size_t mipmap_level)
     {
-        texture_.modify(bordered_image_data.image(), offset, mipmap_level);
+        texture_.modify(bordered_image_data.image(), static_cast<ivec3>(offset), static_cast<GLint>(mipmap_level));
     };
 
 private:
@@ -56,8 +59,8 @@ class TextureAtlas
 public:
     using Base = TextureAtlasBase<detail::TextureAtlasSingleTexture<v_pixel_format, v_pixel_type, v_row_alignment>>;
 
-    explicit TextureAtlas(std::optional<GLsizei> max_texture_size = std::nullopt,
-                          std::optional<GLsizei> max_layer_count = std::nullopt)
+    explicit TextureAtlas(std::optional<std::size_t> max_texture_size = std::nullopt,
+                          std::optional<std::size_t> max_layer_count = std::nullopt)
         : Base(TextureAtlasUtils::checkLimits(max_texture_size, max_layer_count))
     {}
 };

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

@@ -11,9 +11,9 @@ The TextureBase concept:
 
 - Move-constructible
 - using BorderedImageData = ...;
-- bool resize(GLsizei required_size, GLsizei layers, GLsizei mipmap_levels)
+- bool resize(std::size_t required_size, std::size_t layers, std::size_t mipmap_levels)
     -> protected, resizes the texture
-- void modify(const BorderedImageData& bordered_image_data, ivec3 offset, GLint mipmap_level)
+- void modify(const BorderedImageData& bordered_image_data, dmath::svec3 offset, std::size_t mipmap_level)
     -> protected, modifies the texture at a given spot
 
 */

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

@@ -29,8 +29,8 @@ The BorderedImageData concept:
 
 /// @brief Holds maximum size restrictions of the texture atlas.
 struct TextureAtlasLimits {
-    GLsizei max_texture_size;
-    GLsizei max_layer_count;
+    std::size_t max_texture_size;
+    std::size_t max_layer_count;
 };
 
 /// @brief Can store a large number of texture tiles in multiple layers of grids.
@@ -43,25 +43,25 @@ class TextureAtlasTiles {
 
     /// @brief A function that is called with required size (width and height), layers and mipmap levels.
     /// @remark Returns whether actual resizing occurred.
-    using TextureResizeFunction = std::function<bool(GLsizei, GLsizei, GLsizei)>;
+    using TextureResizeFunction = std::function<bool(std::size_t, std::size_t, std::size_t)>;
 
     /// @brief A function that uploads the image to a specific position and mipmap level of a texture.
-    using TextureModifyFunction = std::function<void(const BorderedImageData&, ivec3, GLint)>;
+    using TextureModifyFunction = std::function<void(const BorderedImageData&, dmath::svec3, std::size_t)>;
 
     class TileHandle;
 
 private:
     /// @brief Atlas information which is stored in a unique_ptr, so that it can be shared with all TileData instances.
     struct AtlasInfo {
-        GLsizei atlas_size;
+        std::size_t atlas_size;
     };
 
     /// @brief Information about the placement of a tile, including whether it has been written to the texture yet.
     struct TilePlacement {
         /// @brief The index of this tile in the layer.
         std::size_t index = 0;
         /// @brief The position where the write this tile in the array texture.
-        svec3 position;
+        dmath::svec3 position;
         /// @brief Whether this tile has been written to the array texture yet.
         bool written = false;
 
@@ -70,19 +70,19 @@ class TextureAtlasTiles {
         /// @param index The index of this tile in the layer.
         /// @param layer The index of the layer itself, determining the z position.
         /// @param position The x and y coordinates of the position.
-        TilePlacement(std::size_t index, svec2 position, GLsizei layer)
+        TilePlacement(std::size_t index, dmath::svec2 position, std::size_t layer)
             : index(index)
             , position(position.x(), position.y(), layer)
         {}
 
         /// @brief The position on the given mipmap layer.
-        auto pixelPos(GLsizei mipmap_layer = 0) const { return position.xy() >> mipmap_layer; }
+        auto pixelPos(std::size_t mipmap_layer = 0) const { return position.xy() >> mipmap_layer; }
 
         /// @brief The position and atlas layer on the given mipmap layer.
-        auto pixelPosAndLayer(GLsizei mipmap_layer = 0) const
+        auto pixelPosAndLayer(std::size_t mipmap_layer = 0) const
         {
             auto [x, y] = pixelPos(mipmap_layer);
-            return svec3{x, y, position.z()};
+            return dmath::svec3(x, y, position.z());
         }
     };
 
@@ -108,7 +108,7 @@ class TextureAtlasTiles {
     class Layer {
     public:
         /// @brief Creates a new layer with the given tile size, specified as log2.
-        explicit Layer(const svec2& tile_size_log2, std::size_t max_texture_size)
+        explicit Layer(const dmath::svec2& tile_size_log2, std::size_t max_texture_size)
             : tile_size_log2_(tile_size_log2)
             , max_tiles_(calculateMaxTiles(max_texture_size))
         {}
@@ -119,22 +119,25 @@ class TextureAtlasTiles {
         Layer& operator=(Layer&&) = default;
 
         /// @brief Returns the log2 of the pixel size of a tile.
-        svec2 tileSizeLog2() const { return tile_size_log2_; }
+        dmath::svec2 tileSizeLog2() const { return tile_size_log2_; }
         /// @brief Returns the pixel size of a single tile.
-        svec2 tileSize() const { return {GLsizei{1} << tile_size_log2_.x(), GLsizei{1} << tile_size_log2_.y()}; }
+        dmath::svec2 tileSize() const
+        {
+            return {std::size_t{1} << tile_size_log2_.x(), std::size_t{1} << tile_size_log2_.y()};
+        }
 
         /// @brief Calculates the required grid size (for the longer side) to fit all tiles.
-        GLsizei requiredGridSizeLog2() const
+        std::size_t requiredGridSizeLog2() const
         {
             if (tiles_.empty())
                 return 0;
-            auto diff_log2 = std::abs(tile_size_log2_.x() - tile_size_log2_.y());
+            auto diff_log2 = dutils::absoluteDifference(tile_size_log2_.x(), tile_size_log2_.y());
             auto square_tiles = ((tiles_.size() - 1) >> diff_log2) + 1;
             return (dutils::ilog2ceil(square_tiles) + 1) >> 1;
         }
 
         /// @brief Calculates the required texture size to fit all tiles.
-        GLsizei requiredTextureSize() const { return tileSize().maxValue() << requiredGridSizeLog2(); }
+        std::size_t requiredTextureSize() const { return tileSize().maxValue() << requiredGridSizeLog2(); }
 
         /// @brief Whether the grid is empty.
         bool empty() const { return tiles_.empty(); }
@@ -143,7 +146,7 @@ class TextureAtlasTiles {
         bool full() const { return first_free_tile_ == max_tiles_; }
 
         /// @brief Places a single tile in the grid, filling potential gaps that appeared after removing tiles.
-        void addTile(TileData& tile, GLsizei layer)
+        void addTile(TileData& tile, std::size_t layer)
         {
             assert(!full());
             tile.placement = TilePlacement(first_free_tile_, tileSize() * indexToPosition(first_free_tile_), layer);
@@ -199,8 +202,7 @@ class TextureAtlasTiles {
         /// @brief Draws a single tile onto the texture.
         void drawTile(TileData& tile, const TextureModifyFunction& modify) const
         {
-            for (GLint mipmap_level = 0; mipmap_level < static_cast<GLint>(tile.mipmap_levels.count());
-                 mipmap_level++) {
+            for (std::size_t mipmap_level = 0; mipmap_level < tile.mipmap_levels.count(); mipmap_level++) {
                 const auto& bordered_image = tile.mipmap_levels[mipmap_level];
                 assert(bordered_image);
                 modify(bordered_image, tile.placement.pixelPosAndLayer(mipmap_level), mipmap_level);
@@ -211,38 +213,38 @@ class TextureAtlasTiles {
         /// @brief Returns the maximum number of tiles, that can fit in a square texture of the given size.
         std::size_t calculateMaxTiles(std::size_t max_texture_size) const
         {
-            assert(static_cast<std::size_t>(tileSize().maxValue()) <= max_texture_size);
+            assert(tileSize().maxValue() <= max_texture_size);
             auto x_tiles = std::size_t{1} << dutils::ilog2(max_texture_size >> tile_size_log2_.x());
             auto y_tiles = std::size_t{1} << dutils::ilog2(max_texture_size >> tile_size_log2_.y());
             return x_tiles * y_tiles;
         }
 
         /// @brief Inverse pairing function, returning only even/odd bits as x/y.
-        svec2 indexToPosition(std::size_t index)
+        dmath::svec2 indexToPosition(std::size_t index)
         {
-            auto size_diff_log2 = std::abs(tile_size_log2_.x() - tile_size_log2_.y());
+            auto size_diff_log2 = dutils::absoluteDifference(tile_size_log2_.x(), tile_size_log2_.y());
             auto flip = tile_size_log2_.x() < tile_size_log2_.y();
-            auto x = static_cast<GLsizei>(dutils::removeOddBits(index >> size_diff_log2));
-            auto y = static_cast<GLsizei>(dutils::removeOddBits(index >> (size_diff_log2 + 1)));
+            auto x = dutils::removeOddBits(index >> size_diff_log2);
+            auto y = dutils::removeOddBits(index >> (size_diff_log2 + 1));
             y <<= size_diff_log2;
             y |= index & ~(~std::size_t{0} << size_diff_log2);
-            return flip ? svec2(y, x) : svec2(x, y);
+            return flip ? dmath::svec2(y, x) : dmath::svec2(x, y);
         }
 
         /// @brief Pairing function, interleaving x/y as odd/even bits of the resulting integer.
-        std::size_t positionToIndex(svec2 position)
+        std::size_t positionToIndex(dmath::svec2 position)
         {
             auto size_diff_log2 = std::abs(tile_size_log2_.x() - tile_size_log2_.y());
             auto flip = tile_size_log2_.x() < tile_size_log2_.y();
             position = flip ? position.yx() : position;
             auto result = position.y() & ~(~std::size_t{0} << size_diff_log2);
             position.y() >>= size_diff_log2;
-            result |= dutils::interleaveZeros(static_cast<std::size_t>(position.x())) << size_diff_log2;
-            result |= dutils::interleaveZeros(static_cast<std::size_t>(position.y())) << (size_diff_log2 + 1);
+            result |= dutils::interleaveZeros(position.x()) << size_diff_log2;
+            result |= dutils::interleaveZeros(position.y()) << (size_diff_log2 + 1);
             return result;
         }
 
-        svec2 tile_size_log2_;
+        dmath::svec2 tile_size_log2_;
         std::vector<TileData*> tiles_;
         std::size_t first_free_tile_ = 0;
         std::size_t max_tiles_;
@@ -271,30 +273,27 @@ class TextureAtlasTiles {
             return !(lhs == rhs);
         }
 
-        auto atlasPixelSize(GLsizei mipmap_layer = 0) const
+        auto atlasPixelSize(std::size_t mipmap_layer = 0) const
         {
             return dataOrThrow().atlas_info->atlas_size >> mipmap_layer;
         }
 
-        auto pixelPos(GLsizei mipmap_layer = 0) const { return dataOrThrow().placement.pixelPos(mipmap_layer); }
+        auto pixelPos(std::size_t mipmap_layer = 0) const { return dataOrThrow().placement.pixelPos(mipmap_layer); }
 
-        auto pixelSize(GLsizei mipmap_layer = 0) const
-        {
-            return dataOrThrow().mipmap_levels[static_cast<std::size_t>(mipmap_layer)].size();
-        }
+        auto pixelSize(std::size_t mipmap_layer = 0) const { return dataOrThrow().mipmap_levels[mipmap_layer].size(); }
 
-        auto pixelPosAndLayer(GLsizei mipmap_layer = 0) const
+        auto pixelPosAndLayer(std::size_t mipmap_layer = 0) const
         {
             return dataOrThrow().placement.pixelPosAndLayer(mipmap_layer);
         }
 
-        auto pos() const { return static_cast<vec2>(pixelPos()) / vec2(static_cast<GLfloat>(atlasPixelSize())); }
-        auto size() const { return static_cast<vec2>(pixelSize()) / vec2(static_cast<GLfloat>(atlasPixelSize())); }
+        auto pos() const { return static_cast<dmath::vec2>(pixelPos()) / static_cast<float>(atlasPixelSize()); }
+        auto size() const { return static_cast<dmath::vec2>(pixelSize()) / static_cast<float>(atlasPixelSize()); }
 
         bounds2 bounds() const
         {
-            auto padding = dataOrThrow().mipmap_levels.front().padding();
-            auto inset = static_cast<vec2>(padding) / (2.0f * atlasPixelSize());
+            auto padding = dataOrThrow().mipmap_levels[0].padding();
+            auto inset = static_cast<dmath::vec2>(padding) / (2.0f * atlasPixelSize());
             auto top_left = pos();
             auto bottom_right = top_left + size();
             return bounds2(top_left, bottom_right).inset(inset);
@@ -323,12 +322,7 @@ class TextureAtlasTiles {
     /// @exception std::invalid_argument if either maximum is less than zero.
     TextureAtlasTiles(const TextureAtlasLimits& limits)
         : limits_(limits)
-    {
-        if (limits.max_texture_size < 0)
-            throw std::invalid_argument("Maximum texture size cannot be negative.");
-        if (limits.max_layer_count < 0)
-            throw std::invalid_argument("Maximum layer count cannot be negative.");
-    }
+    {}
 
     TextureAtlasTiles(const TextureAtlasTiles&) = delete;
     TextureAtlasTiles(TextureAtlasTiles&&) = default;
@@ -402,18 +396,20 @@ class TextureAtlasTiles {
     void ensureTextureSize(const TextureResizeFunction& resize)
     {
         auto required_size = maxLayerSize();
-        auto layers = static_cast<GLsizei>(layers_.size());
-        auto mipmap_levels = static_cast<GLsizei>(maxMipmapLevels(static_cast<std::size_t>(required_size)));
+        if (required_size == 0)
+            return;
+        auto layers = layers_.size();
+        auto mipmap_levels = maxMipmapLevels(required_size);
         if (!resize(required_size, layers, mipmap_levels))
             return;
         for (const auto& tile : tiles_)
             tile->placement.written = false;
     }
 
     /// @brief Finds the maximum layer size.
-    GLsizei maxLayerSize() const
+    std::size_t maxLayerSize() const
     {
-        GLsizei result = 0;
+        std::size_t result = 0;
         for (auto& layer : layers_)
             result = std::max(result, layer.requiredTextureSize());
         return result;
@@ -423,16 +419,14 @@ class TextureAtlasTiles {
 
     /// @brief Returns a pointer to a (possibly newly created) layer for the given tile size and its index.
     /// @remark The pointer can be null, in which case a new layer would have exceeded the maximum layer count.
-    LayerResult layerForTile(const svec2& size)
+    LayerResult layerForTile(const dmath::svec2& size)
     {
-        auto unsigned_width = static_cast<std::make_unsigned_t<GLsizei>>(size.x());
-        auto unsigned_height = static_cast<std::make_unsigned_t<GLsizei>>(size.y());
-        auto tile_size_log2 = svec2(static_cast<GLsizei>(dutils::ilog2ceil(unsigned_width)),
-                                    static_cast<GLsizei>(dutils::ilog2ceil(unsigned_height)));
+        auto tile_size_log2 = dmath::svec2(static_cast<std::size_t>(dutils::ilog2ceil(size.x())),
+                                           static_cast<std::size_t>(dutils::ilog2ceil(size.y())));
         auto layer_iter = std::find_if(begin(layers_), end(layers_), [&](const Layer& layer) {
             return !layer.full() && layer.tileSizeLog2() == tile_size_log2;
         });
-        auto layer_index = std::distance(begin(layers_), layer_iter);
+        auto layer_index = static_cast<std::size_t>(std::distance(begin(layers_), layer_iter));
         if (layer_iter != end(layers_))
             return {&*layer_iter, layer_index};
         if (layer_index >= limits_.max_layer_count)
@@ -455,13 +449,13 @@ class TextureAtlasTiles {
             throw std::invalid_argument("Image is too big for texture atlas. (" + size.format() + " > " +
                                         std::to_string(limits_.max_texture_size) + ")");
 
-        auto [layer, index] = layerForTile(static_cast<svec2>(size));
+        auto [layer, index] = layerForTile(size);
         if (!layer)
             throw std::length_error("Too many texture atlas layers. (max " + std::to_string(limits_.max_layer_count) +
                                     ")");
 
-        const auto& tile = tiles_.emplace_back(std::make_shared<TileData>(std::move(bordered_image_data), atlas_info_));
-        layer->addTile(*tile, static_cast<GLsizei>(index));
+        const auto& tile = tiles_.emplace_back(std::make_shared<TileData>(std::move(mipmap_levels), atlas_info_));
+        layer->addTile(*tile, index);
         atlas_info_->atlas_size = maxLayerSize();
         return tile;
     }