gosu 1.4.6 → 2.0.0.pre6

data/src/TextBuilder.hpp

@@ -6,6 +6,9 @@
 
 namespace Gosu
 {
+    // A single word and its formatting context. A "word" is anything that is atomic in terms of
+    // where Gosu can introduce line breaks. Even a single word has several "parts" because e.g. a
+    // single character in the middle could be bold.
     struct WordInfo
     {
         std::vector<FormattedString> parts;
@@ -25,16 +28,10 @@ namespace Gosu
         double m_line_spacing;
         Alignment m_align;
 
-        enum EndOfLineReason
-        {
-            LINE_TOO_LONG,
-            END_OF_PARAGRAPH,
-            END_OF_TEXT
-        };
-
         // Input.
         std::vector<WordInfo> m_current_line;
         int m_current_line_width = 0;
+        enum EndOfLineReason : int;
         void flush_current_line(EndOfLineReason reason);
 
         // Output.
@@ -42,13 +39,13 @@ namespace Gosu
         int m_used_lines = 0;
         int m_allocated_lines = 0;
         void allocate_next_line();
-        void resize_to_allocated_lines();
+        void reallocate(int lines);
 
     public:
         TextBuilder(const std::string& font_name, int font_height, int line_spacing, int width,
                     Alignment align);
 
-        void feed_word(std::vector<FormattedString>&& word);
+        void feed_word(std::vector<FormattedString> word);
 
         Bitmap move_into_bitmap() &&;
     };

data/src/Texture.cpp

@@ -1,39 +1,35 @@
 #include "Texture.hpp"
-#include "TexChunk.hpp"
-#include "Log.hpp"
 #include <Gosu/Bitmap.hpp>
-#include <Gosu/Graphics.hpp>
 #include <Gosu/Platform.hpp>
+#include "OpenGLContext.hpp"
+#include "TexChunk.hpp"
 #include <stdexcept>
-using namespace std;
 
-namespace Gosu
+Gosu::Texture::Texture(int width, int height, bool retro)
+    : m_bin_packer(width, height),
+      m_tex_name(0),
+      m_retro(retro)
 {
-    bool undocumented_retrofication = false;
-}
+    if (width <= 0 || height <= 0) {
+        throw std::invalid_argument("Gosu::Texture must not be empty");
+    }
 
-Gosu::Texture::Texture(unsigned width, unsigned height, bool retro)
-: allocator_(width, height), retro_(retro)
-{
-    log("Allocating a new texture of size %dx%d (retro=%d)", width, height, (int) retro);
+    const OpenGLContext current_context;
 
-    ensure_current_context();
-    
     // Create texture name.
-    glGenTextures(1, &tex_name_);
-    if (tex_name_ == static_cast<GLuint>(-1)) throw runtime_error("Couldn't create OpenGL texture");
+    glGenTextures(1, &m_tex_name);
+    // GCOV_EXCL_START: Hard to simulate out-of-texture situations.
+    if (m_tex_name == static_cast<GLuint>(-1)) {
+        throw std::runtime_error("Failed to allocate OpenGL texture");
+    }
+    // GCOV_EXCL_END
 
     // Create empty texture.
-    glBindTexture(GL_TEXTURE_2D, tex_name_);
-#ifdef GOSU_IS_OPENGLES
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, allocator_.width(), allocator_.height(), 0, GL_RGBA,
+    glBindTexture(GL_TEXTURE_2D, m_tex_name);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_bin_packer.width(), m_bin_packer.height(), 0, GL_RGBA,
                  GL_UNSIGNED_BYTE, nullptr);
-#else
-    glTexImage2D(GL_TEXTURE_2D, 0, 4, allocator_.width(), allocator_.height(), 0, GL_RGBA,
-                 GL_UNSIGNED_BYTE, nullptr);
-#endif
-    
-    if (retro || undocumented_retrofication) {
+
+    if (retro) {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     }
@@ -41,7 +37,7 @@ Gosu::Texture::Texture(unsigned width, unsigned height, bool retro)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     }
-    
+
 #ifdef GL_CLAMP_TO_EDGE
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
@@ -53,79 +49,65 @@ Gosu::Texture::Texture(unsigned width, unsigned height, bool retro)
 
 Gosu::Texture::~Texture()
 {
-    ensure_current_context();
-    
-    glDeleteTextures(1, &tex_name_);
+    try {
+        const OpenGLContext current_context;
+        glDeleteTextures(1, &m_tex_name);
+    } catch (...)
+    {
+        // Leaking is better than throwing in a destructor.
+    }
 }
 
-unsigned Gosu::Texture::width() const
+std::unique_ptr<Gosu::TexChunk> Gosu::Texture::try_alloc(const Bitmap& bitmap, int padding)
 {
-    return allocator_.width();
-}
+    const std::shared_ptr<const Rect> rect = m_bin_packer.alloc(bitmap.width(), bitmap.height());
 
-unsigned Gosu::Texture::height() const
-{
-    return allocator_.height();
-}
+    if (!rect) {
+        return nullptr;
+    }
 
-GLuint Gosu::Texture::tex_name() const
-{
-    return tex_name_;
-}
+    insert(bitmap, rect->x, rect->y);
 
-bool Gosu::Texture::retro() const
-{
-    return retro_;
+    const Rect rect_without_padding { rect->x + padding, rect->y + padding,
+                                      rect->width - 2 * padding, rect->height - 2 * padding };
+    return std::make_unique<TexChunk>(shared_from_this(), rect_without_padding, rect);
 }
 
-unique_ptr<Gosu::TexChunk> Gosu::Texture::try_alloc(const Bitmap& bmp, unsigned padding)
+void Gosu::Texture::insert(const Gosu::Bitmap& bitmap, int x, int y)
 {
-    BlockAllocator::Block block;
-    
-    if (!allocator_.alloc(bmp.width(), bmp.height(), block)) return nullptr;
-    
-    unique_ptr<TexChunk> result(new TexChunk(shared_from_this(),
-                                             block.left   + padding,
-                                             block.top    + padding,
-                                             block.width  - 2 * padding,
-                                             block.height - 2 * padding,
-                                             padding));
-    
-    ensure_current_context();
-    
-    glBindTexture(GL_TEXTURE_2D, tex_name_);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, block.left, block.top, block.width, block.height,
-                    Color::GL_FORMAT, GL_UNSIGNED_BYTE, bmp.data());
-
-    return result;
-}
+    if (!Rect::covering(*this).contains(Rect { x, y, bitmap.width(), bitmap.height() })) {
+        throw std::invalid_argument("Gosu::Texture::insert: Rect exceeds bounds");
+    }
 
