Format and document utility files (#246)

* Format and document utility files

* Add Doxyfile

* small updates for cleanup

* Final touches for util docs

* Replace `_` with `s_` for static functions

* update for clang-format changes

* Update include/audio_utils.h

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

* Apply suggestions from code review

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

* Update include/audio_utils.h

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

* Update include/graphic_utils.h

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

* Make clang-format happy :)

* Update gitignore for doxygen

* restor graphic_utils.c to main

* update graphics utils

* tmp

* tmp

* get it to compile

* fix some bad merge mistakes

* Fix clang format

* Apply suggestions from code review

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

* make clang-format happy

---------

Co-authored-by: MeirGavish <meir.gavish@gmail.com>

source/affine_background.c

@@ -1,57 +1,28 @@
 #include "affine_background.h"
+
 #include "affine_background_gfx.h"
 #include "affine_main_menu_background_gfx.h"
-
 #include "graphic_utils.h"
 
 #define ANIMATION_SPEED_DIVISOR 16
 
-BG_AFFINE bgaff_arr[SCREEN_HEIGHT + 1];
+// Prepare screen during VBLANK
+// Pre-computes the affine matrices values for each scanline and stores in bgaff_arr. This is to be
+// done in VBLANK so the HBLANK code can just fetch the values quickly.
+static IWRAM_CODE void s_affine_background_prep_bgaff_arr();
 
-AFF_SRC_EX asx = {0};
-
-enum AffineBackgroundID background = AFFINE_BG_MAIN_MENU;
-
-static uint timer = 0;
+static BG_AFFINE _bgaff_arr[SCREEN_HEIGHT + 1];
+static AFF_SRC_EX _asx = {0};
+static enum AffineBackgroundID _background = AFFINE_BG_MAIN_MENU;
+static uint _timer = 0;
 
 void affine_background_init()
-{   
+{
     affine_background_update();
 
     REG_BG_AFFINE[AFFINE_BG_IDX] = bg_aff_default;
 }
 
-// Pre-computes the affine matrices values for each scanline 
-// and stores in bgaff_arr. 
-// This is to be done in VBLANK so the HBLANK code 
-// can just fetch the values quickly.
-IWRAM_CODE void affine_background_prep_bgaff_arr()
-{
-    for (u16 vcount = 0; vcount < SCREEN_HEIGHT; vcount++)
-    {
-        const s32 timer_s32 = timer << 8;
-        const s32 vcount_s32 = vcount << 8;
-        const s16 vcount_s16 = vcount;
-        const s32 vcount_sine = lu_sin(vcount_s32 + timer_s32 / ANIMATION_SPEED_DIVISOR); // dividing the timer by 16 to make the animation slower
-        
-        asx.scr_x = (SCREEN_WIDTH / 2); // 128 on x and y is an offset used to center the rotation
-        asx.scr_y = vcount_s16 - (SCREEN_HEIGHT / 2); // scr_y must equal vcount otherwise the background will have no vertical difference
-        asx.tex_x = (1000 * 1000) + (vcount_sine);
-        asx.tex_y = (1000 * 1000);
-        asx.sx = 128;
-        asx.sy = 128;
-        asx.alpha = vcount_sine + (timer_s32 / ANIMATION_SPEED_DIVISOR);
-
-        bg_rotscale_ex(&bgaff_arr[vcount], &asx);
-    }
-
-    /* HBLANK occurs after the scanline so REG_VCOUNT represents the 
-     * the scanline that just passed, so when it's SCREEN_HEIGHT we will
-     * actually be updating the first line
-     */
-    bgaff_arr[SCREEN_HEIGHT] = bgaff_arr[0];
-}
-
 IWRAM_CODE void affine_background_hblank()
 {
     vu16 vcount = REG_VCOUNT;
@@ -62,69 +33,110 @@ IWRAM_CODE void affine_background_hblank()
     }
 
     // See comment in affine_background_prep_bgaff_arr()
-    REG_BG_AFFINE[AFFINE_BG_IDX] = bgaff_arr[vcount + 1];
+    REG_BG_AFFINE[AFFINE_BG_IDX] = _bgaff_arr[vcount + 1];
 }
 
 void affine_background_update()
 {
     if (REG_IE & IRQ_HBLANK) // High quality mode with HBLANK interrupt
     {
-        affine_background_prep_bgaff_arr();
+        s_affine_background_prep_bgaff_arr();
     }
     else // Low quality mode without HBLANK interrupt
     {
-        asx.scr_x = 0;
-        asx.scr_y = 0;
-        asx.tex_x += 5;
-        asx.tex_y += 12;
-        asx.sx = ((lu_sin(timer * 100)) >> 8) + 256; // Scale the sine value to fit in a s16
-        asx.sy = ((lu_sin(timer * 100 + 0x4000)) >> 8) + 256; // Scale the sine value to fit in a s16
-        asx.alpha = 0;
+        _asx.scr_x = 0;
+        _asx.scr_y = 0;
+        _asx.tex_x += 5;
+        _asx.tex_y += 12;
+        // Scale the sine value to fit in a s16
+        _asx.sx = ((lu_sin(_timer * 100)) >> 8) + 256;
+        // Scale the sine value to fit in a s16
+        _asx.sy = ((lu_sin(_timer * 100 + 0x4000)) >> 8) + 256;
+        _asx.alpha = 0;
 
-        bg_rotscale_ex(&bgaff_arr[0], &asx);
-        REG_BG_AFFINE[AFFINE_BG_IDX] = bgaff_arr[0];
+        bg_rotscale_ex(&_bgaff_arr[0], &_asx);
+        REG_BG_AFFINE[AFFINE_BG_IDX] = _bgaff_arr[0];
     }
 
-    timer++;
+    _timer++;
 }
 
 void affine_background_set_color(COLOR color)
 {
-    affine_background_change_background(background); // Reload the palette to reset any previous color scaling
+    // Reload the palette to reset any previous color scaling
+    affine_background_change_background(_background);
     for (int i = 0; i < AFFINE_BG_PAL_LEN; i++)
     {
         clr_rgbscale(&pal_bg_mem[AFFINE_BG_PB] + i, &pal_bg_mem[AFFINE_BG_PB] + i, 1, color);
     }
 }
 
