Mirror/GodMode9
1
0
Fork 1
mirror of https://github.com/d0k3/GodMode9.git synced 2025-06-26 13:42:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Moved most things to RGB565

Browse Source
This commit is contained in:
Wolfvak 2019-05-21 00:39:40 +02:00 committed by d0k3
parent 73d8d14bd5
commit 50e97d2dab
8 changed files with 123 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
arm11/source/main.c
View File

@ -90,6 +90,15 @@ void PXI_RX_Handler(u32 __attribute__((unused)) irqn)
break; break;
} }
case PXI_SET_VMODE:
{
int mode = args[0] ? PDC_RGB24 : PDC_RGB565;
GPU_SetFramebufferMode(0, mode);
GPU_SetFramebufferMode(1, mode);
ret = 0;
break;
}
case PXI_I2C_READ: case PXI_I2C_READ:
{ {
ARM_InvDC_Range((void*)args[2], args[3]); ARM_InvDC_Range((void*)args[2], args[3]);

6
arm9/source/common/colors.h
View File

@ -1,7 +1,9 @@
#pragma once #pragma once
#define RGB(r,g,b) \
#define RGB(r,g,b) ((int) ((b)<<16|(g)<<8|(r))) (((u32)(r) >> 3) << 11 | \
((u32)(g) >> 2) << 5 | \
((u32)(b) >> 3))
// a base set of colors below // a base set of colors below
#define COLOR_BLACK RGB(0x00, 0x00, 0x00) #define COLOR_BLACK RGB(0x00, 0x00, 0x00)

114
arm9/source/common/ui.c
View File

@ -131,62 +131,52 @@ bool SetFontFromPbm(const void* pbm, u32 pbm_size) {
return true; return true;
} }
void ClearScreen(u8* screen, int color) void ClearScreen(u16* screen, u32 color)
{ {
u32 *screen_wide = (u32*)(void*)screen;
int width = (screen == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT; int width = (screen == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT;
if (color == COLOR_TRANSPARENT) color = COLOR_BLACK; if (color == COLOR_TRANSPARENT)
if (!color) memset(screen, 0x00, (width * SCREEN_HEIGHT * 3)); color = COLOR_BLACK;
else for (int i = 0; i < (width * SCREEN_HEIGHT); i++) {
*(screen++) = color >> 16; // B color |= color << 16;
*(screen++) = color >> 8; // G for (int i = 0; i < (width * SCREEN_HEIGHT / 2); i++)
*(screen++) = color & 0xFF; // R *(screen_wide++) = color;
}
} }
void ClearScreenF(bool clear_main, bool clear_alt, int color) void ClearScreenF(bool clear_main, bool clear_alt, u32 color)
{ {
if (clear_main) ClearScreen(MAIN_SCREEN, color); if (clear_main) ClearScreen(MAIN_SCREEN, color);
if (clear_alt) ClearScreen(ALT_SCREEN, color); if (clear_alt) ClearScreen(ALT_SCREEN, color);
} }
u32 GetColor(u8* screen, int x, int y) u16 GetColor(u16 *screen, int x, int y)
{ {
u32 color = 0; int xDisplacement = x * SCREEN_HEIGHT;
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT); int yDisplacement = SCREEN_HEIGHT - y - 1;
int yDisplacement = ((SCREEN_HEIGHT - y - 1) * BYTES_PER_PIXEL); return screen[xDisplacement + yDisplacement];
u8* screenPos = screen + xDisplacement + yDisplacement;
color |= (*(screenPos + 0) << 16 ); // B
color |= (*(screenPos + 1) << 8 ); // G
color |= (*(screenPos + 2) << 0 ); // R
return color;
} }
void DrawPixel(u8* screen, int x, int y, int color) void DrawPixel(u16 *screen, int x, int y, int color)
{ {
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT); int xDisplacement = x * SCREEN_HEIGHT;
int yDisplacement = ((SCREEN_HEIGHT - y - 1) * BYTES_PER_PIXEL); int yDisplacement = SCREEN_HEIGHT - y - 1;
u8* screenPos = screen + xDisplacement + yDisplacement; screen[xDisplacement + yDisplacement] = color;
*(screenPos + 0) = color >> 16; // B
*(screenPos + 1) = color >> 8; // G
*(screenPos + 2) = color & 0xFF; // R
} }
void DrawRectangle(u8* screen, int x, int y, int width, int height, int color) void DrawRectangle(u16 *screen, int x, int y, int width, int height, int color)
{ {
for (int yy = 0; yy < height; yy++) { for (int yy = 0; yy < height; yy++) {
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT); int xDisplacement = x * SCREEN_HEIGHT;
int yDisplacement = ((SCREEN_HEIGHT - (y + yy) - 1) * BYTES_PER_PIXEL); int yDisplacement = (SCREEN_HEIGHT - (y + yy) - 1);
u8* screenPos = screen + xDisplacement + yDisplacement; u16* screenPos = screen + xDisplacement + yDisplacement;
for (int xx = width - 1; xx >= 0; xx--) { for (int xx = width - 1; xx >= 0; xx--) {
*(screenPos + 0) = color >> 16; // B *screenPos = color;
*(screenPos + 1) = color >> 8; // G screenPos += SCREEN_HEIGHT;
*(screenPos + 2) = color & 0xFF; // R
screenPos += BYTES_PER_PIXEL * SCREEN_HEIGHT;
} }
} }
} }
void DrawBitmap(u8* screen, int x, int y, int w, int h, u8* bitmap) void DrawBitmap(u16 *screen, int x, int y, int w, int h, const u8* bitmap)
{ {
// on negative values: center the bitmap // on negative values: center the bitmap
if (x < 0) x = (SCREEN_WIDTH(screen) - w) >> 1; if (x < 0) x = (SCREEN_WIDTH(screen) - w) >> 1;
@ -196,20 +186,19 @@ void DrawBitmap(u8* screen, int x, int y, int w, int h, u8* bitmap)
if ((x < 0) || (y < 0) || (w > SCREEN_WIDTH(screen)) || (h > SCREEN_HEIGHT)) if ((x < 0) || (y < 0) || (w > SCREEN_WIDTH(screen)) || (h > SCREEN_HEIGHT))
return; return;
u8* bitmapPos = bitmap;
for (int yy = 0; yy < h; yy++) { for (int yy = 0; yy < h; yy++) {
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT); int xDisplacement = x * SCREEN_HEIGHT;
int yDisplacement = ((SCREEN_HEIGHT - (y + yy) - 1) * BYTES_PER_PIXEL); int yDisplacement = SCREEN_HEIGHT - (y + yy) - 1;
u8* screenPos = screen + xDisplacement + yDisplacement; u16 *screenPos = screen + xDisplacement + yDisplacement;
for (int xx = 0; xx < w; xx++) { for (int xx = 0; xx < w; xx++) {
memcpy(screenPos, bitmapPos, BYTES_PER_PIXEL); *(screenPos) = RGB(bitmap[2], bitmap[1], bitmap[0]);
bitmapPos += BYTES_PER_PIXEL; bitmap += 3;
screenPos += BYTES_PER_PIXEL * SCREEN_HEIGHT; screenPos += SCREEN_HEIGHT;
} }
} }
} }
void DrawQrCode(u8* screen, u8* qrcode) void DrawQrCode(u16 *screen, const u8* qrcode)
{ {
const u32 size_qr = qrcodegen_getSize(qrcode); const u32 size_qr = qrcodegen_getSize(qrcode);
u32 size_qr_s = size_qr; u32 size_qr_s = size_qr;
@ -230,42 +219,38 @@ void DrawQrCode(u8* screen, u8* qrcode)
// draw the QR code // draw the QR code
u32 x_qr = (SCREEN_WIDTH(screen) - size_qr_s) / 2; u32 x_qr = (SCREEN_WIDTH(screen) - size_qr_s) / 2;
u32 y_qr = (SCREEN_HEIGHT - size_qr_s) / 2; u32 y_qr = (SCREEN_HEIGHT - size_qr_s) / 2;
int xDisplacement = (x_qr * BYTES_PER_PIXEL * SCREEN_HEIGHT); int xDisplacement = x_qr * SCREEN_HEIGHT;
for (u32 y = 0; y < size_qr_s; y++) { for (u32 y = 0; y < size_qr_s; y++) {
int yDisplacement = ((SCREEN_HEIGHT - (y_qr + y) - 1) * BYTES_PER_PIXEL); int yDisplacement = SCREEN_HEIGHT - (y_qr + y) - 1;
u8* screenPos = screen + xDisplacement + yDisplacement; u16* screenPos = screen + xDisplacement + yDisplacement;
for (u32 x = 0; x < size_qr_s; x++) { for (u32 x = 0; x < size_qr_s; x++) {
u8 c = qrcodegen_getModule(qrcode, x/scale, y/scale) ? 0x00 : 0xFF; u16 c = qrcodegen_getModule(qrcode, x/scale, y/scale) ? COLOR_BLACK : COLOR_WHITE;
memset(screenPos, c, BYTES_PER_PIXEL); *(screenPos) = c;
screenPos += BYTES_PER_PIXEL * SCREEN_HEIGHT; screenPos += SCREEN_HEIGHT;
} }
} }
} }
void DrawCharacter(u8* screen, int character, int x, int y, int color, int bgcolor) void DrawCharacter(u16 *screen, int character, int x, int y, int color, int bgcolor)
{ {
for (int yy = 0; yy < (int) font_height; yy++) { for (int yy = 0; yy < (int) font_height; yy++) {
int xDisplacement = (x * BYTES_PER_PIXEL * SCREEN_HEIGHT); int xDisplacement = x * SCREEN_HEIGHT;
int yDisplacement = ((SCREEN_HEIGHT - (y + yy) - 1) * BYTES_PER_PIXEL); int yDisplacement = SCREEN_HEIGHT - (y + yy) - 1;
u8* screenPos = screen + xDisplacement + yDisplacement; u16* screenPos = screen + xDisplacement + yDisplacement;
u8 charPos = font_bin[character * font_height + yy]; u8 charPos = font_bin[character * font_height + yy];
for (int xx = 7; xx >= (8 - (int) font_width); xx--) { for (int xx = 7; xx >= (8 - (int) font_width); xx--) {
if ((charPos >> xx) & 1) { if ((charPos >> xx) & 1) {
*(screenPos + 0) = color >> 16; // B *screenPos = color;
*(screenPos + 1) = color >> 8; // G
*(screenPos + 2) = color & 0xFF; // R
} else if (bgcolor != COLOR_TRANSPARENT) { } else if (bgcolor != COLOR_TRANSPARENT) {
*(screenPos + 0) = bgcolor >> 16; // B *screenPos = bgcolor;
*(screenPos + 1) = bgcolor >> 8; // G
*(screenPos + 2) = bgcolor & 0xFF; // R
} }
screenPos += BYTES_PER_PIXEL * SCREEN_HEIGHT; screenPos += SCREEN_HEIGHT;
} }
} }
} }
void DrawString(u8* screen, const char *str, int x, int y, int color, int bgcolor, bool fix_utf8) void DrawString(u16 *screen, const char *str, int x, int y, int color, int bgcolor, bool fix_utf8)
{ {
size_t max_len = (((screen == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT) - x) / font_width; size_t max_len = (((screen == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT) - x) / font_width;
size_t len = (strlen(str) > max_len) ? max_len : strlen(str); size_t len = (strlen(str) > max_len) ? max_len : strlen(str);
@ -275,7 +260,7 @@ void DrawString(u8* screen, const char *str, int x, int y, int color, int bgcolo
} }
} }
void DrawStringF(u8* screen, int x, int y, int color, int bgcolor, const char *format, ...) void DrawStringF(u16 *screen, int x, int y, int color, int bgcolor, const char *format, ...)
{ {
char str[STRBUF_SIZE] = { 0 }; char str[STRBUF_SIZE] = { 0 };
va_list va; va_list va;
@ -287,7 +272,7 @@ void DrawStringF(u8* screen, int x, int y, int color, int bgcolor, const char *f
DrawString(screen, text, x, y, color, bgcolor, true); DrawString(screen, text, x, y, color, bgcolor, true);
} }
void DrawStringCenter(u8* screen, int color, int bgcolor, const char *format, ...) void DrawStringCenter(u16 *screen, int color, int bgcolor, const char *format, ...)
{ {
char str[STRBUF_SIZE] = { 0 }; char str[STRBUF_SIZE] = { 0 };
va_list va; va_list va;
@ -471,12 +456,11 @@ bool ShowPrompt(bool ask, const char *format, ...)
#ifndef AUTO_UNLOCK #ifndef AUTO_UNLOCK
#define PRNG (*(volatile u32*)0x10011000) #define PRNG (*(volatile u32*)0x10011000)
bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) { bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
const int seqcolors[7] = { COLOR_STD_FONT, COLOR_BRIGHTGREEN, COLOR_BRIGHTYELLOW, static const int seqcolors[7] = { COLOR_STD_FONT, COLOR_BRIGHTGREEN,
COLOR_ORANGE, COLOR_BRIGHTBLUE, COLOR_RED, COLOR_DARKRED }; COLOR_BRIGHTYELLOW, COLOR_ORANGE, COLOR_BRIGHTBLUE, COLOR_RED, COLOR_DARKRED };
const u32 seqlen_max = 7; const u32 seqlen_max = 7;
const u32 seqlen = seqlen_max - ((seqlvl < 3) ? 2 : (seqlvl < 4) ? 1 : 0); const u32 seqlen = seqlen_max - ((seqlvl < 3) ? 2 : (seqlvl < 4) ? 1 : 0);
u32 color_bg = COLOR_STD_BG; u32 color_bg = COLOR_STD_BG;
u32 color_font = COLOR_STD_FONT; u32 color_font = COLOR_STD_FONT;
u32 color_off = COLOR_GREY; u32 color_off = COLOR_GREY;

28
arm9/source/common/ui.h
View File

@ -10,7 +10,7 @@
#include "fsdir.h" // only required for ShowFileScrollPrompt #include "fsdir.h" // only required for ShowFileScrollPrompt
#define BYTES_PER_PIXEL 3 #define BYTES_PER_PIXEL 2
#define SCREEN_HEIGHT 240 #define SCREEN_HEIGHT 240
#define SCREEN_WIDTH(s) ((s == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT) #define SCREEN_WIDTH(s) ((s == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT)
#define SCREEN_WIDTH_TOP 400 #define SCREEN_WIDTH_TOP 400
@ -21,8 +21,8 @@
#define FONT_WIDTH_EXT GetFontWidth() #define FONT_WIDTH_EXT GetFontWidth()
#define FONT_HEIGHT_EXT GetFontHeight() #define FONT_HEIGHT_EXT GetFontHeight()
#define TOP_SCREEN ((u8*)VRAM_TOP_LA) #define TOP_SCREEN ((u16*)VRAM_TOP_LA)
#define BOT_SCREEN ((u8*)VRAM_BOT_A) #define BOT_SCREEN ((u16*)VRAM_BOT_A)
#ifdef SWITCH_SCREENS #ifdef SWITCH_SCREENS
#define MAIN_SCREEN TOP_SCREEN #define MAIN_SCREEN TOP_SCREEN
@ -48,19 +48,19 @@ bool ShowUnlockSequence(u32 seqlvl, const char *format, ...);
u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h); u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h);
bool SetFontFromPbm(const void* pbm, const u32 pbm_size); bool SetFontFromPbm(const void* pbm, const u32 pbm_size);
u32 GetColor(u8* screen, int x, int y); u16 GetColor(u16 *screen, int x, int y);
void ClearScreen(unsigned char *screen, int color); void ClearScreen(u16 *screen, u32 color);
void ClearScreenF(bool clear_main, bool clear_alt, int color); void ClearScreenF(bool clear_main, bool clear_alt, u32 color);
void DrawPixel(u8* screen, int x, int y, int color); void DrawPixel(u16 *screen, int x, int y, int color);
void DrawRectangle(u8* screen, int x, int y, int width, int height, int color); void DrawRectangle(u16 *screen, int x, int y, int width, int height, int color);
void DrawBitmap(u8* screen, int x, int y, int w, int h, u8* bitmap); void DrawBitmap(u16 *screen, int x, int y, int w, int h, const u8* bitmap);
void DrawQrCode(u8* screen, u8* qrcode); void DrawQrCode(u16 *screen, const u8* qrcode);
void DrawCharacter(unsigned char *screen, int character, int x, int y, int color, int bgcolor); void DrawCharacter(u16 *screen, int character, int x, int y, int color, int bgcolor);
void DrawString(unsigned char *screen, const char *str, int x, int y, int color, int bgcolor, bool fix_utf8); void DrawString(u16 *screen, const char *str, int x, int y, int color, int bgcolor, bool fix_utf8);
void DrawStringF(unsigned char *screen, int x, int y, int color, int bgcolor, const char *format, ...); void DrawStringF(u16 *screen, int x, int y, int color, int bgcolor, const char *format, ...);
void DrawStringCenter(u8* screen, int color, int bgcolor, const char *format, ...); void DrawStringCenter(u16 *screen, int color, int bgcolor, const char *format, ...);
u32 GetDrawStringHeight(const char* str); u32 GetDrawStringHeight(const char* str);
u32 GetDrawStringWidth(const char* str); u32 GetDrawStringWidth(const char* str);

25
arm9/source/godmode.c
View File

@ -103,6 +103,7 @@ u32 BootFirmHandler(const char* bootpath, bool verbose, bool delete) {
// boot the FIRM (if we got a proper fixpath) // boot the FIRM (if we got a proper fixpath)
if (*fixpath) { if (*fixpath) {
if (delete) PathDelete(bootpath); if (delete) PathDelete(bootpath);
PXI_DoCMD(PXI_SET_VMODE, (u32[]){1}, 1);
PXI_DoCMD(PXI_LEGACY_MODE, NULL, 0); PXI_DoCMD(PXI_LEGACY_MODE, NULL, 0);
BootFirm((FirmHeader*) firm, fixpath); BootFirm((FirmHeader*) firm, fixpath);
while(1); while(1);
@ -185,10 +186,11 @@ void CheckBattery(u32* battery, bool* is_charging) {
} }
} }
void GenerateBatteryBitmap(u8* bitmap, u32 width, u32 height, u32 color_bg) { void DrawBatteryBitmap(u16* screen, u32 b_x, u32 b_y, u32 width, u32 height) {
const u32 color_outline = COLOR_BLACK; const u16 color_outline = COLOR_BLACK;
const u32 color_inline = COLOR_LIGHTGREY; const u16 color_inline = COLOR_LIGHTGREY;
const u32 color_inside = COLOR_LIGHTERGREY; const u16 color_inside = COLOR_LIGHTERGREY;
const u16 color_bg = COLOR_TRANSPARENT;
if ((width < 8) || (height < 6)) return; if ((width < 8) || (height < 6)) return;
@ -196,7 +198,7 @@ void GenerateBatteryBitmap(u8* bitmap, u32 width, u32 height, u32 color_bg) {
bool is_charging; bool is_charging;
CheckBattery(&battery, &is_charging); CheckBattery(&battery, &is_charging);
u32 color_battery = (is_charging) ? COLOR_BATTERY_CHARGING : u16 color_battery = (is_charging) ? COLOR_BATTERY_CHARGING :
(battery > 70) ? COLOR_BATTERY_FULL : (battery > 30) ? COLOR_BATTERY_MEDIUM : COLOR_BATTERY_LOW; (battery > 70) ? COLOR_BATTERY_FULL : (battery > 30) ? COLOR_BATTERY_MEDIUM : COLOR_BATTERY_LOW;
u32 nub_size = (height < 12) ? 1 : 2; u32 nub_size = (height < 12) ? 1 : 2;
u32 width_inside = width - 4 - nub_size; u32 width_inside = width - 4 - nub_size;
@ -206,15 +208,13 @@ void GenerateBatteryBitmap(u8* bitmap, u32 width, u32 height, u32 color_bg) {
const u32 mirror_y = (y >= (height+1) / 2) ? height - 1 - y : y; const u32 mirror_y = (y >= (height+1) / 2) ? height - 1 - y : y;
for (u32 x = 0; x < width; x++) { for (u32 x = 0; x < width; x++) {
const u32 rev_x = width - x - 1; const u32 rev_x = width - x - 1;
u32 color = 0; u16 color = 0;
if (mirror_y == 0) color = (rev_x >= nub_size) ? color_outline : color_bg; if (mirror_y == 0) color = (rev_x >= nub_size) ? color_outline : color_bg;
else if (mirror_y == 1) color = ((x == 0) || (rev_x == nub_size)) ? color_outline : (rev_x < nub_size) ? color_bg : color_inline; else if (mirror_y == 1) color = ((x == 0) || (rev_x == nub_size)) ? color_outline : (rev_x < nub_size) ? color_bg : color_inline;
else if (mirror_y == 2) color = ((x == 0) || (rev_x <= nub_size)) ? color_outline : ((x == 1) || (rev_x == (nub_size+1))) ? color_inline : color_inside; else if (mirror_y == 2) color = ((x == 0) || (rev_x <= nub_size)) ? color_outline : ((x == 1) || (rev_x == (nub_size+1))) ? color_inline : color_inside;
else color = ((x == 0) || (rev_x == 0)) ? color_outline : ((x == 1) || (rev_x <= (nub_size+1))) ? color_inline : color_inside; else color = ((x == 0) || (rev_x == 0)) ? color_outline : ((x == 1) || (rev_x <= (nub_size+1))) ? color_inline : color_inside;
if ((color == color_inside) && (x < (2 + width_battery))) color = color_battery; if ((color == color_inside) && (x < (2 + width_battery))) color = color_battery;
*(bitmap++) = color >> 16; // B if (color != color_bg) DrawPixel(screen, b_x + x, b_y + y, color);
*(bitmap++) = color >> 8; // G
*(bitmap++) = color & 0xFF; // R
} }
} }
} }
@ -264,10 +264,7 @@ void DrawTopBar(const char* curr_path) {
char timestr[32]; char timestr[32];
GetTimeString(timestr, false, false); GetTimeString(timestr, false, false);
DrawStringF(TOP_SCREEN, clock_x, bartxt_start, COLOR_STD_BG, COLOR_TOP_BAR, "%14.14s", timestr); DrawStringF(TOP_SCREEN, clock_x, bartxt_start, COLOR_STD_BG, COLOR_TOP_BAR, "%14.14s", timestr);
DrawBatteryBitmap(TOP_SCREEN, battery_x, battery_y, battery_width, battery_height);
u8 bitmap[battery_width * battery_height * BYTES_PER_PIXEL];
GenerateBatteryBitmap(bitmap, battery_width, battery_height, COLOR_TOP_BAR);
DrawBitmap(TOP_SCREEN, battery_x, battery_y, battery_width, battery_height, bitmap);
} }
} }
@ -674,7 +671,7 @@ u32 FileHexViewer(const char* path) {
u32 y = row * (FONT_HEIGHT_EXT + (2*vpad)) + vpad; u32 y = row * (FONT_HEIGHT_EXT + (2*vpad)) + vpad;
u32 curr_pos = row * cols; u32 curr_pos = row * cols;
u32 cutoff = (curr_pos >= total_data) ? 0 : (total_data >= curr_pos + cols) ? cols : total_data - curr_pos; u32 cutoff = (curr_pos >= total_data) ? 0 : (total_data >= curr_pos + cols) ? cols : total_data - curr_pos;
u8* screen = TOP_SCREEN; u16* screen = TOP_SCREEN;
u32 x0 = 0; u32 x0 = 0;
// marked offsets handling // marked offsets handling

3
arm9/source/main.c
View File

@ -19,6 +19,9 @@ void main(int argc, char** argv, int entrypoint)
// ARM11 says it's ready // ARM11 says it's ready
PXI_Barrier(ARM11_READY_BARRIER); PXI_Barrier(ARM11_READY_BARRIER);
// Set screens to RGB16 mode
PXI_DoCMD(PXI_SET_VMODE, (u32[]){0}, 1);
// A pointer to the shared memory region is // A pointer to the shared memory region is
// stored in the thread ID register in the ARM9 // stored in the thread ID register in the ARM9
ARM_InitSHMEM(); ARM_InitSHMEM();

88
arm9/source/utils/paint9.c
View File

@ -26,61 +26,34 @@ static const TouchBox paint9_boxes[] = {
}; };
static const u8 color_picker_tmp[PAINT9_COLSEL_HEIGHT * BYTES_PER_PIXEL] = { static const u8 color_picker_tmp[PAINT9_COLSEL_HEIGHT * BYTES_PER_PIXEL] = {
0xFD, 0x01, 0x00, 0xFD, 0x01, 0x00, 0xFC, 0x00, 0x01, 0xFD, 0x00, 0x04, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x01, 0xF8, 0x02, 0xF8, 0x02, 0xF8, 0x03, 0xF8,
0xFE, 0x00, 0x0A, 0xFF, 0x00, 0x0E, 0xFE, 0x00, 0x10, 0xFF, 0x00, 0x15, 0x04, 0xF8, 0x05, 0xF8, 0x06, 0xF8, 0x07, 0xF8, 0x08, 0xF8, 0x09, 0xF8, 0x0A, 0xF8, 0x0C, 0xF8,
0xFE, 0x00, 0x1E, 0xFE, 0x00, 0x27, 0xFC, 0x00, 0x2F, 0xFD, 0x00, 0x36, 0x0D, 0xF8, 0x0E, 0xF8, 0x10, 0xF8, 0x11, 0xF8, 0x12, 0xF8, 0x14, 0xF8, 0x16, 0xF8, 0x17, 0xF8,
0xFE, 0x00, 0x3F, 0xFF, 0x00, 0x49, 0xFE, 0x00, 0x52, 0xFD, 0x00, 0x5E, 0x17, 0xF8, 0x19, 0xF8, 0x1A, 0xF8, 0x1B, 0xF8, 0x1C, 0xF8, 0x1D, 0xF8, 0x1E, 0xF8, 0x1E, 0xF8,
0xFC, 0x00, 0x67, 0xFD, 0x00, 0x74, 0xFE, 0x00, 0x7F, 0xFF, 0x00, 0x89, 0x1E, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8,
0xFE, 0x00, 0x94, 0xFF, 0x00, 0xA1, 0xFD, 0x00, 0xAD, 0xFD, 0x00, 0xB5, 0x1F, 0xF8, 0x1F, 0xF0, 0x1F, 0xF0, 0x1F, 0xE8, 0x1F, 0xE0, 0x1F, 0xE0, 0x1F, 0xD8, 0x1F, 0xC8,
0xFE, 0x00, 0xBC, 0xFE, 0x00, 0xC6, 0xFE, 0x00, 0xCF, 0xFE, 0x00, 0xD9, 0x1F, 0xC0, 0x1F, 0xB8, 0x1F, 0xB0, 0x1F, 0xA8, 0x1F, 0x98, 0x1F, 0x90, 0x1F, 0x88, 0x1F, 0x78,
0xFF, 0x00, 0xDE, 0xFE, 0x01, 0xE7, 0xFD, 0x01, 0xEE, 0xFE, 0x00, 0xEF, 0x1F, 0x70, 0x1F, 0x60, 0x1F, 0x58, 0x1F, 0x48, 0x1F, 0x48, 0x1F, 0x40, 0x1F, 0x30, 0x1F, 0x28,
0xFD, 0x00, 0xF1, 0xFE, 0x00, 0xF7, 0xFF, 0x00, 0xFB, 0xFF, 0x00, 0xFE, 0x1F, 0x20, 0x1F, 0x18, 0x1F, 0x10, 0x1F, 0x10, 0x1F, 0x08, 0x1F, 0x08, 0x1F, 0x00, 0x1F, 0x00,
0xFE, 0x00, 0xFE, 0xFE, 0x00, 0xFE, 0xFF, 0x00, 0xFF, 0xFE, 0x00, 0xFF, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x3F, 0x00, 0x5F, 0x00, 0x7F, 0x00, 0x9F, 0x00,
0xFA, 0x00, 0xFE, 0xF4, 0x00, 0xFE, 0xEF, 0x00, 0xFE, 0xEA, 0x00, 0xFE, 0xBF, 0x00, 0xFF, 0x00, 0x3F, 0x01, 0x7F, 0x01, 0xBF, 0x01, 0x1F, 0x02, 0x5F, 0x02, 0x9F, 0x02,
0xE2, 0x00, 0xFF, 0xDD, 0x00, 0xFE, 0xD6, 0x00, 0xFF, 0xCC, 0x00, 0xFE, 0xFF, 0x02, 0x5F, 0x03, 0x9F, 0x03, 0xFF, 0x03, 0x5F, 0x04, 0xBF, 0x04, 0xFF, 0x04, 0x5F, 0x05,
0xC2, 0x00, 0xFE, 0xB9, 0x00, 0xFF, 0xB2, 0x00, 0xFD, 0xA8, 0x00, 0xFE, 0x9F, 0x05, 0xFF, 0x05, 0x3F, 0x06, 0x7F, 0x06, 0xDF, 0x06, 0x1F, 0x07, 0x3F, 0x07, 0x7F, 0x07,
0x9B, 0x00, 0xFF, 0x92, 0x00, 0xFE, 0x86, 0x00, 0xFD, 0x79, 0x00, 0xFE, 0x9F, 0x07, 0xBF, 0x07, 0xDF, 0x07, 0xFF, 0x07, 0xFF, 0x07, 0xFF, 0x07, 0xFF, 0x07, 0xFF, 0x07,
0x6E, 0x00, 0xFF, 0x64, 0x00, 0xFD, 0x5A, 0x00, 0xFE, 0x4B, 0x00, 0xFF, 0xFF, 0x07, 0xFF, 0x07, 0xFE, 0x07, 0xFE, 0x07, 0xFE, 0x07, 0xFD, 0x07, 0xFC, 0x07, 0xFA, 0x07,
0x46, 0x00, 0xFE, 0x3E, 0x00, 0xFE, 0x34, 0x00, 0xFE, 0x2B, 0x00, 0xFE, 0xF9, 0x07, 0xF9, 0x07, 0xF8, 0x07, 0xF6, 0x07, 0xF5, 0x07, 0xF4, 0x07, 0xF2, 0x07, 0xF1, 0x07,
0x22, 0x00, 0xFE, 0x1C, 0x00, 0xFD, 0x13, 0x00, 0xFD, 0x0F, 0x00, 0xFF, 0xF0, 0x07, 0xEE, 0x07, 0xED, 0x07, 0xEC, 0x07, 0xEA, 0x07, 0xE9, 0x07, 0xE8, 0x07, 0xE7, 0x07,
0x0B, 0x00, 0xFE, 0x07, 0x00, 0xFD, 0x02, 0x00, 0xFD, 0x01, 0x00, 0xFF, 0xE5, 0x07, 0xE4, 0x07, 0xE4, 0x07, 0xE3, 0x07, 0xE2, 0x07, 0xE2, 0x07, 0xE1, 0x07, 0xE0, 0x07,
0x00, 0x01, 0xFF, 0x00, 0x00, 0xFD, 0x00, 0x00, 0xFE, 0x00, 0x02, 0xFF, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x07, 0xE0, 0x0F, 0xE0, 0x0F,
0x00, 0x04, 0xFE, 0x00, 0x09, 0xFE, 0x00, 0x0C, 0xFE, 0x02, 0x10, 0xFF, 0xE0, 0x17, 0xE0, 0x17, 0xE0, 0x1F, 0xE0, 0x27, 0xE0, 0x37, 0xE0, 0x37, 0xE0, 0x3F, 0xE0, 0x4F,
0x00, 0x14, 0xFF, 0x00, 0x1C, 0xFE, 0x01, 0x23, 0xFE, 0x01, 0x2C, 0xFF, 0xE0, 0x57, 0xE0, 0x5F, 0xE0, 0x67, 0xE0, 0x77, 0xE0, 0x7F, 0xE0, 0x8F, 0xE0, 0x97, 0xE0, 0xA7,
0x00, 0x36, 0xFE, 0x00, 0x40, 0xFD, 0x00, 0x48, 0xFE, 0x01, 0x50, 0xFE, 0xE0, 0xAF, 0xE0, 0xB7, 0xE0, 0xBF, 0xE0, 0xC7, 0xE0, 0xCF, 0xE0, 0xDF, 0xE0, 0xDF, 0xE0, 0xE7,
0x00, 0x5D, 0xFE, 0x00, 0x67, 0xFD, 0x01, 0x72, 0xFC, 0x00, 0x7D, 0xFD, 0xE0, 0xF7, 0xE0, 0xF7, 0xE0, 0xF7, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF, 0xE0, 0xFF,
0x00, 0x88, 0xFF, 0x00, 0x93, 0xFF, 0x02, 0x9C, 0xFE, 0x00, 0xA8, 0xFD, 0xE0, 0xFF, 0xE0, 0xFF, 0xC0, 0xFF, 0xA0, 0xFF, 0x80, 0xFF, 0x60, 0xFF, 0x40, 0xFF, 0x00, 0xFF,
0x00, 0xB2, 0xFD, 0x02, 0xBB, 0xFF, 0x01, 0xC5, 0xFF, 0x00, 0xCE, 0xFE, 0xC0, 0xFE, 0x80, 0xFE, 0x20, 0xFE, 0xE0, 0xFD, 0xA0, 0xFD, 0x40, 0xFD, 0xE0, 0xFC, 0xA0, 0xFC,
0x00, 0xD7, 0xFD, 0x01, 0xDF, 0xFE, 0x00, 0xE6, 0xFE, 0x00, 0xED, 0xFC, 0x40, 0xFC, 0xE0, 0xFB, 0x80, 0xFB, 0x40, 0xFB, 0x00, 0xFB, 0xA0, 0xFA, 0x60, 0xFA, 0x00, 0xFA,
0x00, 0xF0, 0xFE, 0x00, 0xF4, 0xFE, 0x00, 0xF8, 0xFD, 0x00, 0xFC, 0xFD, 0xC0, 0xF9, 0x60, 0xF9, 0x20, 0xF9, 0xE0, 0xF8, 0xA0, 0xF8, 0x80, 0xF8, 0x60, 0xF8, 0x40, 0xF8,
0x00, 0xFE, 0xFC, 0x01, 0xFF, 0xFD, 0x01, 0xFE, 0xFF, 0x00, 0xFE, 0xFE, 0x20, 0xF8, 0x00, 0xF8, 0x00, 0xF8, 0x00, 0xF8
0x01, 0xFF, 0xFC, 0x00, 0xFE, 0xF7, 0x00, 0xFE, 0xF2, 0x00, 0xFF, 0xF0,
0x00, 0xFF, 0xED, 0x00, 0xFE, 0xE7, 0x00, 0xFD, 0xDE, 0x00, 0xFE, 0xD3,
0x00, 0xFE, 0xCA, 0x00, 0xFE, 0xC5, 0x00, 0xFF, 0xBD, 0x00, 0xFF, 0xB2,
0x00, 0xFE, 0xAA, 0x01, 0xFD, 0xA0, 0x02, 0xFE, 0x93, 0x01, 0xFF, 0x89,
0x00, 0xFE, 0x7E, 0x00, 0xFE, 0x73, 0x00, 0xFE, 0x68, 0x00, 0xFF, 0x5D,
0x00, 0xFE, 0x4E, 0x01, 0xFE, 0x47, 0x00, 0xFF, 0x40, 0x00, 0xFE, 0x35,
0x00, 0xFE, 0x2B, 0x00, 0xFF, 0x23, 0x00, 0xFF, 0x1E, 0x01, 0xFE, 0x16,
0x01, 0xFE, 0x10, 0x00, 0xFD, 0x0D, 0x00, 0xFC, 0x08, 0x00, 0xFE, 0x04,
0x00, 0xFF, 0x02, 0x00, 0xFE, 0x00, 0x00, 0xFE, 0x00, 0x00, 0xFF, 0x00,
0x00, 0xFE, 0x00, 0x02, 0xFD, 0x00, 0x07, 0xFD, 0x00, 0x0C, 0xFE, 0x00,
0x0F, 0xFF, 0x00, 0x13, 0xFE, 0x00, 0x1B, 0xFE, 0x00, 0x23, 0xFF, 0x00,
0x2D, 0xFE, 0x01, 0x34, 0xFD, 0x00, 0x3C, 0xFF, 0x01, 0x46, 0xFF, 0x02,
0x4F, 0xFE, 0x03, 0x59, 0xFE, 0x00, 0x64, 0xFF, 0x00, 0x71, 0xFE, 0x00,
0x7C, 0xFF, 0x00, 0x85, 0xFE, 0x00, 0x90, 0xFF, 0x00, 0x9D, 0xFE, 0x01,
0xAA, 0xFE, 0x00, 0xB2, 0xFE, 0x00, 0xB9, 0xFE, 0x00, 0xC2, 0xFE, 0x00,
0xCC, 0xFE, 0x00, 0xD5, 0xFD, 0x00, 0xDC, 0xFD, 0x01, 0xE2, 0xFD, 0x02,
0xED, 0xFE, 0x00, 0xF0, 0xFF, 0x00, 0xF3, 0xFE, 0x00, 0xF7, 0xFF, 0x01,
0xFB, 0xFE, 0x00, 0xFD, 0xFD, 0x00, 0xFE, 0xFD, 0x00, 0xFE, 0xFD, 0x00,
0xFE, 0xFD, 0x00, 0xFE, 0xFD, 0x00, 0xFF, 0xFA, 0x01, 0xFE, 0xF5, 0x00,
0xFF, 0xF1, 0x01, 0xFD, 0xEE, 0x00, 0xFD, 0xE8, 0x00, 0xFE, 0xE0, 0x00,
0xFD, 0xD8, 0x00, 0xFE, 0xCF, 0x00, 0xFF, 0xC6, 0x03, 0xFF, 0xBD, 0x03,
0xFD, 0xB3, 0x00, 0xFC, 0xAA, 0x00, 0xFF, 0x9D, 0x01, 0xFE, 0x95, 0x00,
0xFE, 0x8A, 0x00, 0xFE, 0x7E, 0x00, 0xFE, 0x72, 0x01, 0xFD, 0x67, 0x01,
0xFB, 0x5F, 0x00, 0xFE, 0x54, 0x00, 0xFE, 0x4B, 0x00, 0xFD, 0x41, 0x00,
0xFE, 0x37, 0x00, 0xFE, 0x2E, 0x00, 0xFF, 0x25, 0x00, 0xFD, 0x1D, 0x00,
0xFD, 0x16, 0x01, 0xFE, 0x12, 0x02, 0xFF, 0x0D, 0x00, 0xFF, 0x08, 0x00,
0xFE, 0x04, 0x00, 0xFF, 0x02, 0x02, 0xFE, 0x01, 0x03, 0xFD, 0x00, 0x02
}; };
static const u16 brushes_tmp[PAINT9_N_BRUSHES][PAINT9_BRUSH_SIZE] = { static const u16 brushes_tmp[PAINT9_N_BRUSHES][PAINT9_BRUSH_SIZE] = {
@ -146,10 +119,9 @@ u32 Paint9(void) {
u32 pick_x = paint9_boxes[1].x; u32 pick_x = paint9_boxes[1].x;
u32 pick_y = paint9_boxes[1].y; u32 pick_y = paint9_boxes[1].y;
for (u32 y = 0; y < PAINT9_COLSEL_HEIGHT; y++) { for (u32 y = 0; y < PAINT9_COLSEL_HEIGHT; y++) {
const u8* rgb = color_picker_tmp + (y * BYTES_PER_PIXEL); const u16* color = (u16*)(void*) (color_picker_tmp + (y * BYTES_PER_PIXEL));
color = RGB(rgb[0], rgb[1], rgb[2]);
for (u32 x = 0; x < PAINT9_COLSEL_WIDTH; x++) for (u32 x = 0; x < PAINT9_COLSEL_WIDTH; x++)
DrawPixel(BOT_SCREEN, pick_x + x, pick_y + y, color); DrawPixel(BOT_SCREEN, pick_x + x, pick_y + y, *color);
} }
// draw brushes // draw brushes

1
common/pxi.h
View File

@ -30,6 +30,7 @@
enum { enum {
PXI_LEGACY_MODE = 0, PXI_LEGACY_MODE = 0,
PXI_GET_SHMEM, PXI_GET_SHMEM,
PXI_SET_VMODE,
PXI_I2C_READ, PXI_I2C_READ,
PXI_I2C_WRITE, PXI_I2C_WRITE,