-void Gosu::Texture::block(unsigned x, unsigned y, unsigned width, unsigned height)
-{
-    allocator_.block(x, y, width, height);
+    const OpenGLContext current_context;
+    glBindTexture(GL_TEXTURE_2D, m_tex_name);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, bitmap.width(), bitmap.height(), GL_RGBA,
+                    GL_UNSIGNED_BYTE, bitmap.data());
 }
 
-void Gosu::Texture::free(unsigned x, unsigned y, unsigned width, unsigned height)
+Gosu::Bitmap Gosu::Texture::to_bitmap(const Rect& rect) const
 {
-    allocator_.free(x, y, width, height);
-}
+    if (!Rect::covering(*this).contains(rect)) {
+        throw std::invalid_argument("Gosu::Texture::to_bitmap: Rect exceeds bounds");
+    }
 
-Gosu::Bitmap Gosu::Texture::to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
-{
 #ifdef GOSU_IS_OPENGLES
     // See here for one possible implementation: https://github.com/apitrace/apitrace/issues/70
     // (Could reuse a lot of code from OffScreenTarget)
-    throw logic_error("Texture::to_bitmap not supported on iOS");
+    throw std::logic_error("Gosu::Texture::to_bitmap not supported in OpenGL ES");
 #else
-    ensure_current_context();
-    
-    Bitmap full_texture(this->width(), this->height());
-    glBindTexture(GL_TEXTURE_2D, tex_name());
-    // TODO: There are ways to retrieve only part of a texture, which we should use sooner or later.
-    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, full_texture.data());
-    Bitmap bitmap(width, height);
-    bitmap.insert(-int(x), -int(y), full_texture);
-    
+    const OpenGLContext current_context;
+    Bitmap bitmap(width(), height());
+    glBindTexture(GL_TEXTURE_2D, m_tex_name);
+    // This should use glGetTextureSubImage where available: https://stackoverflow.com/a/38148494
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, bitmap.data());
+
+    if (rect != Rect::covering(*this)) {
+        Bitmap smaller_bitmap(rect.width, rect.height);
+        smaller_bitmap.insert(bitmap, -rect.x, -rect.y);
+        bitmap = std::move(smaller_bitmap);
+    }
+
     return bitmap;
 #endif
 }