-void affine_background_load_palette(const u16 *src)
+void affine_background_load_palette(const u16* src)
 {
     memcpy16(&pal_bg_mem[AFFINE_BG_PB], src, AFFINE_BG_PAL_LEN);
 }
 
 void affine_background_change_background(enum AffineBackgroundID new_bg)
 {
-    background = new_bg;
+    _background = new_bg;
 
-    switch (background)
+    switch (_background)
     {
-    case AFFINE_BG_MAIN_MENU:
-        REG_BG2CNT &= ~BG_AFF_32x32;
-        REG_BG2CNT |= BG_AFF_16x16;
-        REG_IE |= IRQ_HBLANK; // Enable HBLANK
+        case AFFINE_BG_MAIN_MENU:
+            REG_BG2CNT &= ~BG_AFF_32x32;
+            REG_BG2CNT |= BG_AFF_16x16;
+            REG_IE |= IRQ_HBLANK; // Enable HBLANK
 
-        memcpy32_tile8_with_palette_offset((u32*)&tile8_mem[AFFINE_BG_CBB], (const u32*)affine_main_menu_background_gfxTiles, affine_main_menu_background_gfxTilesLen/4, AFFINE_BG_PB);
-        GRIT_CPY(&se_mem[AFFINE_BG_SBB], affine_main_menu_background_gfxMap);
-        affine_background_load_palette(affine_main_menu_background_gfxPal);
-        break;
-    case AFFINE_BG_GAME:
-        REG_BG2CNT &= ~BG_AFF_16x16;
-        REG_BG2CNT |= BG_AFF_32x32;
-        REG_IE &= ~IRQ_HBLANK; // Disable HBLANK
+            memcpy32_tile8_with_palette_offset(
+                (u32*)&tile8_mem[AFFINE_BG_CBB],
+                (const u32*)affine_main_menu_background_gfxTiles,
+                affine_main_menu_background_gfxTilesLen / 4,
+                AFFINE_BG_PB
+            );
+            GRIT_CPY(&se_mem[AFFINE_BG_SBB], affine_main_menu_background_gfxMap);
+            affine_background_load_palette(affine_main_menu_background_gfxPal);
+            break;
+        case AFFINE_BG_GAME:
+            REG_BG2CNT &= ~BG_AFF_16x16;
+            REG_BG2CNT |= BG_AFF_32x32;
+            REG_IE &= ~IRQ_HBLANK; // Disable HBLANK
 
-        memcpy32_tile8_with_palette_offset((u32*)&tile8_mem[AFFINE_BG_CBB], (const u32*)affine_background_gfxTiles, affine_background_gfxTilesLen/4, AFFINE_BG_PB);
-        GRIT_CPY(&se_mem[AFFINE_BG_SBB], affine_background_gfxMap);
-        affine_background_load_palette(affine_background_gfxPal);
-        break;
+            memcpy32_tile8_with_palette_offset(
+                (u32*)&tile8_mem[AFFINE_BG_CBB],
+                (const u32*)affine_background_gfxTiles,
+                affine_background_gfxTilesLen / 4,
+                AFFINE_BG_PB
+            );
+            GRIT_CPY(&se_mem[AFFINE_BG_SBB], affine_background_gfxMap);
+            affine_background_load_palette(affine_background_gfxPal);
+            break;
     }
-}
+}
+
+static IWRAM_CODE void s_affine_background_prep_bgaff_arr()
+{
+    for (u16 vcount = 0; vcount < SCREEN_HEIGHT; vcount++)
+    {
+        const s32 timer_s32 = _timer << 8;
+        const s32 vcount_s32 = vcount << 8;
+        const s16 vcount_s16 = vcount;
+        const s32 vcount_sine = lu_sin(vcount_s32 + timer_s32 / ANIMATION_SPEED_DIVISOR);
+
+        _asx.scr_x = (SCREEN_WIDTH / 2);
+        // scr_y must equal vcount otherwise the background will have no vertical difference
+        _asx.scr_y = vcount_s16 - (SCREEN_HEIGHT / 2);
+        _asx.tex_x = (1000 * 1000) + (vcount_sine);
+        _asx.tex_y = (1000 * 1000);
+        _asx.sx = 128;
+        _asx.sy = 128;
+        _asx.alpha = vcount_sine + (timer_s32 / ANIMATION_SPEED_DIVISOR);
+
+        bg_rotscale_ex(&_bgaff_arr[vcount], &_asx);
+    }
+
+    /* HBLANK occurs after the scanline so REG_VCOUNT represents the
+     * the scanline that just passed, so when it's SCREEN_HEIGHT we will
+     * actually be updating the first line
+     */
+    _bgaff_arr[SCREEN_HEIGHT] = _bgaff_arr[0];
+}

