add sgb border support

.gitignore

 compile_commands.json
 bear.cfg
 tmp
+*.sav

Makefile

 PNGA := $(GBDK_HOME)/bin/png2asset
 ROMU := $(GBDK_HOME)/bin/romusage
 GB_EMU := gearboy
+SGB_EMU := sameboy
 
 LCCFLAGS := -Wa-l -Wl-m -Wp-MMD -Wf--opt-code-speed
 LCCFLAGS += -I$(BUILD_DIR)/$(DATA_DIR)
-LCCFLAGS += -Wm"-yn Duality" -Wm-yt0x1B -Wm-yoA -Wm-ya16 -Wm-yc
+LCCFLAGS += -Wm"-yn Duality" -Wm-yt0x1B -Wm-yoA -Wm-ya16 -Wm-yc -Wm-ys
 LCCFLAGS += -autobank -Wb-ext=.rel -Wb-v -Wf-bo255
 
 EMUFLAGS := $(BIN)
 #DEPS=$(OBJS:%.o=%.d)
 #-include $(DEPS)
 
-.PHONY: all run clean compile_commands.json usage
+.PHONY: all run sgb_run clean compile_commands.json usage
 .PRECIOUS: $(BUILD_DIR)/$(DATA_DIR)/%.c $(BUILD_DIR)/$(DATA_DIR)/%.h
 
 all: $(BIN)
 	@echo Emulating $<
 	@$(GB_EMU) $(EMUFLAGS)
 
+sgb_run: $(BIN)
+	@echo Emulating $<
+	@$(SGB_EMU) $(BIN)
+
 $(BUILD_DIR)/$(DATA_DIR)/%.c $(BUILD_DIR)/$(DATA_DIR)/%.h: $(DATA_DIR)/%.png
 	@mkdir -p $(@D)
-	$(if $(findstring _map,$<),           \
-		@echo "Converting map $<" &&  \
-		$(PNGA) $< -o $@ -spr8x8 -map -use_map_attributes -noflip \
-	,$(if $(findstring _fnt,$<), \
-		@echo "Converting font $<" && \
-		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -map -noflip \
-	,$(if $(findstring _spr8,$<), \
-		@echo "Converting 8x8 sprite $<" && \
-		$(PNGA) $< -o $@ -spr8x8 -sw 8 -sh 8 -noflip \
-	,$(if $(findstring _spr16,$<), \
-		@echo "Converting 16x16 sprite $<" && \
-		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -noflip \
-	,                                     \
-		@echo "Converting tile $<" && \
-		$(PNGA) $< -o $@ -spr8x8      \
-	))))
+	$(if $(findstring _map,$<),                                                             \
+		@echo "Converting map $<" &&                                                    \
+		$(PNGA) $< -o $@ -spr8x8 -map -use_map_attributes -noflip                       \
+	,$(if $(findstring _fnt,$<),                                                            \
+		@echo "Converting font $<" &&                                                   \
+		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -map -noflip                             \
+	,$(if $(findstring _spr8,$<),                                                           \
+		@echo "Converting 8x8 sprite $<" &&                                             \
+		$(PNGA) $< -o $@ -spr8x8 -sw 8 -sh 8 -noflip                                    \
+	,$(if $(findstring _spr16,$<),                                                          \
+		@echo "Converting 16x16 sprite $<" &&                                           \
+		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -noflip                                  \
+	,$(if $(findstring _sgb,$<),                                                            \
+		@echo "Converting sgb border $<" &&                                             \
+		$(PNGA) $< -o $@ -map -bpp 4 -max_palettes 4 -pack_mode sgb -use_map_attributes \
+	,                                                                                       \
+		@echo "Converting tile $<" &&                                                   \
+		$(PNGA) $< -o $@ -spr8x8                                                        \
+	)))))
 
 $(BUILD_DIR)/%.o: %.c $(SPRITES)
 	@mkdir -p $(@D)