data/src/Texture.hpp

@@ -1,29 +1,31 @@
 #pragma once
 
-#include "BlockAllocator.hpp"
-#include "GraphicsImpl.hpp"
-#include "TexChunk.hpp"
 #include <Gosu/Fwd.hpp>
-#include <Gosu/Bitmap.hpp>
+#include "BinPacker.hpp"
+#include "TexChunk.hpp"
+#include <cstdint>
 #include <memory>
-#include <vector>
 
-class Gosu::Texture : public std::enable_shared_from_this<Texture>
+namespace Gosu
 {
-    // BlockAllocator can't be copied or moved, so neither can Texture.
-    BlockAllocator allocator_;
-    GLuint tex_name_;
-    bool retro_;
-    
-public:
-    Texture(unsigned width, unsigned height, bool retro);
-    ~Texture();
-    unsigned width() const;
-    unsigned height() const;
-    GLuint tex_name() const;
-    bool retro() const;
-    std::unique_ptr<TexChunk> try_alloc(const Bitmap& bmp, unsigned padding);
-    void block(unsigned x, unsigned y, unsigned width, unsigned height);
-    void free(unsigned x, unsigned y, unsigned width, unsigned height);
-    Bitmap to_bitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;
-};
+    class Texture : public std::enable_shared_from_this<Texture>, private Noncopyable
+    {
+        BinPacker m_bin_packer;
+        std::uint32_t m_tex_name;
+        const bool m_retro;
+
+    public:
+        Texture(int width, int height, bool retro);
+        ~Texture();
+
+        int width() const { return m_bin_packer.width(); }
+        int height() const { return m_bin_packer.height(); }
+        std::uint32_t tex_name() const { return m_tex_name; }
+        bool retro() const { return m_retro; }
+
+        [[nodiscard]] std::unique_ptr<TexChunk> try_alloc(const Bitmap& bitmap, int padding);
+
+        void insert(const Bitmap& bitmap, int x, int y);
+        Bitmap to_bitmap(const Rect& rect) const;
+    };
+}

data/src/TiledDrawable.cpp