source/audio_utils.c

@@ -1,8 +1,15 @@
-#include "audio_utils.h"
-#include <maxmod.h>
-
-void play_sfx(mm_word id, mm_word rate)
-{
-    mm_sound_effect sfx = { {id}, rate, 0, SFX_DEFAULT_VOLUME, SFX_DEFAULT_PAN, };
-    mmEffectEx(&sfx);
-}
+#include "audio_utils.h"
+
+#include <maxmod.h>
+
+void play_sfx(mm_word id, mm_word rate)
+{
+    mm_sound_effect sfx = {
+        {id},
+        rate,
+        0,
+        SFX_DEFAULT_VOLUME,
+        SFX_DEFAULT_PAN,
+    };
+    mmEffectEx(&sfx);
+}

source/graphic_utils.c

@@ -1,16 +1,30 @@
-#include <tonc_core.h>
-#include <tonc_tte.h>
-#include <tonc_math.h>
+#include "graphic_utils.h"
 
 #include "util.h"
-#include "graphic_utils.h"
-#include <string.h>
 
-const Rect FULL_SCREENBLOCK_RECT = { 0, 0, SE_ROW_LEN - 1, SE_COL_LEN - 1};
+#include <string.h>
+#include <tonc_core.h>
+#include <tonc_math.h>
+#include <tonc_tte.h>
+
+const Rect FULL_SCREENBLOCK_RECT = {0, 0, SE_ROW_LEN - 1, SE_COL_LEN - 1};
+
+static void clip_se_rect_to_screenblock(Rect* rect);
+static void bg_se_copy_or_move_rect_1_tile_vert(
+    u16 bg_sbb,
+    Rect se_rect,
+    enum ScreenVertDir direction,
+    bool move
+);
+static void main_bg_se_copy_or_move_rect_1_tile_vert(
+    Rect se_rect,
+    enum ScreenVertDir direction,
+    bool move
+);
 
 // Clips a rect of screenblock entries to a specified rect
 // The bounding rect is not required to be within screenblock boundaries
