mirror of
https://github.com/marian-m12l/game-and-watch-zelda3.git
synced 2025-12-17 07:16:05 +01:00
699 lines
25 KiB
C
699 lines
25 KiB
C
#include "common.h"
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include "main.h"
|
|
#include "buttons.h"
|
|
#include "lcd.h"
|
|
#include "gw_linker.h"
|
|
#include "font_basic.h"
|
|
|
|
#if ENABLE_SCREENSHOT
|
|
uint16_t framebuffer_capture[GW_LCD_WIDTH * GW_LCD_HEIGHT] __attribute__((section (".fbflash"))) __attribute__((aligned(4096)));
|
|
#endif
|
|
|
|
const uint8_t backlightLevels[] = {128, 130, 133, 139, 149, 162, 178, 198, 222, 255};
|
|
|
|
|
|
__attribute__((section (".configflash"))) __attribute__((aligned(4096))) persistent_config_t persistent_config_flash;
|
|
persistent_config_t persistent_config_ram;
|
|
|
|
void settings_init()
|
|
{
|
|
memcpy(&persistent_config_ram, &persistent_config_flash, sizeof(persistent_config_t));
|
|
|
|
if (persistent_config_ram.magic != CONFIG_MAGIC) {
|
|
printf("Config: Magic mismatch. Expected 0x%08x, got 0x%08lx\n", CONFIG_MAGIC, persistent_config_ram.magic);
|
|
settings_reset();
|
|
return;
|
|
}
|
|
|
|
if (persistent_config_ram.version != persistent_config_default.version) {
|
|
printf("Config: New config version, resetting settings.\n");
|
|
settings_reset();
|
|
return;
|
|
}
|
|
|
|
// Calculate crc32 of the whole struct with the crc32 value set to 0
|
|
persistent_config_ram.crc32 = 0;
|
|
persistent_config_ram.crc32 = crc32_le(0, (unsigned char *) &persistent_config_ram, sizeof(persistent_config_t));
|
|
|
|
if (persistent_config_ram.crc32 != persistent_config_flash.crc32) {
|
|
printf("Config: CRC32 mismatch. Expected 0x%08lx, got 0x%08lx\n", persistent_config_ram.crc32, persistent_config_flash.crc32);
|
|
settings_reset();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void settings_commit()
|
|
{
|
|
// Calculate crc32 of the whole struct with the crc32 value set to 0
|
|
persistent_config_ram.crc32 = 0;
|
|
persistent_config_ram.crc32 = crc32_le(0, (unsigned char *) &persistent_config_ram, sizeof(persistent_config_t));
|
|
|
|
store_save((const uint8_t *) &persistent_config_flash, (const uint8_t *) &persistent_config_ram, sizeof(persistent_config_t));
|
|
}
|
|
|
|
void settings_reset()
|
|
{
|
|
memcpy(&persistent_config_ram, &persistent_config_default, sizeof(persistent_config_t));
|
|
}
|
|
|
|
uint8_t settings_Volume_get()
|
|
{
|
|
return persistent_config_ram.volume;
|
|
}
|
|
void settings_Volume_set(uint8_t value)
|
|
{
|
|
persistent_config_ram.volume = value;
|
|
}
|
|
|
|
uint8_t settings_Backlight_get()
|
|
{
|
|
return persistent_config_ram.backlight;
|
|
}
|
|
void settings_Backlight_set(uint8_t value)
|
|
{
|
|
persistent_config_ram.backlight = value;
|
|
}
|
|
|
|
|
|
|
|
#define OVERLAY_COLOR_565 0xFFFF
|
|
#define BORDER_COLOR_565 0x1082 // Dark Dark Gray
|
|
|
|
#define BORDER_HEIGHT 240
|
|
#define BORDER_WIDTH 32
|
|
|
|
#define BORDER_Y_OFFSET (((GW_LCD_HEIGHT) - (BORDER_HEIGHT)) / 2)
|
|
|
|
/**
|
|
* Was generated using tool https://github.com/BrianPugh/sheikah-banner with params:
|
|
* python main.py gamewatch --vertical --mode=1 --size=480 --padding=60 --resize 0.05
|
|
* The image was then recropped to 240x32 and then converted using:
|
|
* https://github.com/sylverb/game-and-watch-retro-go/blob/msx_wsv_genesis/tools/binary_png_to_bitarray.py
|
|
*/
|
|
static const uint8_t IMG_BORDER[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0xFF, 0xFF, 0x00, 0x01, 0xFF, 0xFF, 0x80,
|
|
0x03, 0xFF, 0xFF, 0xC0, 0x07, 0xFF, 0xFF, 0xE0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x03, 0xC0, 0xF0,
|
|
0x0F, 0x07, 0xE0, 0xF0, 0x0F, 0x0F, 0xF0, 0xF0,
|
|
0x0F, 0x1F, 0xF8, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x07, 0xFC, 0x78, 0xF0, 0x03, 0xF8, 0x78, 0xF0,
|
|
0x01, 0xF0, 0x78, 0xF0, 0x00, 0xE0, 0x78, 0xF0,
|
|
0x00, 0x00, 0x78, 0xF0, 0x00, 0x00, 0x78, 0xF0,
|
|
0x0F, 0xFF, 0xF8, 0xF0, 0x07, 0xFF, 0xF0, 0xE0,
|
|
0x03, 0xFF, 0xE0, 0xC0, 0x01, 0xFF, 0xC0, 0x80,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x01, 0x03, 0xFF, 0x80, 0x03, 0x07, 0xFF, 0xC0,
|
|
0x07, 0x0F, 0xFF, 0xE0, 0x0F, 0x1F, 0xFF, 0xE0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1E, 0x00, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1E, 0x00, 0xF0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1F, 0xF8, 0xF0,
|
|
0x0F, 0x0F, 0xF8, 0xF0, 0x0F, 0x07, 0xF8, 0xF0,
|
|
0x0F, 0x03, 0xF8, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x07, 0xFF, 0xFF, 0xE0, 0x03, 0xFF, 0xFF, 0xC0,
|
|
0x01, 0xFF, 0xFF, 0x80, 0x00, 0xFF, 0xFF, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00,
|
|
0x01, 0xFF, 0xFF, 0x80, 0x03, 0xFF, 0xFF, 0xC0,
|
|
0x07, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0F, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xF0,
|
|
0x0F, 0xF8, 0x1F, 0xF0, 0x0F, 0xFC, 0x3F, 0xF0,
|
|
0x00, 0x1E, 0x78, 0x00, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xE0,
|
|
0x07, 0xFF, 0xFF, 0xE0, 0x03, 0xFF, 0xFF, 0xC0,
|
|
0x01, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x0F, 0x03, 0xC0, 0xF0,
|
|
0x0F, 0x07, 0xE0, 0xF0, 0x0F, 0x0F, 0xF0, 0xF0,
|
|
0x0F, 0x1F, 0xF8, 0xF0, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x07, 0xE0, 0x07, 0xE0, 0x03, 0xF0, 0x0F, 0xC0,
|
|
0x01, 0xF8, 0x1F, 0x80, 0x00, 0xFC, 0x3F, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x07, 0xFC, 0x3F, 0xE0,
|
|
0x03, 0xF8, 0x1F, 0xC0, 0x01, 0xF0, 0x0F, 0x80,
|
|
0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0xE0, 0x07, 0x00, 0x01, 0xF0, 0x0F, 0x80,
|
|
0x03, 0xF8, 0x1F, 0xC0, 0x07, 0xFC, 0x3F, 0xE0,
|
|
0x00, 0x1E, 0x78, 0x00, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x0F, 0xF0, 0xF0, 0x0F, 0x07, 0xE0, 0xF0,
|
|
0x0F, 0x03, 0xC0, 0xF0, 0x0F, 0x01, 0x80, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x07, 0xFF, 0xFF, 0xE0, 0x03, 0xFF, 0xFF, 0xC0,
|
|
0x01, 0xFF, 0xFF, 0x80, 0x00, 0xFF, 0xFF, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x01, 0x03, 0xFF, 0x80, 0x03, 0x07, 0xFF, 0xC0,
|
|
0x07, 0x0F, 0xFF, 0xE0, 0x0F, 0x1F, 0xFF, 0xF0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1E, 0x00, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1E, 0x00, 0xF0,
|
|
0x0F, 0x1E, 0x00, 0xF0, 0x0F, 0x1F, 0xF8, 0xF0,
|
|
0x0F, 0x0F, 0xF8, 0xF0, 0x0F, 0x07, 0xF8, 0xF0,
|
|
0x0F, 0x03, 0xF8, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x07, 0xFF, 0xFF, 0xE0, 0x03, 0xFF, 0xFF, 0xC0,
|
|
0x01, 0xFF, 0xFF, 0x80, 0x00, 0xFF, 0xFF, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xF8, 0x00,
|
|
0x01, 0x1F, 0xF8, 0x80, 0x03, 0x1F, 0xF8, 0xC0,
|
|
0x07, 0x1F, 0xF8, 0xE0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x03, 0xC0, 0xF0, 0x0F, 0x07, 0xE0, 0xF0,
|
|
0x0F, 0x0F, 0xF0, 0xF0, 0x0F, 0x1F, 0xF8, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0xFE, 0x7F, 0xF0, 0x07, 0xFC, 0x3F, 0xE0,
|
|
0x03, 0xF8, 0x1F, 0xC0, 0x01, 0xF0, 0x0F, 0x80,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x07, 0xFF, 0xFF, 0xE0,
|
|
0x03, 0xFF, 0xFF, 0xC0, 0x01, 0xFF, 0xFF, 0x80,
|
|
0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x01, 0xF0, 0x0F, 0x80,
|
|
0x03, 0xF8, 0x1F, 0xC0, 0x07, 0xFC, 0x3F, 0xE0,
|
|
0x0F, 0xFE, 0x7F, 0xF0, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x00, 0xFC, 0x3F, 0x00,
|
|
0x01, 0xF8, 0x1F, 0x80, 0x03, 0xF0, 0x0F, 0xC0,
|
|
0x07, 0xE0, 0x07, 0xE0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x07, 0xE0, 0x07, 0xE0, 0x03, 0xF0, 0x0F, 0xC0,
|
|
0x01, 0xF8, 0x1F, 0x80, 0x00, 0xFC, 0x3F, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x00, 0x1E, 0x78, 0x00,
|
|
0x00, 0x1E, 0x78, 0x00, 0x07, 0xFC, 0x3F, 0xE0,
|
|
0x03, 0xF8, 0x1F, 0xC0, 0x01, 0xF0, 0x0F, 0x80,
|
|
0x00, 0xE0, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80,
|
|
0x03, 0xFF, 0xFF, 0xC0, 0x07, 0xFF, 0xFF, 0xE0,
|
|
0x0F, 0xFF, 0xFF, 0xE0, 0x0F, 0x00, 0x00, 0xF0,
|
|
0x0F, 0x00, 0x00, 0xF0, 0x0F, 0x01, 0x80, 0xF0,
|
|
0x0F, 0x03, 0xC0, 0xF0, 0x0F, 0x07, 0xE0, 0xF0,
|
|
0x0F, 0x0F, 0xF0, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x0F, 0x1E, 0x78, 0xF0, 0x0F, 0x1E, 0x78, 0xF0,
|
|
0x07, 0x1E, 0x78, 0xE0, 0x03, 0x1E, 0x78, 0xC0,
|
|
0x01, 0x1E, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
void draw_border(pixel_t * fb){
|
|
uint32_t start, bit_index;
|
|
start = 0;
|
|
bit_index = 0;
|
|
for(uint16_t i=0; i < BORDER_HEIGHT; i++){
|
|
uint32_t offset = start + i * GW_LCD_WIDTH;
|
|
for(uint8_t j=0; j < BORDER_WIDTH; j++){
|
|
fb[offset + j] =
|
|
(IMG_BORDER[bit_index >> 3] << (bit_index & 0x07)) & 0x80 ? BORDER_COLOR_565 : 0x0000;
|
|
bit_index++;
|
|
}
|
|
}
|
|
start = 32 + 256;
|
|
bit_index = 0;
|
|
for(uint16_t i=0; i < BORDER_HEIGHT; i++){
|
|
uint32_t offset = start + i * GW_LCD_WIDTH;
|
|
for(uint8_t j=0; j < BORDER_WIDTH; j++){
|
|
fb[offset + j] =
|
|
(IMG_BORDER[bit_index >> 3] << (bit_index & 0x07)) & 0x80 ? BORDER_COLOR_565 : 0x0000;
|
|
bit_index++;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// These must be multiples of 8
|
|
#define IMG_H 24
|
|
#define IMG_W 24
|
|
|
|
static const uint8_t IMG_SPEAKER[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
|
|
0x08, 0x00, 0x00, 0x04, 0x00, 0x30, 0x42, 0x00,
|
|
0x70, 0x21, 0x00, 0xF0, 0x11, 0x7F, 0xF1, 0x09,
|
|
0xFF, 0xF0, 0x89, 0xFF, 0xF0, 0x49, 0xFF, 0xF0,
|
|
0x49, 0xFF, 0xF0, 0x49, 0xFF, 0xF0, 0x49, 0xFF,
|
|
0xF0, 0x49, 0xFF, 0xF0, 0x49, 0x7F, 0xF0, 0x89,
|
|
0x00, 0xF1, 0x09, 0x00, 0x70, 0x11, 0x00, 0x30,
|
|
0x21, 0x00, 0x00, 0x42, 0x00, 0x00, 0x04, 0x00,
|
|
0x00, 0x08, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
|
|
static const uint8_t IMG_SUN[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x00, 0x02,
|
|
0x08, 0x20, 0x01, 0x00, 0x40, 0x00, 0x80, 0x80,
|
|
0x00, 0x1C, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x7F,
|
|
0x00, 0x0E, 0x7F, 0x38, 0x00, 0x7F, 0x00, 0x00,
|
|
0x3E, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x80, 0x40,
|
|
0x01, 0x00, 0x20, 0x02, 0x08, 0x10, 0x00, 0x08,
|
|
0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
static const uint8_t ROUND[] = { // This is the top/left of a 8-pixel radius circle
|
|
0b00000001,
|
|
0b00000111,
|
|
0b00001111,
|
|
0b00011111,
|
|
0b00111111,
|
|
0b01111111,
|
|
0b01111111,
|
|
0b11111111,
|
|
};
|
|
|
|
__attribute__((optimize("unroll-loops")))
|
|
static void draw_img(pixel_t *fb, const uint8_t *img, uint16_t x, uint16_t y){
|
|
uint16_t idx = 0;
|
|
for(uint8_t i=0; i < IMG_H; i++) {
|
|
for(uint8_t j=0; j < IMG_W; j++) {
|
|
if(img[idx / 8] & (1 << (7 - idx % 8))){
|
|
fb[x + j + GW_LCD_WIDTH * (y + i)] = OVERLAY_COLOR_565;
|
|
}
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define DARKEN_MASK_565 0x7BEF // Mask off the MSb of each color
|
|
#define DARKEN_ADD_565 0x2104 // value of 4-red, 8-green, 4-blue to add back in a little gray, especially on black backgrounds
|
|
static inline void darken_pixel(pixel_t *p){
|
|
// Quickly divide all colors by 2
|
|
*p = ((*p >> 1) & DARKEN_MASK_565) + DARKEN_ADD_565;
|
|
}
|
|
|
|
__attribute__((optimize("unroll-loops")))
|
|
static void draw_rectangle(pixel_t *fb, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2){
|
|
for(uint16_t i=y1; i < y2; i++){
|
|
for(uint16_t j=x1; j < x2; j++){
|
|
fb[j + GW_LCD_WIDTH * i] = OVERLAY_COLOR_565;
|
|
}
|
|
}
|
|
}
|
|
|
|
__attribute__((optimize("unroll-loops")))
|
|
static void draw_darken_rectangle(pixel_t *fb, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2){
|
|
for(uint16_t i=y1; i < y2; i++){
|
|
for(uint16_t j=x1; j < x2; j++){
|
|
darken_pixel(&fb[j + GW_LCD_WIDTH * i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
__attribute__((optimize("unroll-loops")))
|
|
static void draw_darken_rounded_rectangle(pixel_t *fb, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2){
|
|
// *1 is inclusive, *2 is exclusive
|
|
uint16_t h = y2 - y1;
|
|
uint16_t w = x2 - x1;
|
|
if (w < 16 || h < 16) {
|
|
// Draw not rounded rectangle
|
|
draw_darken_rectangle(fb, x1, y1, x2, y2);
|
|
return;
|
|
}
|
|
|
|
// Draw upper left round
|
|
for(uint8_t i=0; i < 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
if(ROUND[i] & (1 << (7 - j))) darken_pixel(&fb[x1 + j + GW_LCD_WIDTH * (y1 + i)]);
|
|
|
|
// Draw upper right round
|
|
for(uint8_t i=0; i < 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
if(ROUND[i] & (1 << (7 - j))) darken_pixel(&fb[x2 - j - 1 + GW_LCD_WIDTH * (y1 + i)]);
|
|
|
|
// Draw lower left round
|
|
for(uint8_t i=0; i < 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
if(ROUND[i] & (1 << (7 - j))) darken_pixel(&fb[x1 + j + GW_LCD_WIDTH * (y2 - i - 1)]);
|
|
|
|
// Draw lower right round
|
|
for(uint8_t i=0; i < 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
if(ROUND[i] & (1 << (7 - j))) darken_pixel(&fb[x2 - j - 1 + GW_LCD_WIDTH * (y2 - i - 1)]);
|
|
|
|
// Draw upper rectangle
|
|
for(uint16_t i=x1+8; i < x2 - 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
darken_pixel(&fb[ i + GW_LCD_WIDTH * (y1 + j)]);
|
|
|
|
// Draw central rectangle
|
|
for(uint16_t i=x1; i < x2; i++) for(uint16_t j=y1+8; j < y2-8; j++)
|
|
darken_pixel(&fb[i+GW_LCD_WIDTH * j]);
|
|
|
|
// Draw lower rectangle
|
|
for(uint16_t i=x1+8; i < x2 - 8; i++) for(uint8_t j=0; j < 8; j++)
|
|
darken_pixel(&fb[ i + GW_LCD_WIDTH * (y2 - j - 1)]);
|
|
}
|
|
|
|
#define INGAME_OVERLAY_X 265
|
|
#define INGAME_OVERLAY_Y 10
|
|
#define INGAME_OVERLAY_BARS_H 128
|
|
#define INGAME_OVERLAY_W 39
|
|
#define INGAME_OVERLAY_BORDER 4
|
|
#define INGAME_OVERLAY_BOX_GAP 2
|
|
|
|
#define INGAME_OVERLAY_BARS_W INGAME_OVERLAY_W
|
|
#define INGAME_OVERLAY_IMG_H (IMG_H + 2 * INGAME_OVERLAY_BORDER) // For when only an image is showing
|
|
|
|
#define INGAME_OVERLAY_BOX_W (INGAME_OVERLAY_BARS_W - (2 * INGAME_OVERLAY_BORDER) - 6)
|
|
#define INGAME_OVERLAY_BOX_X (INGAME_OVERLAY_X + ((INGAME_OVERLAY_BARS_W - INGAME_OVERLAY_BOX_W) / 2))
|
|
#define INGAME_OVERLAY_BOX_Y (INGAME_OVERLAY_Y + INGAME_OVERLAY_BORDER + 3)
|
|
|
|
// For when only an image is shown
|
|
#define INGAME_OVERLAY_IMG_X (INGAME_OVERLAY_X + ((INGAME_OVERLAY_BARS_W - IMG_W) / 2))
|
|
#define INGAME_OVERLAY_IMG_Y (INGAME_OVERLAY_Y + INGAME_OVERLAY_BORDER)
|
|
|
|
// Places the image at the bottom for bars-related overlay (volume, brightness)
|
|
#define INGAME_OVERLAY_BARS_IMG_X INGAME_OVERLAY_IMG_X
|
|
#define INGAME_OVERLAY_BARS_IMG_Y (INGAME_OVERLAY_Y + INGAME_OVERLAY_BARS_H - IMG_H - INGAME_OVERLAY_BORDER)
|
|
|
|
#define DARKEN_IMG_ONLY() draw_darken_rounded_rectangle(fb, \
|
|
INGAME_OVERLAY_X, \
|
|
INGAME_OVERLAY_Y, \
|
|
INGAME_OVERLAY_X + INGAME_OVERLAY_BARS_W, \
|
|
INGAME_OVERLAY_Y + INGAME_OVERLAY_IMG_H)
|
|
|
|
|
|
static uint8_t box_height(uint8_t n) {
|
|
return ((INGAME_OVERLAY_BARS_IMG_Y - INGAME_OVERLAY_BOX_Y) / n) - INGAME_OVERLAY_BOX_GAP;
|
|
}
|
|
|
|
void draw_ingame_overlay(pixel_t *fb, ingame_overlay_t overlay){
|
|
uint8_t bh;
|
|
uint16_t by = INGAME_OVERLAY_BOX_Y;
|
|
|
|
switch(overlay)
|
|
{
|
|
case INGAME_OVERLAY_NONE:
|
|
break;
|
|
case INGAME_OVERLAY_VOLUME:
|
|
bh = box_height(AUDIO_VOLUME_MAX);
|
|
|
|
draw_darken_rounded_rectangle(fb,
|
|
INGAME_OVERLAY_X,
|
|
INGAME_OVERLAY_Y,
|
|
INGAME_OVERLAY_X + INGAME_OVERLAY_BARS_W,
|
|
INGAME_OVERLAY_Y + INGAME_OVERLAY_BARS_H);
|
|
draw_img(fb, IMG_SPEAKER, INGAME_OVERLAY_BARS_IMG_X, INGAME_OVERLAY_BARS_IMG_Y);
|
|
|
|
uint8_t volume = settings_Volume_get();
|
|
for(int8_t i=AUDIO_VOLUME_MAX; i > 0; i--){
|
|
if(i <= volume)
|
|
draw_rectangle(fb,
|
|
INGAME_OVERLAY_BOX_X,
|
|
by,
|
|
INGAME_OVERLAY_BOX_X + INGAME_OVERLAY_BOX_W,
|
|
by + bh);
|
|
else
|
|
draw_darken_rectangle(fb,
|
|
INGAME_OVERLAY_BOX_X,
|
|
by,
|
|
INGAME_OVERLAY_BOX_X + INGAME_OVERLAY_BOX_W,
|
|
by + bh);
|
|
|
|
by += bh + INGAME_OVERLAY_BOX_GAP;
|
|
}
|
|
break;
|
|
case INGAME_OVERLAY_BRIGHTNESS:
|
|
bh = box_height(BRIGHTNESS_MAX);
|
|
|
|
draw_darken_rounded_rectangle(fb,
|
|
INGAME_OVERLAY_X,
|
|
INGAME_OVERLAY_Y,
|
|
INGAME_OVERLAY_X + INGAME_OVERLAY_BARS_W,
|
|
INGAME_OVERLAY_Y + INGAME_OVERLAY_BARS_H);
|
|
draw_img(fb, IMG_SUN, INGAME_OVERLAY_BARS_IMG_X, INGAME_OVERLAY_BARS_IMG_Y);
|
|
|
|
uint8_t brightness = settings_Backlight_get();
|
|
for(int8_t i=BRIGHTNESS_MAX; i > 0; i--){
|
|
if(i <= brightness)
|
|
draw_rectangle(fb,
|
|
INGAME_OVERLAY_BOX_X,
|
|
by,
|
|
INGAME_OVERLAY_BOX_X + INGAME_OVERLAY_BOX_W,
|
|
by + bh);
|
|
else
|
|
draw_darken_rectangle(fb,
|
|
INGAME_OVERLAY_BOX_X,
|
|
by,
|
|
INGAME_OVERLAY_BOX_X + INGAME_OVERLAY_BOX_W,
|
|
by + bh);
|
|
|
|
by += bh + INGAME_OVERLAY_BOX_GAP;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*void odroid_display_write_rect(short left, short top, short width, short height, short stride, const uint16_t* buffer)
|
|
{
|
|
pixel_t *dest = lcd_get_active_buffer();
|
|
|
|
for (short y = 0; y < height; y++) {
|
|
pixel_t *dest_row = &dest[(y + top) * GW_LCD_WIDTH + left];
|
|
memcpy(dest_row, &buffer[y * stride], width * sizeof(pixel_t));
|
|
}
|
|
}*/
|
|
|
|
// Same as odroid_display_write_rect but stride is assumed to be width (for backwards compat)
|
|
/*void odroid_display_write(short left, short top, short width, short height, const uint16_t* buffer)
|
|
{
|
|
odroid_display_write_rect(left, top, width, height, width, buffer);
|
|
}*/
|
|
|
|
int odroid_overlay_get_font_width()
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
int odroid_overlay_draw_text_line(pixel_t *fb, uint16_t x_pos, uint16_t y_pos, uint16_t width, const char *text, uint16_t color, uint16_t color_bg)
|
|
{
|
|
int font_height = 8; //odroid_overlay_get_font_size();
|
|
int font_width = 8; //odroid_overlay_get_font_width();
|
|
int x_offset = x_pos;//0;
|
|
float scale = 1; //(float)font_height / 8;
|
|
int text_len = strlen(text);
|
|
|
|
for (int i = 0; i < (width / font_width); i++)
|
|
{
|
|
const char *glyph = font8x8_basic[(i < text_len) ? text[i] : ' '];
|
|
for (int y = 0; y < font_height; y++)
|
|
{
|
|
int offset = x_offset + (width * (y + y_pos));
|
|
for (int x = 0; x < 8; x++)
|
|
{
|
|
/*overlay_buffer*/fb[offset + x] = (glyph[(int)(y/scale)] & (1 << x)) ? color : color_bg;
|
|
}
|
|
}
|
|
x_offset += font_width;
|
|
}
|
|
|
|
//odroid_display_write(x_pos, y_pos, width, font_height, /*overlay_buffer*/fb);
|
|
|
|
return font_height;
|
|
}
|
|
|
|
int odroid_overlay_draw_text(pixel_t *fb, uint16_t x_pos, uint16_t y_pos, uint16_t width, const char *text, uint16_t color, uint16_t color_bg)
|
|
{
|
|
int text_len = 1;
|
|
int height = 0;
|
|
|
|
if (text == NULL || text[0] == 0) {
|
|
text = " ";
|
|
}
|
|
|
|
text_len = strlen(text);
|
|
|
|
if (width < 1) {
|
|
width = text_len * odroid_overlay_get_font_width();
|
|
}
|
|
|
|
if (width > (320/*ODROID_SCREEN_WIDTH*/ - x_pos)) {
|
|
width = (320/*ODROID_SCREEN_WIDTH*/ - x_pos);
|
|
}
|
|
|
|
int line_len = width / odroid_overlay_get_font_width();
|
|
char buffer[320/*ODROID_SCREEN_WIDTH*/ / 8 + 1];
|
|
|
|
for (int pos = 0; pos < text_len;)
|
|
{
|
|
sprintf(buffer, "%.*s", line_len, text + pos);
|
|
if (strchr(buffer, '\n')) *(strchr(buffer, '\n')) = 0;
|
|
height += odroid_overlay_draw_text_line(fb, x_pos, y_pos + height, width, buffer, color, color_bg);
|
|
pos += strlen(buffer);
|
|
if (*(text + pos) == 0 || *(text + pos) == '\n') pos++;
|
|
}
|
|
|
|
return height;
|
|
}
|
|
|
|
cpumon_stats_t cpumon_stats = {0};
|
|
|
|
//uint32_t audioBuffer[AUDIO_BUFFER_LENGTH];
|
|
uint32_t audio_mute;
|
|
|
|
|
|
int16_t pendingSamples = 0;
|
|
int16_t audiobuffer[AUDIO_BUFFER_LENGTH];
|
|
int16_t audiobuffer_dma[AUDIO_BUFFER_LENGTH * 2];
|
|
|
|
dma_transfer_state_t dma_state;
|
|
uint32_t dma_counter;
|
|
|
|
const uint8_t volume_tbl[AUDIO_VOLUME_MAX + 1] = {
|
|
(uint8_t)(UINT8_MAX * 0.00f),
|
|
(uint8_t)(UINT8_MAX * 0.06f),
|
|
(uint8_t)(UINT8_MAX * 0.125f),
|
|
(uint8_t)(UINT8_MAX * 0.187f),
|
|
(uint8_t)(UINT8_MAX * 0.25f),
|
|
(uint8_t)(UINT8_MAX * 0.35f),
|
|
(uint8_t)(UINT8_MAX * 0.42f),
|
|
(uint8_t)(UINT8_MAX * 0.60f),
|
|
(uint8_t)(UINT8_MAX * 0.80f),
|
|
(uint8_t)(UINT8_MAX * 1.00f),
|
|
};
|
|
|
|
void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai)
|
|
{
|
|
dma_counter++;
|
|
dma_state = DMA_TRANSFER_STATE_HF;
|
|
}
|
|
|
|
void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)
|
|
{
|
|
dma_counter++;
|
|
dma_state = DMA_TRANSFER_STATE_TC;
|
|
}
|
|
|
|
|
|
// TODO: Move to own file
|
|
void odroid_audio_mute(bool mute)
|
|
{
|
|
if (mute) {
|
|
for (int i = 0; i < sizeof(audiobuffer_dma) / sizeof(audiobuffer_dma[0]); i++) {
|
|
audiobuffer_dma[i] = 0;
|
|
}
|
|
}
|
|
|
|
audio_mute = mute;
|
|
}
|
|
|
|
common_emu_state_t common_emu_state = {
|
|
.frame_time_10us = (uint16_t)(100000 / 60 + 0.5f), // Reasonable default of 60FPS if not explicitly configured.
|
|
};
|
|
|
|
|
|
static runtime_stats_t statistics;
|
|
static runtime_counters_t counters;
|
|
static uint32_t skip;
|
|
|
|
|
|
void odroid_system_tick(uint32_t skippedFrame, uint32_t fullFrame, uint32_t busyTime)
|
|
{
|
|
if (skippedFrame) counters.skippedFrames++;
|
|
else if (fullFrame) counters.fullFrames++;
|
|
counters.totalFrames++;
|
|
|
|
// Because the emulator may have a different time perception, let's just skip the first report.
|
|
if (skip) {
|
|
skip = 0;
|
|
} else {
|
|
counters.busyTime += busyTime;
|
|
}
|
|
|
|
statistics.lastTickTime = HAL_GetTick();
|
|
}
|
|
|
|
runtime_stats_t odroid_system_get_stats()
|
|
{
|
|
float tickTime = (HAL_GetTick() - counters.resetTime);
|
|
|
|
//statistics.battery = odroid_input_read_battery();
|
|
statistics.busyPercent = counters.busyTime / tickTime * 100.f;
|
|
statistics.skippedFPS = counters.skippedFrames / (tickTime / 1000.f);
|
|
statistics.totalFPS = counters.totalFrames / (tickTime / 1000.f);
|
|
|
|
skip = 1;
|
|
counters.busyTime = 0;
|
|
counters.totalFrames = 0;
|
|
counters.skippedFrames = 0;
|
|
counters.resetTime = HAL_GetTick();
|
|
|
|
return statistics;
|
|
}
|
|
|
|
bool common_emu_frame_loop(void){
|
|
//rg_app_desc_t *app = odroid_system_get_app();
|
|
static int32_t frame_integrator = 0;
|
|
int16_t frame_time_10us = common_emu_state.frame_time_10us;
|
|
int16_t elapsed_10us = 100 * (HAL_GetTick() - common_emu_state.last_sync_time);
|
|
bool draw_frame = common_emu_state.skip_frames < 2;
|
|
|
|
if( !cpumon_stats.busy_ms ) cpumon_busy();
|
|
odroid_system_tick(!draw_frame, 0, cpumon_stats.busy_ms);
|
|
cpumon_reset();
|
|
|
|
common_emu_state.pause_frames = 0;
|
|
common_emu_state.skip_frames = 0;
|
|
|
|
common_emu_state.last_sync_time = HAL_GetTick();
|
|
|
|
if(common_emu_state.startup_frames < 3) {
|
|
common_emu_state.startup_frames++;
|
|
return true;
|
|
}
|
|
|
|
frame_integrator += (elapsed_10us - frame_time_10us);
|
|
if(frame_integrator > frame_time_10us << 1) common_emu_state.skip_frames = 2;
|
|
else if(frame_integrator > frame_time_10us) common_emu_state.skip_frames = 1;
|
|
else if(frame_integrator < -frame_time_10us) common_emu_state.pause_frames = 1;
|
|
common_emu_state.skipped_frames += common_emu_state.skip_frames;
|
|
|
|
return draw_frame;
|
|
}
|
|
|
|
|
|
static void cpumon_common(bool sleep){
|
|
uint32_t t0 = HAL_GetTick(); //get_elapsed_time();
|
|
if(cpumon_stats.last_busy){
|
|
cpumon_stats.busy_ms += t0 - cpumon_stats.last_busy;
|
|
}
|
|
else{
|
|
cpumon_stats.busy_ms = 0;
|
|
}
|
|
if(sleep) __WFI();
|
|
uint32_t t1 = HAL_GetTick(); //get_elapsed_time();
|
|
cpumon_stats.last_busy = t1;
|
|
cpumon_stats.sleep_ms += t1 - t0;
|
|
}
|
|
|
|
|
|
void cpumon_busy(void){
|
|
cpumon_common(false);
|
|
}
|
|
|
|
void cpumon_sleep(void){
|
|
cpumon_common(true);
|
|
}
|
|
|
|
void cpumon_reset(void){
|
|
cpumon_stats.busy_ms = 0;
|
|
cpumon_stats.sleep_ms = 0;
|
|
}
|