@@ -0,0 +1,150 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Math.hpp>
+#include "GraphicsImpl.hpp"
+#include "TiledDrawable.hpp"
+#include <cmath>
+#include <stdexcept>
+
+Gosu::TiledDrawable::TiledDrawable(const Bitmap& source, const Rect& source_rect, int tile_size,
+                                   unsigned image_flags)
+    : m_width(source_rect.width),
+      m_height(source_rect.height)
+{
+    if (!Rect::covering(source).contains(source_rect) || source_rect.empty()) {
+        throw std::invalid_argument("Invalid TiledDrawable source_rect");
+    }
+    if (tile_size <= 0) {
+        throw std::invalid_argument("tile_size must be greater than 0");
+    }
+
+    // Manually round up during this integer division.
+    const int tiles_x = (source_rect.width + tile_size - 1) / tile_size;
+    const int tiles_y = (source_rect.height + tile_size - 1) / tile_size;
+
+    for (int ty = 0; ty < tiles_y; ++ty) {
+        for (int tx = 0; tx < tiles_x; ++tx) {
+            Rect tile_source_rect { .x = source_rect.x + tx * tile_size,
+                                    .y = source_rect.y + ty * tile_size,
+                                    .width = tile_size,
+                                    .height = tile_size };
+            tile_source_rect.clip_to(source_rect);
+
+            unsigned local_flags = image_flags;
+
+            // The left edge must always be tileable in all columns except for the first.
+            if (tx > 0) {
+                local_flags |= IF_TILEABLE_LEFT;
+            }
+            // The right edge must always be tileable in all columns except for the last.
+            if (tx < tiles_x - 1) {
+                local_flags |= IF_TILEABLE_RIGHT;
+            }
+            // The top edge must always be tileable in all rows except for the first.
+            if (ty > 0) {
+                local_flags |= IF_TILEABLE_TOP;
+            }
+            // The bottom edge must always be tileable in all rows except for the last.
+            if (ty < tiles_y - 1) {
+                local_flags |= IF_TILEABLE_BOTTOM;
+            }
+
+            m_tiles.push_back(Tile {
+                .x = tile_source_rect.x,
+                .y = tile_source_rect.y,
+                .data = create_drawable(source, tile_source_rect, local_flags),
+            });
+        }
+    }
+}
+
+Gosu::TiledDrawable::TiledDrawable(const TiledDrawable& parent, const Rect& rect)
+    : m_width(rect.width),
+      m_height(rect.height)
+{
+    for (const Tile& tile : parent.m_tiles) {
+        // rect is the source area on the parent, tile_rect is this tile's area on the parent.
+        Rect tile_rect { tile.x, tile.y, tile.data->width(), tile.data->height() };
+        // The x/y source position on the tile...
+        int x = 0, y = 0;
+        // ...must be adjusted while clipping.
+        tile_rect.clip_to(rect, &x, &y);
+        // If there is anything left of the tile_rect after clipping, we need to create a tile too.
+        if (!tile_rect.empty()) {
+            m_tiles.push_back(Tile {
+                .x = tile.x - rect.x,
+                .y = tile.y - rect.y,
+                .data = tile.data->subimage(Rect { x, y, tile_rect.width, tile_rect.height }),
+            });
+        }
+    }
+}
+
+void Gosu::TiledDrawable::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
+                                double x3, double y3, Color c3, double x4, double y4, Color c4,
+                                ZPos z, BlendMode mode) const
+{
+    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
+
+    double f_width = m_width, f_height = m_height;
+    for (const Tile& tile : m_tiles) {
+        double rel_x_l = tile.x / f_width;
+        double rel_x_r = (tile.x + tile.data->width()) / f_width;
+        double rel_y_t = tile.y / f_height;
+        double rel_y_b = (tile.y + tile.data->height()) / f_height;
+
+        using std::lerp;
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define LERP2D(what, x_weight, y_weight)                                                           \
+    lerp(lerp(what##1, what##3, y_weight), lerp(what##2, what##4, y_weight), x_weight);
+
+        double x_t_l = LERP2D(x, rel_x_l, rel_y_t);
+        double x_t_r = LERP2D(x, rel_x_r, rel_y_t);
+        double x_b_l = LERP2D(x, rel_x_l, rel_y_b);
+        double x_b_r = LERP2D(x, rel_x_r, rel_y_b);
+
+        double y_t_l = LERP2D(y, rel_x_l, rel_y_t);
+        double y_t_r = LERP2D(y, rel_x_r, rel_y_t);
+        double y_b_l = LERP2D(y, rel_x_l, rel_y_b);
+        double y_b_r = LERP2D(y, rel_x_r, rel_y_b);
+
+        Color c_t_l = LERP2D(c, rel_x_l, rel_y_t);
+        Color c_t_r = LERP2D(c, rel_x_r, rel_y_t);
+        Color c_b_l = LERP2D(c, rel_x_l, rel_y_b);
+        Color c_b_r = LERP2D(c, rel_x_r, rel_y_b);
+
+        tile.data->draw(x_t_l, y_t_l, c_t_l, x_t_r, y_t_r, c_t_r, //
+                        x_b_l, y_b_l, c_b_l, x_b_r, y_b_r, c_b_r, z, mode);
+    }
+}
+
+std::unique_ptr<Gosu::Drawable> Gosu::TiledDrawable::subimage(const Rect& source_rect) const
+{
+    auto tiled_drawable = std::make_unique<TiledDrawable>(*this, source_rect);
+    if (tiled_drawable->m_tiles.size() == 1) {
+        // Optimization: If the tiled subimage only contains a single tile, return that.
+        return std::move(tiled_drawable->m_tiles[0].data);
+    }
+    return tiled_drawable;
+}
+
+Gosu::Bitmap Gosu::TiledDrawable::to_bitmap() const
+{
+    Bitmap bitmap(width(), height());
+    for (const Tile& tile : m_tiles) {
+        bitmap.insert(tile.data->to_bitmap(), tile.x, tile.y);
+    }
+    return bitmap;
+}
+
+void Gosu::TiledDrawable::insert(const Bitmap& bitmap, int x, int y)
+{
+    const Rect target_rect { x, y, bitmap.width(), bitmap.height() };
+    for (const Tile& tile : m_tiles) {
+        Rect tile_rect { tile.x, tile.y, tile.data->width(), tile.data->height() };
+        tile_rect.clip_to(target_rect);
+        if (!tile_rect.empty()) {
+            tile.data->insert(bitmap, x - tile.x, y - tile.y);
+        }
+    }
+}

data/src/TiledDrawable.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Drawable.hpp>
+#include <Gosu/Platform.hpp>
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace Gosu
+{
+    /// When an image file is too large to be represented by a single OpenGL texture, Gosu automatically
+    /// splits it up into a rectangle of tiles instead of throwing an error.
+    class TiledDrawable : public Drawable
+    {
+        int m_width, m_height;
+        struct Tile
+        {
+            int x = 0, y = 0;
+            std::unique_ptr<Drawable> data = nullptr;
+        };
+        std::vector<Tile> m_tiles;
+
+    public:
+        TiledDrawable(const Bitmap& source, const Rect& source_rect, int tile_size,
+                      unsigned image_flags);
+        /// This constructor is used to implement subimage().
+        TiledDrawable(const TiledDrawable& parent, const Rect& rect);
+
+        int width() const override { return m_width; }
+        int height() const override { return m_height; }
+
+        void draw(double x1, double y1, Color c1, //
+                  double x2, double y2, Color c2, //
+                  double x3, double y3, Color c3, //
+                  double x4, double y4, Color c4, //
+                  ZPos z, BlendMode mode) const override;
+
+        const GLTexInfo* gl_tex_info() const override { return nullptr; }
+
+        std::unique_ptr<Drawable> subimage(const Rect& rect) const override;
+
+        Bitmap to_bitmap() const override;
+
+        void insert(const Bitmap& bitmap, int x, int y) override;
+    };
+}

data/src/TimingApple.cpp

@@ -23,7 +23,7 @@ unsigned long Gosu::milliseconds()
     }();
 
     uint64_t runtime = mach_absolute_time() - first_tick;
-    return runtime * info.numer / info.denom / 1000000;
+    return runtime * info.numer / info.denom / 1'000'000;
 }
 
 #endif