-static void clip_se_rect_to_bounding_rect(Rect* rect, const Rect* bounding_rect)
+static inline void clip_se_rect_to_bounding_rect(Rect* rect, const Rect* bounding_rect)
 {
     rect->right = min(rect->right, bounding_rect->right);
     rect->bottom = min(rect->bottom, bounding_rect->bottom);
@@ -25,14 +39,12 @@ static void clip_se_rect_to_screenblock(Rect* rect)
     clip_se_rect_to_bounding_rect(rect, &FULL_SCREENBLOCK_RECT);
 }
 
-SE main_bg_se_get_se(BG_POINT pos)
-{
-    return se_mat[MAIN_BG_SBB][pos.y][pos.x];
-}
-
-// Clips a rect of screenblock entries to be within one step of 
+// Clips a rect of screenblock entries to be within one step of
 // screenblock boundaries vertically depending on direction.
-static void clip_se_rect_within_step_of_full_screen_vert(Rect* se_rect, enum ScreenVertDir direction)
+static inline void clip_se_rect_within_step_of_full_screen_vert(
+    Rect* se_rect,
+    enum ScreenVertDir direction
+)
 {
     Rect bounding_rect = FULL_SCREENBLOCK_RECT;
     if (direction == SCREEN_UP)
@@ -43,28 +55,19 @@ static void clip_se_rect_within_step_of_full_screen_vert(Rect* se_rect, enum Scr
     {
         bounding_rect.bottom -= 1;
     }
-    
+
     clip_se_rect_to_bounding_rect(se_rect, &bounding_rect);
 }
 
-void main_bg_se_clear_rect(Rect se_rect)
-{
-    if (se_rect.left > se_rect.right)
-        return;
-    // Clip to avoid screenblock overflow
-    clip_se_rect_to_screenblock(&se_rect);
-
-    for (int y = se_rect.top; y < se_rect.bottom; y++)
-    {
-        memset16(&(se_mat[MAIN_BG_SBB][y][se_rect.left]), 0x0000, rect_width(&se_rect));
-    }
-}
-
 // Internal static function to merge implementation of move/copy functions.
-static void bg_se_copy_or_move_rect_1_tile_vert(u16 bg_sbb, Rect se_rect, enum ScreenVertDir direction, bool move)
+static void bg_se_copy_or_move_rect_1_tile_vert(
+    u16 bg_sbb,
+    Rect se_rect,
+    enum ScreenVertDir direction,
+    bool move
+)
 {
-     if (se_rect.left > se_rect.right
-        || (direction != SCREEN_UP && direction != SCREEN_DOWN))
+    if (se_rect.left > se_rect.right || (direction != SCREEN_UP && direction != SCREEN_DOWN))
     {
         return;
     }
@@ -77,9 +80,11 @@ static void bg_se_copy_or_move_rect_1_tile_vert(u16 bg_sbb, Rect se_rect, enum S
 
     for (int y = start; y != end - direction; y -= direction)
     {
-        memcpy16(&(se_mat[bg_sbb][y + direction][se_rect.left]),
-                 &se_mat[bg_sbb][y][se_rect.left],
-                 rect_width(&se_rect));
+        memcpy16(
+            &(se_mat[bg_sbb][y + direction][se_rect.left]),
+            &se_mat[bg_sbb][y][se_rect.left],
+            rect_width(&se_rect)
+        );
     }
 
     if (move)
@@ -88,9 +93,13 @@ static void bg_se_copy_or_move_rect_1_tile_vert(u16 bg_sbb, Rect se_rect, enum S
     }
 }
 
-static void main_bg_se_copy_or_move_rect_1_tile_vert(Rect se_rect, enum ScreenVertDir direction, bool move)
+static void main_bg_se_copy_or_move_rect_1_tile_vert(
+    Rect se_rect,
+    enum ScreenVertDir direction,
+    bool move
+)
 {
-   bg_se_copy_or_move_rect_1_tile_vert(MAIN_BG_SBB, se_rect, direction, move);
+    bg_se_copy_or_move_rect_1_tile_vert(MAIN_BG_SBB, se_rect, direction, move);
 }
 
 void bg_se_copy_rect_1_tile_vert(u16 bg_sbb, Rect se_rect, enum ScreenVertDir direction)
@@ -128,22 +137,18 @@ void main_bg_se_copy_rect(Rect se_rect, BG_POINT dest_pos)
     // Copy the rect to the tile map
     for (int sy = 0; sy < height; sy++)
     {
-        memcpy16(&tile_map[sy][0],
-                 &se_mat[MAIN_BG_SBB][se_rect.top + sy][se_rect.left], 
-                 width);
+        memcpy16(&tile_map[sy][0], &se_mat[MAIN_BG_SBB][se_rect.top + sy][se_rect.left], width);
     }
-    
+
     // TODO: Avoid overflow
     // Copy the tilemap to the new rect position
     for (int sy = 0; sy < height; sy++)
     {
-        memcpy16(&se_mat[MAIN_BG_SBB][dest_pos.y + sy][dest_pos.x],
-                 &tile_map[sy][0],
-                 width);
+        memcpy16(&se_mat[MAIN_BG_SBB][dest_pos.y + sy][dest_pos.x], &tile_map[sy][0], width);
     }
 }
 
-void main_bg_se_fill_rect_with_se(SE se, Rect se_rect)
+static inline void main_bg_se_fill_rect_with_se(SE se, Rect se_rect)
 {
     if (se_rect.left > se_rect.right || se_rect.top > se_rect.bottom)
         return;
@@ -161,7 +166,12 @@ void main_bg_se_fill_rect_with_se(SE se, Rect se_rect)
 }
 
 // Helper: Copy the corners of a 3x3 tile block
-static void main_bg_se_expand_3x3_copy_corners(const Rect* se_dest_rect, const BG_POINT* src_top_left_pnt, int dest_rect_width, int dest_rect_height)
+static inline void main_bg_se_expand_3x3_copy_corners(
+    const Rect* se_dest_rect,
+    const BG_POINT* src_top_left_pnt,
+    int dest_rect_width,
+    int dest_rect_height
+)
 {
     SE top_left_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y][src_top_left_pnt->x];
     se_mat[MAIN_BG_SBB][se_dest_rect->top][se_dest_rect->left] = top_left_se;
@@ -170,33 +180,53 @@ static void main_bg_se_expand_3x3_copy_corners(const Rect* se_dest_rect, const B
     se_mat[MAIN_BG_SBB][se_dest_rect->top][se_dest_rect->left + dest_rect_width - 1] = top_right_se;
 
     SE bottom_left_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y + 2][src_top_left_pnt->x];
-    se_mat[MAIN_BG_SBB][se_dest_rect->top + dest_rect_height - 1][se_dest_rect->left] = bottom_left_se;
+    se_mat[MAIN_BG_SBB][se_dest_rect->top + dest_rect_height - 1][se_dest_rect->left] =
+        bottom_left_se;
 
     SE bottom_right_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y + 2][src_top_left_pnt->x + 2];