README.md

 A copy of the license can be found in `COPYING`.
 
 It uses the [GBDK-2020](https://gbdk.org) libraries and is based on their example code.
+The files `sgb_border.c` and `sgb_border.h` are copied directly from their `sgb_border` example.
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by

src/main.c

 #include "input.h"
 #include "game.h"
 #include "score.h"
+#include "sgb_border.h"
+#include "border_sgb.h"
 
 static void highscore(uint8_t is_black) NONBANKED {
     HIDE_WIN;
     return name;
 }
 
+static void sgb_init(void) NONBANKED {
+    // Wait 4 frames
+    // For SGB on PAL SNES this delay is required on startup, otherwise borders don't show up
+    for (uint8_t i = 0; i < 4; i++) {
+        vsync();
+    }
+
+    DISPLAY_ON;
+
+    SWITCH_ROM(BANK(border_sgb));
+
+    set_sgb_border((const uint8_t *)border_sgb_tiles, sizeof(border_sgb_tiles),
+                   (const uint8_t *)border_sgb_map, sizeof(border_sgb_map),
+                   (const uint8_t *)border_sgb_palettes, sizeof(border_sgb_palettes));
+
+    DISPLAY_OFF;
+
+}
+
 void main(void) NONBANKED {
+    // load sgb border
+    sgb_init();
+
     // "cheat" and enable double-speed CPU mode on GBC
     if (_cpu == CGB_TYPE) {
         cpu_fast();

src/sgb_border.c

+#include "sgb_border.h"
+
+#include <gb/gb.h>
+#include <stdint.h>
+#include <gb/sgb.h>
+#include <string.h>
+
+#define SGB_CHR_BLOCK0 0
+#define SGB_CHR_BLOCK1 1
+
+#define SGB_SCR_FREEZE 1
+#define SGB_SCR_UNFREEZE 0
+
+#define SGB_TRANSFER(A,B) map_buf[0]=(A),map_buf[1]=(B),sgb_transfer(map_buf)
+
+// The display must be turned on before calling this function
+// (with @ref DISPLAY_ON).
+void set_sgb_border(const uint8_t *tiledata, size_t tiledata_size,
+                    const uint8_t *tilemap, size_t tilemap_size,
+                    const uint8_t *palette, size_t palette_size) NONBANKED {
+    if (!sgb_check()) {
+        return;
+    }
+
+    unsigned char map_buf[20];
+    memset(map_buf, 0, sizeof(map_buf));
+
+    SGB_TRANSFER((SGB_MASK_EN << 3) | 1, SGB_SCR_FREEZE);
+
+    BGP_REG = OBP0_REG = OBP1_REG = 0xE4U;
+    SCX_REG = SCY_REG = 0U;
+
+    uint8_t tmp_lcdc = LCDC_REG;
+
+    HIDE_SPRITES, HIDE_WIN, SHOW_BKG;
+    DISPLAY_ON;
+    // prepare tilemap for SGB_BORDER_CHR_TRN (should display all 256 tiles)
+    uint8_t i = 0U;
+    for (uint8_t y = 0; y != 14U; ++y) {
+        uint8_t * dout = map_buf;
+        for (uint8_t x = 0U; x != 20U; ++x) {
+            *dout++ = i++;
+        }
+        set_bkg_tiles(0, y, 20, 1, map_buf);
+    }
+    memset(map_buf, 0, sizeof(map_buf));
+
+    // transfer tile data
+    uint8_t ntiles = (tiledata_size > 256 * 32) ? 0 : tiledata_size >> 5;
+    if ((!ntiles) || (ntiles > 128U)) {
+        set_bkg_data(0, 0, tiledata);
+        SGB_TRANSFER((SGB_CHR_TRN << 3) | 1, SGB_CHR_BLOCK0);
+        if (ntiles) ntiles -= 128U;
+        tiledata += (128 * 32);
+        set_bkg_data(0, ntiles << 1, tiledata);
+        SGB_TRANSFER((SGB_CHR_TRN << 3) | 1, SGB_CHR_BLOCK1);
+    } else {
+        set_bkg_data(0, ntiles << 1, tiledata);
+        SGB_TRANSFER((SGB_CHR_TRN << 3) | 1, SGB_CHR_BLOCK0);
+    }
+
+    // transfer map and palettes
+    set_bkg_data(0, (uint8_t)(tilemap_size >> 4), tilemap);
+    set_bkg_data(128, (uint8_t)(palette_size >> 4), palette);
+    SGB_TRANSFER((SGB_PCT_TRN << 3) | 1, 0);
+
+    LCDC_REG = tmp_lcdc;
+
+    // clear SCREEN
+    fill_bkg_rect(0, 0, 20, 18, 0);
+
+    SGB_TRANSFER((SGB_MASK_EN << 3) | 1, SGB_SCR_UNFREEZE);
+}

src/sgb_border.h

+#ifndef __SGB_BORDER_H_INCLUDE
+#define __SGB_BORDER_H_INCLUDE
+
+#include <gb/gb.h>
+#include <stdint.h>
+
+#define SNES_RGB(R,G,B) (uint16_t)((B) << 10 | (G) << 5 | (R))
+
+/** sets SGB border
+
+    The display must be turned on before calling this function
+    (with @ref DISPLAY_ON).
+
+    When using the SGB with a PAL SNES, a delay should be added
+    just after program startup such as:
+
+    \code{.c}
+    // Wait 4 frames
+    // For PAL SNES this delay is required on startup
+    for (uint8_t i = 4; i != 0; i--) vsync();
+    \endcode
+*/
+void set_sgb_border(const unsigned char * tiledata, size_t tiledata_size,
+                    const unsigned char * tilemap, size_t tilemap_size,
+                    const unsigned char * palette, size_t palette_size);
+
+#endif