data/src/Transform.cpp

@@ -1,73 +1,68 @@
-// Default matrices, adapted from original Transform support
-// contribution by erisdiscord. Thank you!
+// Default matrices, adapted from original Transform support contribution by erisdiscord. Thank you!
 
-#include "GraphicsImpl.hpp"
-#include <Gosu/GraphicsBase.hpp>
 #include <Gosu/Math.hpp>
+#include <Gosu/Transform.hpp>
 #include <cmath>
-using namespace std;
 
-Gosu::Transform Gosu::rotate(double angle, double around_x, double around_y)
+void Gosu::Transform::apply(double& x, double& y) const
 {
-    double c = cos(degrees_to_radians(angle));
-    double s = sin(degrees_to_radians(angle));
-    Transform result = {
-        +c, +s, 0, 0,
-        -s, +c, 0, 0,
-        0,  0,  1, 0,
-        0,  0,  0, 1
-    };
-    if (around_x != 0 || around_y != 0) {
-        result = concat(concat(translate(-around_x, -around_y), result),
-                        translate(around_x, around_y));
+    double in[4] = { x, y, 0, 1 };
+    double out[4] = { 0, 0, 0, 0 };
+    for (int i = 0; i < 4; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            out[i] += in[j] * matrix[j * 4 + i];
+        }
     }
-    return result;
+    x = out[0] / out[3];
+    y = out[1] / out[3];
 }
 