-    se_mat[MAIN_BG_SBB][se_dest_rect->top + dest_rect_height - 1][se_dest_rect->left + dest_rect_width - 1] = bottom_right_se;
+    se_mat[MAIN_BG_SBB][se_dest_rect->top + dest_rect_height - 1]
+          [se_dest_rect->left + dest_rect_width - 1] = bottom_right_se;
 }
 
 // Helper: Copy the top and bottom sides of a 3x3 tile block
-static void main_bg_se_expand_3x3_copy_top_bottom(const Rect* se_dest_rect, const BG_POINT* src_top_left_pnt, int dest_rect_width)
+static inline void main_bg_se_expand_3x3_copy_top_bottom(
+    const Rect* se_dest_rect,
+    const BG_POINT* src_top_left_pnt,
+    int dest_rect_width
+)
 {
     if (dest_rect_width > 2)
     {
         SE top_middle_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y][src_top_left_pnt->x + 1];
         SE bottom_middle_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y + 2][src_top_left_pnt->x + 1];
-        memset16(&se_mat[MAIN_BG_SBB][se_dest_rect->top][se_dest_rect->left + 1], top_middle_se, dest_rect_width - 2);
-        memset16(&se_mat[MAIN_BG_SBB][se_dest_rect->bottom][se_dest_rect->left + 1], bottom_middle_se, dest_rect_width - 2);
+        memset16(
+            &se_mat[MAIN_BG_SBB][se_dest_rect->top][se_dest_rect->left + 1],
+            top_middle_se,
+            dest_rect_width - 2
+        );
+        memset16(
+            &se_mat[MAIN_BG_SBB][se_dest_rect->bottom][se_dest_rect->left + 1],
+            bottom_middle_se,
+            dest_rect_width - 2
+        );
     }
 }
 
 // Helper: Copy the left and right sides of a 3x3 tile block
-static void main_bg_se_expand_3x3_copy_left_right(const Rect* se_dest_rect, const BG_POINT* src_top_left_pnt, int dest_rect_width, int dest_rect_height)
+static inline void main_bg_se_expand_3x3_copy_left_right(
+    const Rect* se_dest_rect,
+    const BG_POINT* src_top_left_pnt,
+    int dest_rect_width,
+    int dest_rect_height
+)
 {
     SE middle_left_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y + 1][src_top_left_pnt->x];
     SE middle_right_se = se_mat[MAIN_BG_SBB][src_top_left_pnt->y + 1][src_top_left_pnt->x + 2];
-    for (int y = 1;  y < dest_rect_height - 1; y++)
+    for (int y = 1; y < dest_rect_height - 1; y++)
     {
         se_mat[MAIN_BG_SBB][se_dest_rect->top + y][se_dest_rect->left] = middle_left_se;
-        se_mat[MAIN_BG_SBB][se_dest_rect->top + y][se_dest_rect->left + dest_rect_width - 1] = middle_right_se;
+        se_mat[MAIN_BG_SBB][se_dest_rect->top + y][se_dest_rect->left + dest_rect_width - 1] =
+            middle_right_se;
     }
 }
 
@@ -214,19 +244,34 @@ void main_bg_se_copy_expand_3x3_rect(Rect se_dest_rect, BG_POINT src_top_left_pn
     }
 
     // Copy the corners
-    main_bg_se_expand_3x3_copy_corners(&se_dest_rect, &src_top_left_pnt, dest_rect_width, dest_rect_height);
+    main_bg_se_expand_3x3_copy_corners(
+        &se_dest_rect,
+        &src_top_left_pnt,
+        dest_rect_width,
+        dest_rect_height
+    );
 
     // Copy top and bottom sides
     main_bg_se_expand_3x3_copy_top_bottom(&se_dest_rect, &src_top_left_pnt, dest_rect_width);
 
     // Copy left and right sides
-    main_bg_se_expand_3x3_copy_left_right(&se_dest_rect, &src_top_left_pnt, dest_rect_width, dest_rect_height);
+    main_bg_se_expand_3x3_copy_left_right(
+        &se_dest_rect,
+        &src_top_left_pnt,
+        dest_rect_width,
+        dest_rect_height
+    );
 
     // Fill the center if needed
     if (dest_rect_width > 2 && dest_rect_height > 2)
     {
         SE middle_fill_se = se_mat[MAIN_BG_SBB][src_top_left_pnt.y + 1][src_top_left_pnt.x + 1];
-        Rect dest_inner_fill_rect = {se_dest_rect.left + 1, se_dest_rect.top + 1, se_dest_rect.right - 1, se_dest_rect.bottom - 1};
+        Rect dest_inner_fill_rect = {
+            se_dest_rect.left + 1,
+            se_dest_rect.top + 1,
+            se_dest_rect.right - 1,
+            se_dest_rect.bottom - 1
+        };
         main_bg_se_fill_rect_with_se(middle_fill_se, dest_inner_fill_rect);
     }
 }
@@ -236,7 +281,11 @@ void tte_erase_rect_wrapper(Rect rect)
     tte_erase_rect(rect.left, rect.top, rect.right, rect.bottom);
 }
 
-void update_text_rect_to_right_align_str(Rect* rect, const char* str, enum OverflowDir overflow_direction)
+void update_text_rect_to_right_align_str(
+    Rect* rect,
+    const char* str,
+    enum OverflowDir overflow_direction
+)
 {
     // TODO: Allow passing string length to avoid calling strlen()?
     int str_len = strlen(str);
@@ -249,7 +298,7 @@ void update_text_rect_to_right_align_str(Rect* rect, const char* str, enum Overf
         int num_fitting_chars = rect_width(rect) / TTE_CHAR_SIZE;
         if (str_len < num_fitting_chars)
             rect->left += (num_fitting_chars - str_len) * TTE_CHAR_SIZE;
-        //else nothing is to be updated, entire rect is filled and may overflow
+        // else nothing is to be updated, entire rect is filled and may overflow
     }
 }
 