-Gosu::Transform Gosu::translate(double x, double y)
+Gosu::Transform Gosu::Transform::translate(double x, double y)
 {
-    Transform result = {
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 1, 0,
-        x, y, 0, 1
-    };
-    return result;
+    return Transform { 1, 0, 0, 0, //
+                       0, 1, 0, 0, //
+                       0, 0, 1, 0, //
+                       x, y, 0, 1 };
 }
 
-Gosu::Transform Gosu::scale(double factor)
+Gosu::Transform Gosu::Transform::rotate(double angle)
 {
-    Transform result = {
-        factor, 0,      0, 0,
-        0,      factor, 0, 0,
-        0,      0,      1, 0,
-        0,      0,      0, 1
-    };
-    return result;
+    double c = std::cos(degrees_to_radians(angle));
+    double s = std::sin(degrees_to_radians(angle));
+    return Transform { +c, +s, 0, 0, //
+                       -s, +c, 0, 0, //
+                       0,  0,  1, 0, //
+                       0,  0,  0, 1 };
 }
 
-Gosu::Transform Gosu::scale(double scale_x, double scale_y, double around_x, double around_y)
+Gosu::Transform Gosu::Transform::scale(double factor)
 {
-    Transform result = {
-        scale_x, 0,       0, 0,
-        0,       scale_y, 0, 0,
-        0,       0,       1, 0,
-        0,       0,       0, 1
-    };
-    if (around_x != 0 || around_y != 0) {
-        result = concat(concat(translate(-around_x, -around_y), result),
-                        translate(around_x, around_y));
-    }
-    return result;
+    return Transform { factor, 0,      0, 0, //
+                       0,      factor, 0, 0, //
+                       0,      0,      1, 0, //
+                       0,      0,      0, 1 };
+}
+
+Gosu::Transform Gosu::Transform::scale(double scale_x, double scale_y)
+{
+    return Transform { scale_x, 0,       0, 0, //
+                       0,       scale_y, 0, 0, //
+                       0,       0,       1, 0, //
+                       0,       0,       0, 1 };
+}
+
+Gosu::Transform Gosu::Transform::around(double around_x, double around_y) const
+{
+    return translate(-around_x, -around_y) * *this * translate(around_x, around_y);
 }
 
-Gosu::Transform Gosu::concat(const Transform& left, const Transform& right)
+Gosu::Transform Gosu::Transform::operator*(const Transform& rhs) const
 {
-    Transform result;
+    Transform result { 0 };
     for (int i = 0; i < 16; ++i) {
-        result[i] = 0;
+        result.matrix[i] = 0;
         for (int j = 0; j < 4; ++j) {
-            result[i] += left[i / 4 * 4 + j] * right[i % 4 + j * 4];
+            result.matrix[i] += matrix[i / 4 * 4 + j] * rhs.matrix[i % 4 + j * 4];
         }
     }
     return result;