@@ -283,7 +332,8 @@ void memcpy16_tile8_with_palette_offset(u16* dst, const u16* src, uint hwcount,
 
 void memcpy32_tile8_with_palette_offset(u32* dst, const u32* src, uint wcount, u8 palette_offset)
 {
-    const u32 offset = (palette_offset << 24) | (palette_offset << 16) | (palette_offset << 8) | palette_offset;
+    const u32 offset =
+        (palette_offset << 24) | (palette_offset << 16) | (palette_offset << 8) | palette_offset;
     for (int i = 0; i < wcount; i++)
     {
         // Copying u8 data 4 times across u32 data
@@ -319,4 +369,17 @@ void toggle_windows(bool win0, bool win1)
     {
         REG_BLDCNT = 0;
     }
-}
+}
+
+void main_bg_se_clear_rect(Rect se_rect)
+{
+    if (se_rect.left > se_rect.right)
+        return;
+    // Clip to avoid screenblock overflow
+    clip_se_rect_to_screenblock(&se_rect);
+
+    for (int y = se_rect.top; y < se_rect.bottom; y++)
+    {
+        memset16(&(se_mat[MAIN_BG_SBB][y][se_rect.left]), 0x0000, rect_width(&se_rect));
+    }
+}

source/util.c

@@ -1,7 +1,8 @@
 #include "util.h"
+
 #include <limits.h>
-#include <stdio.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 int int_arr_max(int int_arr[], int size)
 {
@@ -17,7 +18,11 @@ int int_arr_max(int int_arr[], int size)
     return max;
 }
 
-void truncate_uint_to_suffixed_str(uint32_t num, int num_req_chars, char out_str_buff[UINT_MAX_DIGITS + 1])
+void truncate_uint_to_suffixed_str(
+    uint32_t num,
+    int num_req_chars,
+    char out_str_buff[UINT_MAX_DIGITS + 1]
+)
 {
     bool inevitable_overflow = num_req_chars < SUFFIXED_NUM_MIN_REQ_CHARS;
     if (inevitable_overflow)
@@ -28,7 +33,7 @@ void truncate_uint_to_suffixed_str(uint32_t num, int num_req_chars, char out_str
     int num_digits = u32_get_digits(num);
     int overflow_size = num_digits - num_req_chars;
     char* suffix = "";
-    
+
     /* If there is overflow, divide by the next suffixed power of 10
      * to truncate the number back within num_req_chars.
      * UINT32_MAX is in the billions so no need to check larger numbers
@@ -44,9 +49,8 @@ void truncate_uint_to_suffixed_str(uint32_t num, int num_req_chars, char out_str
         num /= ONE_M;
         suffix = "M";
     }
-    else if (overflow_size > 0 
-            || (inevitable_overflow && num_digits == SUFFIXED_NUM_MIN_REQ_CHARS)) 
-            // Special case - alleviate inevitable overflow for 1000s and truncate them to "1K"s
+    else if (overflow_size > 0 || (inevitable_overflow && num_digits == SUFFIXED_NUM_MIN_REQ_CHARS))
+    // Special case - alleviate inevitable overflow for 1000s and truncate them to "1K"s
     {
         num /= ONE_K;
         suffix = "K";
@@ -61,7 +65,7 @@ uint32_t u32_protected_add(uint32_t a, uint32_t b)
 {
     return (a > (UINT32_MAX - b)) ? UINT32_MAX : (a + b);
 }
-    
+
 uint16_t u16_protected_add(uint16_t a, uint16_t b)
 {
     return (a > (UINT16_MAX - b)) ? UINT16_MAX : (a + b);
@@ -75,5 +79,4 @@ uint32_t u32_protected_mult(uint32_t a, uint32_t b)
 uint16_t u16_protected_mult(uint16_t a, uint16_t b)
 {
     return (a == 0 || b == 0) ? 0 : (a > (UINT16_MAX / b) ? UINT16_MAX : a * b);
-
 }

source/version.c

@@ -6,5 +6,4 @@
 #define GIT_DIRTY "-dirty"
 #endif
 
-__attribute__((section(".version"), used))
-const char balatro_version[] = "GBALATRO_VERSION:" GIT_HASH GIT_DIRTY;
+__attribute__((section(".version"), used)) const char balatro_version[] = "GBALATRO_VERSION:" GIT_HASH GIT_DIRTY;