static int graphicsPresent(lua_State *L) { // love.graphics.present()
sf2d_swapbuffers();
return 0;
}
// --------------------------------------------------
ViewState Viewer::startMainLoop(Viewer* viewer)
// --------------------------------------------------
{
viewer->initialize();
u32 kDown, kHeld, kUp;
touchPosition touch;
while(viewer->isRunning() && aptMainLoop())
{
hidScanInput();
kDown = hidKeysDown();
kHeld = hidKeysHeld();
kUp = hidKeysUp();
hidTouchRead(&touch);
sf2d_start_frame(GFX_TOP, GFX_LEFT);
viewer->drawTopScreen();
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
viewer->drawBotScreen();
sf2d_end_frame();
sf2d_swapbuffers();
viewer->updateControls(kDown, kHeld, kUp, &touch);
}
return viewer->state();
}
int main()
{
sf2d_init();
sf2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
consoleInit(GFX_BOTTOM, NULL);
printf("sftd sample\n");
// Font loading
sftd_init();
sftd_font *font = sftd_load_font_mem(airstrike_ttf, airstrike_ttf_size);
while (aptMainLoop()) {
hidScanInput();
if (hidKeysDown() & KEY_START) break;
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sftd_draw_text(font, 10, 10, RGBA8(255, 0, 0, 255), 20, "Font drawing on the top screen!");
sftd_draw_textf(font, 10, 40, RGBA8(0, 255, 0, 255), 20, "FPS %f", sf2d_get_fps());
sf2d_end_frame();
sf2d_swapbuffers();
}
sftd_free_font(font);
sftd_fini();
sf2d_fini();
return 0;
}
//MAIN GAME CONTROL
void game_controller_handle_state(GameController self) {
while (self->flag_external_state == GAME_STATE) {
if (self->enemy->y < 0+self->enemy->radius || self->enemy->y > 240-self->enemy->radius) {
self->enemy->y_velocity = -(self->enemy->y_velocity);
}
if (self->is_paused) { //Paused
game_controller_pause_input(self);
//ZZZ TODO Pause menu interface.
} else if (self->player->lives <= 0) {
//ZZZ TODO Proper fail state
self->flag_external_state = TITLE_SCREEN;
} else { //Game
game_controller_game_input(self);
object_update_game_update(self);
}
/* Draw game current game state */
game_controller_draw_top(self);
game_controller_draw_bottom(self);
sf2d_swapbuffers(); //Called at end of frame rendering.
}
}
//ZZ Quick function to check if drawing is working here.
void test_draw() {
sf2d_start_frame(GFX_TOP, GFX_LEFT); //Left for Standard Vision
sf2d_draw_rectangle(0, 0, 400, 240, RGBA8(0xFF, 0xFF, 0x89, 0xFF)); //Background
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_draw_rectangle(0, 0, 400, 240, RGBA8(0xFF, 0xFF, 0x89, 0xFF)); //Background
sf2d_end_frame();
sf2d_swapbuffers();
}
int main(int argc, char **argv)
{
// Start sf2dlib
sf2d_init();
sf2d_set_clear_color(RGBA8(0xF5, 0xF2, 0xEF, 0xFF));
// Initialize console on top screen
// consoleInit(GFX_TOP, NULL);
printf("Sizeof report:\n");
printf(" > elementNode: %i\n", sizeof(elementNode_s));
printf(" > elementList: %i\n", sizeof(elementList_s));
printf(" %2i | %2i |", strcmp("ab", "aa"), strcmp("ab", "ac"));
printf(" %2i | %2i \n", strcmp("a ", "aA"), strcmp("a ", "aa"));
AlchemyScene scene;
scene.initialize();
// consoleClear();
keystate_s ks;
while(aptMainLoop())
{
hidKeys(&ks);
// Draw the top screen
sf2d_start_frame(GFX_TOP, GFX_LEFT);
scene.drawTopScreen();
sf2d_end_frame();
// Draw the bottom screen
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
scene.drawBottomScreen();
sf2d_end_frame();
// Swap the buffers
sf2d_swapbuffers();
scene.updateInput(ks);
// Exit the loop
if (ks.down & KEY_START) break;
}
scene.destroy();
// Stop sf2dlib
sf2d_fini();
return 0;
}
int lockScreen()
{
lockscreenBg = sf2d_create_texture_mem_RGBA8(lockscreen_img.pixel_data, lockscreen_img.width, lockscreen_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
time_t unixTime = time(NULL);
struct tm* timeStruct = gmtime((const time_t *)&unixTime);
int hours = timeStruct->tm_hour;
int minutes = timeStruct->tm_min;
int day = timeStruct->tm_mday;
sf2d_set_clear_color(RGBA8(0, 0, 0, 0));
while (1)
{
hidScanInput();
u32 kDown = hidKeysDown();
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(background, 0, 0);
sf2d_draw_texture(lockscreenBg, 0, 0);
sftd_draw_textf(roboto, 142, 20, RGBA8(255, 255, 255, 255), 34, "0%2d : %02d", hours, minutes);
sftd_draw_textf(roboto, 140, 80, RGBA8(255, 255, 255, 255), 10, "Monday");
sftd_draw_textf(roboto, 200, 80, RGBA8(255, 255, 255, 255), 10, "%d", day);
sftd_draw_textf(roboto, 220, 80, RGBA8(255, 255, 255, 255), 10, "October");
digitalTime(350, 2);
batteryStatus(316, 2);
cursorController();
sf2d_end_frame();
if ((touch.px >= 160 && touch.px <= 235 && touch.py >= 210 && touch.py <= 240) && (kDown & KEY_A))
{
sf2d_free_texture(lockscreenBg);
return 1;
}
sf2d_swapbuffers();
}
sf2d_free_texture(lockscreenBg);
return 0;
}
void sharedBackupMenu(const titleData dat, FS_Archive arch)
{
menu backupMenu(136, 80, false);
backupMenu.addItem("Export Data");
backupMenu.addItem("Import Data");
backupMenu.addItem("Back");
std::u32string info = tou32(dat.nameSafe) + U" : Shared Extdata";
bool loop = true;
while(loop)
{
hidScanInput();
u32 up = hidKeysUp();
backupMenu.handleInput(up);
if(up & KEY_A)
{
switch(backupMenu.getSelected())
{
case _exp:
createTitleDir(dat, MODE_SHARED);
backupData(dat, arch, MODE_SHARED, false);
break;
case _imp:
restoreData(dat, arch, MODE_SHARED);
break;
case _back:
loop = false;
break;
}
}
else if(up & KEY_B)
break;
sf2d_start_frame(GFX_TOP, GFX_LEFT);
drawTopBar(info);
backupMenu.draw();
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_end_frame();
sf2d_swapbuffers();
}
}
/**
* @brief Lux_NATIVE_Show
*/
void Lux_NATIVE_Show( uint8_t screen )
{
if ( screen > 30 )
{
sf2d_swapbuffers();
}
else
{
gfxScreen_t next_screen = IS_BIT_SET(native_screen_assignment, screen+1) ? GFX_BOTTOM : GFX_TOP;
if ( current_screen != next_screen )
{
sf2d_end_frame();
}
}
}
void _loadingScreen(void* arg)
{
TextureManager* that = (TextureManager*) arg;
sf2d_set_clear_color(RGBA8(0xF8,0xF8,0xF8,0xFF));
sf2d_set_vblank_wait(false);
while (threadMainLoop)
{
sf2d_start_frame(GFX_TOP, GFX_LEFT);
that->drawLoadingTopScreen();
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
that->drawLoadingBottomScreen();
sf2d_end_frame();
sf2d_swapbuffers();
}
sf2d_set_vblank_wait(true);
}
//Draw these lovely circles on the screen.
void circle_controller_draw(CircleController self) {
sf2d_start_frame(GFX_TOP, GFX_LEFT); //Left for Standard Vision
sf2d_draw_rectangle(0, 0, 400, 240, RGBA8(0xFF, 0xFF, 0x89, 0xFF)); //Background
if (DO_DRAW) circle_controller_draw_all_circles(self);
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_draw_rectangle(0, 0, 400, 240, RGBA8(0xFF, 0xEE, 0x89, 0xFF)); //Background
sf2d_draw_fill_circle(self->circle_timer->x, self->circle_timer->y, 4, RGBA8(0xFF, 0xA5, 0xC4, 0xFF));
float fps_percentage = sf2d_get_fps() / 60;
sf2d_draw_rectangle(0, 200, fps_percentage * 320, 10, RGBA8(0x00, 0x00, 0x00, 0xFF));
sf2d_end_frame();
sf2d_swapbuffers();
}
void autoBackup(menu m)
{
showMessage("This can take a few minutes depending on how many titles are selected.");
progressBar autoDump((float)m.getSelectCount(), "Copying saves...");
//Keep track of what's done
float dumpCount = 0;
for(unsigned i = 0; i < m.getSize(); i++)
{
//This is for titles with no save archive ex. Fantasy Life
bool dumped = false;
FS_Archive saveArch;
if(m.optSelected(i) && openSaveArch(&saveArch, sdTitle[i], false))//if it's selected and we can open save archive
{
createTitleDir(sdTitle[i], MODE_SAVE);
backupData(sdTitle[i], saveArch, MODE_SAVE, true);
dumpCount++;
dumped = true;
}
FSUSER_CloseArchive(&saveArch);
FS_Archive extArch;
if(m.optSelected(i) && openExtdata(&extArch, sdTitle[i], false))
{
createTitleDir(sdTitle[i], MODE_EXTDATA);
backupData(sdTitle[i], extArch, MODE_EXTDATA, true);
//check first to make sure we don't count it twice because no save arch
if(!dumped)
dumpCount++;
}
FSUSER_CloseArchive(&extArch);
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
autoDump.draw(i);
sf2d_end_frame();
sf2d_swapbuffers();
}
showMessage("Complete!");
}
static int gfx_target___index(lua_State *L) {
target_userdata *target = luaL_checkudata(L, 1, "LTarget");
const char* name = luaL_checkstring(L, 2);
if (strcmp(name, "texture") == 0) {
texture_userdata *texture;
texture = (texture_userdata*)lua_newuserdata(L, sizeof(*texture));
luaL_getmetatable(L, "LTexture");
lua_setmetatable(L, -2);
texture->texture = &(target->target->texture);
texture->scaleX = 1.0f;
texture->scaleY = 1.0f;
texture->blendColor = 0xffffffff;
return 1;
} else if (strcmp(name, "duck") == 0) {
sf2d_rendertarget *target = sf2d_create_rendertarget(64, 64);
for(int i=0;;i++) {
sf2d_clear_target(target, 0xff000000);
sf2d_start_frame_target(target);
sf2d_draw_fill_circle(i%380, i%200, 10, 0xff0000ff);
sf2d_end_frame();
//sf2d_texture_tile32(&target->texture);
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(&target->texture, 10, 10);
sf2d_end_frame();
sf2d_swapbuffers();
}
} else {
for (u8 i=0;target_methods[i].name;i++) {
if (strcmp(target_methods[i].name, name) == 0) {
lua_pushcfunction(L, target_methods[i].func);
return 1;
}
}
}
lua_pushnil(L);
return 1;
}
void TextureManager::drawStaticLoadingScreen(void)
{
// Set the clear color to a false white.
sf2d_set_clear_color(RGBA8(0xF8,0xF8,0xF8,0xFF));
// Need to be called twice, probably a bug.
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_end_frame();
// Render a blank top screen.
sf2d_start_frame(GFX_TOP, GFX_LEFT);
drawLoadingTopScreen();
sf2d_end_frame();
// Render the loading screen on the bottom screen.
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
drawLoadingBottomScreen();
sf2d_end_frame();
// Swap the buffers
sf2d_swapbuffers();
}
int aboutMenu()
{
aboutBg = sf2d_create_texture_mem_RGBA8(about_img.pixel_data, about_img.width, about_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
highlight = sf2d_create_texture_mem_RGBA8(highlight_img.pixel_data, highlight_img.width, highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
sf2d_set_clear_color(RGBA8(0, 0, 0, 0));
while (aptMainLoop())
{
hidScanInput();
u32 kDown = hidKeysDown();
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(aboutBg, 0, 0);
sftd_draw_textf(roboto, 20, 68, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsAbout[language][0]);
sftd_draw_textf(roboto, 20, 83, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsAbout[language][1]);
sftd_draw_textf(roboto, 20, 116, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsAbout[language][2]);
//sftd_draw_textf(roboto, 20, 132, RGBA8(0, 0, 0, 255), 12, "Model = NULL");
sftd_draw_textf(roboto, 20, 168, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsAbout[language][5]);
//sftd_draw_textf(roboto, 20, 183, RGBA8(0, 0, 0, 255), 12, "NinjaHax version: NULL");
if (touch.px >= 0 && touch.px <= 480 && touch.py >= 58 && touch.py <= 105)
{
sf2d_draw_texture(highlight, 0, 56);
sftd_draw_textf(roboto, 20, 68, RGBA8(0, 0, 0, 255), 12, "Cyanogen3DS Updates");
sftd_draw_textf(roboto, 20, 83, RGBA8(0, 0, 0, 255), 12, "Click for, view or isntall available updates");
}
else if (touch.px >= 0 && touch.px <= 480 && touch.py >= 106 && touch.py <= 157)
{
sf2d_draw_texture(highlight, 0, 105);
sftd_draw_textf(roboto, 20, 116, RGBA8(0, 0, 0, 255), 12, "Cyanogen3DS version: 0.01-20151019-UNOFFICIAL");
sftd_draw_textf(roboto, 20, 132, RGBA8(0, 0, 0, 255), 12, "Model = NULL");
}
digitalTime(350, 2);
batteryStatus(316, 2);
androidQuickSettings();
cursorController();
sf2d_end_frame();
navbarControls(1);
if (kDown & KEY_Y)
powerMenu();
if (kDown & KEY_L)
lockScreen();
if (kDown & KEY_B)
{
sf2d_free_texture(aboutBg);
sf2d_free_texture(highlight);
settingsMenu();
}
if ((touch.px >= 44 && touch.px <= 119 && touch.py >= 201 && touch.py <= 240) && (kDown & KEY_A))
{
sf2d_free_texture(aboutBg);
sf2d_free_texture(highlight);
settingsMenu();
}
else if ((touch.px >= 120 && touch.px <= 195 && touch.py >= 201 && touch.py <= 240) && (kDown & KEY_A))
{
sf2d_free_texture(aboutBg);
sf2d_free_texture(highlight);
home();
}
sf2d_swapbuffers();
}
sf2d_free_texture(aboutBg);
sf2d_free_texture(highlight);
return 0;
}
int settingsMenu()
{
settingsBg = sf2d_create_texture_mem_RGBA8(settings_img.pixel_data, settings_img.width, settings_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
about_highlight = sf2d_create_texture_mem_RGBA8(about_highlight_img.pixel_data, about_highlight_img.width, about_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
display_highlight = sf2d_create_texture_mem_RGBA8(display_highlight_img.pixel_data, display_highlight_img.width, display_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
developeroptions_highlight = sf2d_create_texture_mem_RGBA8(developeroptions_highlight_img.pixel_data, developeroptions_highlight_img.width, developeroptions_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
performance_highlight = sf2d_create_texture_mem_RGBA8(performance_highlight_img.pixel_data, performance_highlight_img.width, performance_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
security_highlight = sf2d_create_texture_mem_RGBA8(security_highlight_img.pixel_data, security_highlight_img.width, security_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
wifi_highlight = sf2d_create_texture_mem_RGBA8(wifi_highlight_img.pixel_data, wifi_highlight_img.width, wifi_highlight_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
sf2d_set_clear_color(RGBA8(0, 0, 0, 0));
while (aptMainLoop())
{
hidScanInput();
u32 kDown = hidKeysDown();
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(settingsBg, 0, 0);
sftd_draw_textf(roboto, 48, 106, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][0]);
sftd_draw_textf(roboto, 48, 153, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][1]);
sftd_draw_textf(roboto, 48, 202, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][2]);
sftd_draw_textf(roboto, 250, 106, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][3]);
sftd_draw_textf(roboto, 250, 153, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][4]);
sftd_draw_textf(roboto, 250, 202, RGBA8(0, 0, 0, 255), 12, "%s", lang_settingsMain[language][5]);
settingsHighlight();
digitalTime(350, 2);
batteryStatus(316, 2);
androidQuickSettings();
cursorController();
sf2d_end_frame();
navbarControls(1);
if (kDown & KEY_Y)
powerMenu();
if (kDown & KEY_L)
lockScreen();
if (kDown & KEY_B)
{
settingsUnload();
appDrawer();
}
if ((touch.px >= 44 && touch.px <= 119 && touch.py >= 201 && touch.py <= 240) && (kDown & KEY_A))
{
settingsUnload();
appDrawer();
}
else if ((touch.px >= 120 && touch.px <= 195 && touch.py >= 201 && touch.py <= 240) && (kDown & KEY_A))
{
settingsUnload();
home();
}
sf2d_swapbuffers();
}
settingsUnload();
return 0;
}
/*
Main function that runs all the stuff
*/
void gui_MainMenuRun(MENU *menu)
{
APT_AppStatus status;
MENUITEM *mi;
done = 0;
while(!done) {
mi = menu->m + menu->itemCur; // pointer to highlite menu option
while((status=aptGetStatus()) != APP_RUNNING) {
if(status == APP_SUSPENDING)
{
aptReturnToMenu();
}
else if(status == APP_PREPARE_SLEEPMODE)
{
aptSignalReadyForSleep();
aptWaitStatusEvent();
}
else if (status == APP_SLEEPMODE) {
}
else if (status == APP_EXITING) {
return;
}
}
hidScanInput();
u32 keydown = hidKeysDown();
if (keydown & KEY_A)
if(mi->itemOnA != NULL) {
// gui_ClearScreen();
(*mi->itemOnA)();
}
// B - exit or back to previous menu
if (keydown & KEY_B)
return;
// UP - arrow down
if (keydown & KEY_UP)
if(--menu->itemCur < 0) menu->itemCur = menu->itemNum - 1;
// DOWN - arrow up
if (keydown & KEY_DOWN)
if(++menu->itemCur == menu->itemNum) menu->itemCur = 0;
// LEFT - decrease parameter value
if (keydown & KEY_LEFT) {
if(mi->itemPar != NULL && *mi->itemPar > 0) *mi->itemPar -= 1;
}
// RIGHT - increase parameter value
if (keydown & KEY_RIGHT) {
if(mi->itemPar != NULL && *mi->itemPar < mi->itemParMaxValue) *mi->itemPar += 1;
}
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
if(!done) {
ShowMenu(menu); // show menu items
}
sf2d_end_frame();
gui_DrawTopScreen();
sf2d_swapbuffers();
}
}
int load_file(char **wildcards, char *result, bool startup)
{
Handle dirHandle;
FS_DirectoryEntry entry;
char current_dir_name[MAX__PATH];
char prev_dir_name[MAX__PATH];
char current_dir_short[81];
u32 current_dir_length;
u32 total_filenames_allocated;
u32 total_dirnames_allocated;
char **file_list;
char **dir_list;
u32 num_files;
u32 num_dirs;
char *file_name;
u32 file_name_length;
u32 ext_pos = -1;
s32 return_value = 1;
u32 current_file_selection;
u32 current_file_scroll_value;
u32 current_dir_selection;
u32 current_dir_scroll_value;
u32 current_file_in_scroll;
u32 current_dir_in_scroll;
u32 current_file_number, current_dir_number;
u32 current_column = 0;
u32 repeat;
u32 i;
strcpy(current_dir_name, config_roms_path);
strcpy(prev_dir_name, current_dir_name);
while(return_value == 1) {
current_file_selection = 0;
current_file_scroll_value = 0;
current_dir_selection = 0;
current_dir_scroll_value = 0;
current_file_in_scroll = 0;
current_dir_in_scroll = 0;
total_filenames_allocated = 32;
total_dirnames_allocated = 32;
file_list = (char **)malloc(sizeof(char *) * 32);
dir_list = (char **)malloc(sizeof(char *) * 32);
memset(file_list, 0, sizeof(char *) * 32);
memset(dir_list, 0, sizeof(char *) * 32);
num_files = 0;
num_dirs = 0;
file_name= (char*) malloc(0x105);
FS_Path dirPath = (FS_Path){PATH_ASCII, strlen(current_dir_name)+1, (u8*)current_dir_name};
FSUSER_OpenDirectory(&dirHandle, sdmcArchive, dirPath);
// DEBUG
printf("Current directory: %s\n", current_dir_name);
u32 nread = 0;
do {
if(dirHandle) FSDIR_Read(dirHandle, &nread, 1, &entry);
if(nread) { //(current_file) {
strncpy_u2a(file_name, entry.name, 0x105); //utf-16 to ascii function yoinked from blargSNES
file_name_length = strlen(file_name);
if(((file_name[0] != '.') || (file_name[1] == '.'))) {
//if(S_ISDIR(file_info.st_mode)) { //!!!!!!!!
if(entry.attributes & FS_ATTRIBUTE_DIRECTORY) {
if((strcmp(file_name, "filer") != 0) && (strcmp(file_name, "Nintendo 3DS") != 0) && (strcmp(file_name, "private") != 0)) {
dir_list[num_dirs] = (char *)malloc(file_name_length + 1);
strcpy(dir_list[num_dirs], file_name);
num_dirs++;
}
} else {
// Must match one of the wildcards, also ignore the .
if(file_name_length >= 4) {
if(file_name[file_name_length - 4] == '.') ext_pos = file_name_length - 4;
else if(file_name[file_name_length - 3] == '.') ext_pos = file_name_length - 3;
else ext_pos = 0;
for(i = 0; wildcards[i] != NULL; i++) {
if(!strcasecmp((file_name + ext_pos), wildcards[i])) {
file_list[num_files] = (char *)malloc(file_name_length + 1);
strcpy(file_list[num_files], file_name);
num_files++;
break;
}
}
}
}
}
if(num_files == total_filenames_allocated) {
file_list = (char **)realloc(file_list, sizeof(char *) * total_filenames_allocated * 2);
memset(file_list + total_filenames_allocated, 0, sizeof(char *) * total_filenames_allocated);
total_filenames_allocated *= 2;
}
if(num_dirs == total_dirnames_allocated) {
dir_list = (char **)realloc(dir_list, sizeof(char *) * total_dirnames_allocated * 2);
memset(dir_list + total_dirnames_allocated, 0, sizeof(char *) * total_dirnames_allocated);
total_dirnames_allocated *= 2;
}
}
} while(nread);
qsort((void *)file_list, num_files, sizeof(char *), sort_function);
qsort((void *)dir_list, num_dirs, sizeof(char *), sort_function);
FSDIR_Close(dirHandle);
current_dir_length = strlen(current_dir_name);
if(current_dir_length > 80) {
memcpy(current_dir_short, "...", 3);
memcpy(current_dir_short + 3, current_dir_name + current_dir_length - 77, 77);
current_dir_short[80] = 0;
} else {
memcpy(current_dir_short, current_dir_name, current_dir_length + 1);
}
repeat = 1;
if(num_files == 0) current_column = 1;
if(num_dirs == 0) current_column = 0;
char print_buffer[81];
while(repeat) {
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT); //!!
sftd_draw_text(font, 0, 4, COLOR_ACTIVE_ITEM, 10, current_dir_short);
const char strMsg[] = "[A] Select Rom [X] Run BIOS [Y] Dir up [B] Back";
guitextwidth = sftd_get_text_width(font, 10, strMsg);
sftd_draw_text(font, (320 - guitextwidth) / 2, 225, COLOR_HELP_TEXT, 10, strMsg);
for(i = 0, current_file_number = i + current_file_scroll_value; i < FILE_LIST_ROWS; i++, current_file_number++) {
if(current_file_number < num_files) {
strncpy(print_buffer,file_list[current_file_number], 30); //38);
print_buffer[30] = 0; //38] = 0;
if((current_file_number == current_file_selection) && (current_column == 0)) {
sftd_draw_text(font, FILE_LIST_POSITION, ((i + 2) * 10), COLOR_ACTIVE_ITEM, 10, print_buffer);
} else {
sftd_draw_text(font, FILE_LIST_POSITION, ((i + 2) * 10), COLOR_INACTIVE_ITEM, 10, print_buffer);
}
}
}
for(i = 0, current_dir_number = i + current_dir_scroll_value; i < FILE_LIST_ROWS; i++, current_dir_number++) {
if(current_dir_number < num_dirs) {
strncpy(print_buffer,dir_list[current_dir_number], 8); //13);
print_buffer[9] = 0; //14] = 0;
if((current_dir_number == current_dir_selection) && (current_column == 1)) {
sftd_draw_text(font, DIR_LIST_POSITION, ((i + 2) * 10), COLOR_ACTIVE_ITEM, 10, print_buffer);
} else {
sftd_draw_text(font, DIR_LIST_POSITION, ((i + 2) * 10), COLOR_INACTIVE_ITEM, 10, print_buffer);
}
}
}
// Catch input
// change to read key state later
if (aptGetStatus() == APP_PREPARE_SLEEPMODE) {
aptSignalReadyForSleep();
aptWaitStatusEvent();
} else if (aptGetStatus() == APP_SUSPENDING) {
aptReturnToMenu();
}
hidScanInput();
u32 keydown = hidKeysDown();
if (keydown & KEY_A) {
if(current_column == 1) {
if(num_dirs != 0) {
repeat = 0;
strcpy(prev_dir_name, current_dir_name);
if (strlen(current_dir_name)>1) strcat(current_dir_name, "/");
strcat(current_dir_name, dir_list[current_dir_selection]);
}
} else {
if(num_files != 0) {
repeat = 0;
return_value = 0;
//strcpy(result, file_list[current_file_selection]);
sprintf(result, "%s/%s", current_dir_name, file_list[current_file_selection]);
break;
}
}
}
if (keydown & KEY_Y) {
repeat = 0;
char* findpath = strrchr(current_dir_name,'/');
if(findpath > current_dir_name)
findpath[0] = '\0';
else
findpath[1] = '\0';
}
if (keydown & KEY_B ) {
return_value = -1;
repeat = 0;
break;
}
if (keydown & KEY_X ) {
return_value = 1;
repeat = 0;
break;
}
if (keydown & KEY_UP) {
if(current_column == 0) {
if(current_file_selection) {
current_file_selection--;
if(current_file_in_scroll == 0) {
//clear_screen(COLOR_BG);
current_file_scroll_value--;
} else {
current_file_in_scroll--;
}
}
} else {
if(current_dir_selection) {
current_dir_selection--;
if(current_dir_in_scroll == 0) {
//clear_screen(COLOR_BG);
current_dir_scroll_value--;
} else {
current_dir_in_scroll--;
}
}
}
}
if (keydown & KEY_DOWN) {
if(current_column == 0) {
if(current_file_selection < (num_files - 1)) {
current_file_selection++;
if(current_file_in_scroll == (FILE_LIST_ROWS - 1)) {
//clear_screen(COLOR_BG);
current_file_scroll_value++;
} else {
current_file_in_scroll++;
}
}
} else {
if(current_dir_selection < (num_dirs - 1)) {
current_dir_selection++;
if(current_dir_in_scroll == (FILE_LIST_ROWS - 1)) {
//clear_screen(COLOR_BG);
current_dir_scroll_value++;
} else {
current_dir_in_scroll++;
}
}
}
}
if (keydown & KEY_L) {
if(current_column == 0) {
if(current_file_selection>FILE_LIST_ROWS) {
current_file_selection-=FILE_LIST_ROWS;
current_file_scroll_value -= FILE_LIST_ROWS;
if (current_file_in_scroll>current_file_selection){
//clear_screen(COLOR_BG);
current_file_scroll_value=0;
current_file_in_scroll=current_file_selection;
}
} else {
current_file_selection=0;
current_file_scroll_value=0;
current_file_in_scroll=0;
}
} else {
if(current_dir_selection) {
current_dir_selection--;
if(current_dir_in_scroll == 0) {
//clear_screen(COLOR_BG);
current_dir_scroll_value--;
} else {
current_dir_in_scroll--;
}
}
}
}
if (keydown & KEY_R) {
if(current_column == 0) {
if(current_file_selection < (num_files - 1 - FILE_LIST_ROWS)) {
current_file_selection+=FILE_LIST_ROWS;
current_file_scroll_value+=FILE_LIST_ROWS;
if (current_file_scroll_value>(num_files - FILE_LIST_ROWS)){
//clear_screen(COLOR_BG);
current_file_scroll_value=num_files - FILE_LIST_ROWS;
current_file_in_scroll= FILE_LIST_ROWS - (num_files - current_file_selection);
}
//clear_screen(COLOR_BG);
} else {
current_file_selection = num_files - 1;
current_file_in_scroll = (num_files<=FILE_LIST_ROWS - 1)?num_files:FILE_LIST_ROWS - 1;
current_file_scroll_value = (num_files > FILE_LIST_ROWS)?num_files - FILE_LIST_ROWS:0;
}
} else {
if(current_dir_selection < (num_dirs - 1)) {
current_dir_selection++;
if(current_dir_in_scroll == (FILE_LIST_ROWS - 1)) {
//clear_screen(COLOR_BG);
current_dir_scroll_value++;
} else {
current_dir_in_scroll++;
}
}
}
}
if (keydown & KEY_LEFT) {
if(current_column == 1) {
if(num_files != 0) current_column = 0;
}
}
if (keydown & KEY_RIGHT) {
if(current_column == 0) {
if(num_dirs != 0) current_column = 1;
}
}
sf2d_end_frame();
gui_DrawTopScreen();
sf2d_swapbuffers();
}
// free pointers
for(i = 0; i < num_files; i++) free(file_list[i]);
free(file_list);
for(i = 0; i < num_dirs; i++) free(dir_list[i]);
free(dir_list);
free(file_name);
}
return return_value;
}
CtrUi::CtrUi(int width, int height) :
BaseUi() {
frame = 0;
fullscreen = false;
trigger_state = false;
sf2d_init();
current_display_mode.width = width;
current_display_mode.height = height;
current_display_mode.bpp = 32;
const DynamicFormat format(
32,
0x000000FF,
0x0000FF00,
0x00FF0000,
0xFF000000,
PF::NoAlpha);
Bitmap::SetFormat(Bitmap::ChooseFormat(format));
main_surface = Bitmap::Create(width, height, true, 32);
main_texture = sf2d_create_texture_mem_RGBA8(main_surface->pixels(),
main_surface->GetWidth(), main_surface->GetHeight(),
TEXFMT_RGBA8, SF2D_PLACE_VRAM);
#ifdef SUPPORT_AUDIO
audio_.reset(new CtrAudio());
#endif
#ifdef NO_DEBUG
// Loading bottom screen keyboard
u8* key_buffer = (u8*)&keyboard_bmp[0x36];
u32 key_buffer_size = keyboard_bmp_size - 0x36;
u8* key_buffer_rgba = (u8*)malloc((key_buffer_size/3)<<2);
int z = 0;
for(int i=0;i<key_buffer_size;i=i+3){
key_buffer_rgba[z+2] = key_buffer[i];
key_buffer_rgba[z+1] = key_buffer[i+1];
key_buffer_rgba[z] = key_buffer[i+2];
key_buffer_rgba[z+3] = 0xFF;
z = z + 4;
}
keyboard_texture = sf2d_create_texture_mem_RGBA8(key_buffer_rgba,
320, 240,
TEXFMT_RGBA8, SF2D_PLACE_RAM);
free(key_buffer_rgba);
// Disabling debug console
devoptab_list[STD_OUT] = &dotab_null;
devoptab_list[STD_ERR] = &dotab_null;
consoleGetDefault()->frameBuffer = NULL;
gfxSetScreenFormat(GFX_BOTTOM,GSP_BGR8_OES);
gfxSetDoubleBuffering(GFX_BOTTOM,true);
// Drawing keyboard once then unloading it
for (int i=0;i<5;i++){ // If we don't print this a couple of time, image is corrupted
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_draw_texture(keyboard_texture, 0, 0);
sf2d_end_frame();
sf2d_swapbuffers();
}
sf2d_free_texture(keyboard_texture);
#endif
}
int main()
{
sf2d_init();
csndInit();
noItem = newItem(ITEM_NULL,0);
currentMenu = MENU_TITLE;
currentSelection = 0;
quitGame = false;
icons = sfil_load_PNG_buffer(icons2_png, SF2D_PLACE_RAM);
font = sfil_load_PNG_buffer(Font_png, SF2D_PLACE_RAM);
//consoleInit(GFX_BOTTOM, NULL);
// printf("Press 'Start' to exit.\n");
loadSound(&snd_playerHurt, "resources/playerhurt.raw");
loadSound(&snd_playerDeath, "resources/playerdeath.raw");
loadSound(&snd_monsterHurt, "resources/monsterhurt.raw");
loadSound(&snd_test, "resources/test.raw");
loadSound(&snd_pickup, "resources/pickup.raw");
loadSound(&snd_bossdeath, "resources/bossdeath.raw");
loadSound(&snd_craft, "resources/craft.raw");
int i;
for(i = 0;i < 5;++i){
minimap[i] = sf2d_create_texture(128,128,TEXFMT_RGBA8,SF2D_PLACE_RAM);
sf2d_texture_tile32(minimap[i]);
}
sf2d_set_vblank_wait(true);
sf2d_set_clear_color(0xFF);
/* Default inputs */
k_up.input = KEY_DUP | KEY_CPAD_UP | KEY_CSTICK_UP;
k_down.input = KEY_DDOWN | KEY_CPAD_DOWN | KEY_CSTICK_DOWN;
k_left.input = KEY_DLEFT | KEY_CPAD_LEFT | KEY_CSTICK_LEFT;
k_right.input = KEY_DRIGHT | KEY_CPAD_RIGHT | KEY_CSTICK_RIGHT;
k_attack.input = KEY_A | KEY_B | KEY_L | KEY_ZR;
k_menu.input = KEY_X | KEY_Y | KEY_R | KEY_ZL;
k_pause.input = KEY_START;
k_accept.input = KEY_A;
k_decline.input = KEY_B;
k_delete.input = KEY_X;
FILE * file;
/* If btnSave exists, then use that. */
if ((file = fopen("btnSave.bin", "rb"))){
fread(&k_up.input, sizeof(int), 1, file);
fread(&k_down.input, sizeof(int), 1, file);
fread(&k_left.input, sizeof(int), 1, file);
fread(&k_right.input, sizeof(int), 1, file);
fread(&k_attack.input, sizeof(int), 1, file);
fread(&k_menu.input, sizeof(int), 1, file);
fread(&k_pause.input, sizeof(int), 1, file);
fread(&k_accept.input, sizeof(int), 1, file);
fread(&k_decline.input, sizeof(int), 1, file);
fread(&k_delete.input, sizeof(int), 1, file);
fclose(file);
}
//screenShot = false;
tickCount=0;
initRecipes();
defineTables();
while (aptMainLoop()) {
++tickCount;
hidScanInput();
tickKeys(hidKeysHeld(),hidKeysDown());
//if (quitGame || hidKeysHeld() & KEY_SELECT) break;
if (quitGame) break;
//if (hidKeysDown() & (KEY_L | KEY_R)) screenShot = true;
// else screenShot = false;
if(initGame > 0) setupGame(initGame == 1 ? true : false);
if(currentMenu == 0){
tick();
sprintf(fpsstr, " FPS: %.0f, X:%d, Y:%d, E:%d", sf2d_get_fps(),player.x, player.y,eManager.lastSlot[currentLevel]);
sf2d_start_frame(GFX_TOP, GFX_LEFT);
if(currentLevel == 0){
sf2d_draw_texture_part_scale(minimap[1],(-xscr/3)-256,(-yscr/3)-32,0,0,128,128,12.5,7.5);
sf2d_draw_rectangle(0,0,400,240, 0xDFDFDFAF);
}
offsetX = xscr;offsetY = yscr;
renderBackground(xscr,yscr);
renderEntities(player.x, player.y, &eManager);
renderPlayer();
offsetX = 0;offsetY = 0;
renderItemWithText(player.p.activeItem, 10, 205);
// drawText(debugText,2,208);
drawText(fpsstr,2,225);
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
if(currentLevel == 0 && airWizardHealthDisplay > 0){
sprintf(bossHealthText, "BOSS: %.0f%%", ((float)airWizardHealthDisplay/2000.0)*100);
drawText(bossHealthText,2,225);
}
renderGui();
sf2d_draw_texture(minimap[currentLevel], 192, 112);//y:56
sf2d_end_frame();
} else{
tickMenu(currentMenu);
renderMenu(currentMenu,xscr,yscr);
}
sf2d_swapbuffers();
}
freeRecipes();
sf2d_free_texture(icons);
sf2d_free_texture(minimap[0]);
sf2d_free_texture(minimap[1]);
sf2d_free_texture(minimap[2]);
sf2d_free_texture(minimap[3]);
sf2d_free_texture(minimap[4]);
freeSounds();
csndExit();
sf2d_fini();
return 0;
}
int main()
{
//gfxInitDefault();
sf2d_init();
sf2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
consoleInit(GFX_TOP, NULL);
Result rc = _srvGetServiceHandle(&romfsRealHandle, "fs:USER");
printf("realHandle: %08lX\n", rc);
rc = FSUSER_Initialize(&romfsRealHandle);
printf("initReal: %08lX\n", rc);
// Regular RomFS
u8 zeros[0xC];
memset(zeros, 0, sizeof(zeros));
FS_archive arch = { ARCH_ROMFS, { PATH_EMPTY, 1, (u8*)"" }, 0, 0 };
FS_path path = { PATH_BINARY, sizeof(zeros), zeros };
Handle romFS_file;
rc = FSUSER_OpenFileDirectly(&romfsRealHandle, &romFS_file, arch, path, FS_OPEN_READ, FS_ATTRIBUTE_NONE);
printf("romfsOpen: %08lX\n", rc);
rc = romfsInitFromFile(romFS_file, 0);
u8 *decomp_out;
u8 *darc_decomp;
u32 decomp_size;
u32 darc_decomp_size;
sf2d_texture **mon;
char *mon_garc;
char *box_garc;
if (rc)
{
printf("romfsInit: %08lX\n", rc);
mon_garc = "sdmc:/1";
box_garc = "sdmc:/3_box";
}
else
{
printf("romfs Init Successful!\n");
mon_garc = "romfs:/a/0/9/3"; //Pokemon X/Y
box_garc = "romfs:/a/1/0/4"; //Pokemon X/Y
u32 num_mon = gnumrecords(mon_garc);
if(!num_mon)
{
mon_garc = "sdmc:/1";
num_mon = gnumrecords(mon_garc);
}
u32 box_test = gnumrecords(box_garc);
if(!box_test)
{
box_garc = "sdmc:/3_box";
}
}
u32 num_mon = gnumrecords(mon_garc);
mon = (sf2d_texture**)malloc(num_mon * sizeof(sf2d_texture*));
printf("Loading sprites...");
int i;
for(i = 0; i < 32; i++)
{
gfread(mon_garc, i, &decomp_out, &decomp_size);
sf2d_texture *mon_sprite = create_texture_from_xy7_clim(decomp_out, decomp_size);
mon[i] = mon_sprite;
free(decomp_out);
}
printf("Pokemon sprites read.\n");
gfread(box_garc, 0, &darc_decomp, &darc_decomp_size);
printf("Box sprites read.\n");
u32 box_clim_size;
u32 box_bg_size;
u32 box_name_size;
void *box_clim;
void *box_bg_clim;
void *box_name;
if(darc_decomp)
{
printf("darc_file: %x\n", box_clim);
}
printf("All read!\n");
sf2d_texture *cursor = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "cursol01.bclim");
sf2d_texture *wallpaper = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "box_wp02.bclim");
sf2d_texture *name_box = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "box_name02.bclim");
sf2d_texture *mode01 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode01.bclim");
sf2d_texture *mode02 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode02.bclim");
sf2d_texture *mode03 = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "mode03.bclim");
sf2d_texture *left_button = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "left_button.bclim");
sf2d_texture *right_button = load_texture_from_darc(pokedarc_get_darc(darc_decomp), "right_button.bclim");
float cursor_spot = 0;
u8 cursor_direction = 1;
float cursor_add = 0.4f;
u8 cursor_mon_x = 3;
u8 cursor_mon_y = 2;
// Main loop
while (aptMainLoop())
{
hidScanInput();
if(cursor_direction)
{
cursor_spot += cursor_add;
if(cursor_spot >= 5.0f)
cursor_direction--;
}
else
{
cursor_spot -= cursor_add;
if(cursor_spot <= 0.0f)
cursor_direction++;
}
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
clim_draw_texture(wallpaper, 0, 0);
clim_draw_texture(mode01, 25, 0);
clim_draw_texture(mode02, 25+50+10, 0);
clim_draw_texture(mode03, 25+50+10+50+10, 0);
clim_draw_texture(name_box, 20, 20);
clim_draw_texture(left_button, 5, 20);
clim_draw_texture(right_button, 20+name_box->width, 20);
int x, y;
int i = 1;
for(y = 0; y < 5; y++)
{
for(x = 0; x < 6; x++)
{
clim_draw_texture(mon[i], 10+(x*32), 45+(y*30));
i++;
}
}
clim_draw_texture(cursor, (int)(10-5+((cursor_mon_x + 1) * 32)-cursor_spot), (int)(45+5+((cursor_mon_y - 1) * 30)+cursor_spot));
sf2d_end_frame();
u32 kDown = hidKeysDown();
if (kDown & KEY_START)
break; // break in order to return to hbmenu
sf2d_swapbuffers();
}
sf2d_fini();
romfsExit();
gfxExit();
return 0;
}
/***
Display any drawn pixel.
@function render
*/
static int gfx_render(lua_State *L) {
sf2d_swapbuffers();
return 0;
}
int main()
{
sf2d_init();
sf2d_set_vblank_wait(0);
// this will depend on the level
uint8_t mapWidth = 4;
uint8_t mapHeight = 3;
uint16_t mapDim = mapWidth*mapHeight;
uint8_t map_u[mapDim];
uint16_t mapLength = generateLevel(map_u, mapWidth, mapHeight, 12);
uint8_t map[mapDim];
memcpy(map, map_u, mapDim);
// get some drawing parameters
uint16_t areaWidth = TWIDTH*2/3;
uint16_t areaHeight = THEIGHT*2/3;
uint16_t recWidth = areaWidth/mapWidth;
uint16_t recHeight = areaHeight/mapHeight;
uint16_t areaTop = (THEIGHT-mapHeight*recHeight)/2;
uint16_t areaLeft = (TWIDTH-mapWidth*recWidth)/2;
uint8_t curX = 0;
uint8_t curY = 0;
uint16_t playerLength = 0;
float colorInterpolation = 0;
u64 oldTime = 0;
u64 keyTime = 0;
while (aptMainLoop()) {
// manage timer according to time passed since last frame
u64 newTime = osGetTime();
keyTime += newTime-oldTime;
oldTime = newTime;
hidScanInput();
if (hidKeysDown() & KEY_START) break;
// move cursor according to input
uint16_t oldCurXY = curY*mapWidth+curX;
curX += mapWidth;
curY += mapHeight;
if (hidKeysDown() & KEY_LEFT) curX--;
if (hidKeysDown() & KEY_RIGHT) curX++;
if (hidKeysDown() & KEY_UP) curY--;
if (hidKeysDown() & KEY_DOWN) curY++;
curX %= mapWidth;
curY %= mapHeight;
uint16_t newCurXY = curY*mapWidth+curX;
if (newCurXY != oldCurXY) {
map[newCurXY]--;
playerLength++;
keyTime=0; // force cursor display now
}
if (map[newCurXY] == 255) {
// reset level
curX = 0;
curY = 0;
playerLength = 0;
memcpy(map, map_u, mapDim);
}
if (playerLength == mapLength) break; // TODO should be "you won"
u32 targetColor = RGBA8(0x00,0xaa,0xaa,255);
float targetInterpolation = (float)playerLength/(float)mapLength;
if (newTime%256==0) colorInterpolation = (colorInterpolation*3+targetInterpolation*1)/4;
u32 darkColor = interpolate(targetColor, greyed(targetColor), colorInterpolation);
u32 liteColor = interpolate(darkColor, 0xffffffff, 1.0f/3.0f); // white is too clear
u32 bgColor = interpolate(darkColor, 0, 0.5f);
sf2d_set_clear_color(bgColor);
sf2d_start_frame(GFX_TOP, GFX_LEFT);
{
// draw tiles
for (uint8_t x=0; x<mapWidth; x++) for (uint8_t y=0; y<mapHeight; y++) {
sf2d_draw_rectangle(x*recWidth+areaLeft, y*recHeight+areaTop, recWidth, recHeight, interpolate(darkColor, liteColor, ((float)map[y*mapWidth+x])/3));
}
// draw cursor
float t = (float)(keyTime%2048)/2048.0f;
uint8_t op = pow(fabs(t-0.5f)*2,4)*255;
sf2d_draw_rectangle(curX*recWidth+areaLeft, curY*recHeight+areaTop, recWidth, recHeight, RGBA8(0,0,0,op));
}
sf2d_end_frame();
sf2d_swapbuffers();
}
sf2d_fini();
return 0;
}
void end() {
sf2d_swapbuffers();
}
int main()
{
sf2d_init();
sf2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
consoleInit(GFX_BOTTOM, NULL);
printf("intraFont test sinusoid\n");
intraFontInit();
intraFont *font = intraFontLoad("/ltn8.pgf", INTRAFONT_CACHE_ASCII);
intraFontSetStyle(font, 1.0f, 0, 0, 0.0f, INTRAFONT_ALIGN_CENTER);
struct Sinusoid {
float angle; // In degrees
float amplitude;
float step;
float speed;
float speed_inc;
char str[64];
} sinus = {0.f,35.f,10.f,0.f,0.007f,"intraFont 0.31 - 2009 by BenHur"};
float x = 0.0f;
float y = 0.0f;
float size = 0.65f;
float tmp_angle;
int i;
u32 held;
while (aptMainLoop()) {
hidScanInput();
held = hidKeysHeld();
if (held & KEY_START) {
break;
} else if (held & KEY_L) {
size += 0.1f;
} else if (held & KEY_R) {
size -= 0.1f;
}
if (held & KEY_UP) {
y -= 3.0f;
} else if (held & KEY_DOWN) {
y += 3.0f;
}
if (held & KEY_RIGHT) {
x += 3.0f;
} else if (held & KEY_LEFT) {
x -= 3.0f;
}
sf2d_start_frame(GFX_TOP, GFX_LEFT);
//sf2d_draw_rectangle(50, 60, 50, 50, RGBA8(0,255,0,255));
intraFontSetStyle(font, size, RGBA8(255,0,0,255), RGBA8(0,255,0,255), 0.0f, INTRAFONT_ALIGN_LEFT);
intraFontPrint(font, x, y, "ola k ase");
// * Draw the sinusoid *
/*float draw_x = x - intraFontMeasureText(font,sinus.str)/2;
// Get the x position of the 1st char
// Increment the speed
if (fabsf(sinus.speed += sinus.speed_inc) > 10.f)
sinus.speed_inc = -sinus.speed_inc;
// Increment the angle
tmp_angle = (sinus.angle += sinus.speed);
if (sinus.angle > 360.f) sinus.angle -= 360.f;
// Draw one by one
for (i = 0; i != strlen(sinus.str); i++, tmp_angle += sinus.step) {
intraFontSetStyle(font, 1.0f, WHITE, BLACK, 45.f*cosf(tmp_angle*M_PI/180.f),
INTRAFONT_ALIGN_LEFT);
draw_x = intraFontPrintEx(font, draw_x, y + sinus.amplitude*sinf(tmp_angle*M_PI/180.f),
sinus.str+i,1);
}*/
sf2d_end_frame();
sf2d_swapbuffers();
}
intraFontUnload(font);
intraFontShutdown();
sf2d_fini();
return 0;
}
void Graphic::swapbuffer() {
sf2d_swapbuffers();
}
void sharedExtManager()
{
menu sharedMenu(128, 72, false);
sharedMenu.addItem("E0000000");
sharedMenu.addItem("F0000001");
sharedMenu.addItem("F0000002");
sharedMenu.addItem("F0000009");
sharedMenu.addItem("F000000B");
sharedMenu.addItem("F000000C");
sharedMenu.addItem("F000000D");
sharedMenu.addItem("F000000E");
sharedMenu.addItem("Back");
std::u32string info = U"Shared ExtData";
bool loop = true;
while(loop)
{
hidScanInput();
u32 up = hidKeysUp();
sharedMenu.handleInput(up);
if(up & KEY_A)
{
FS_Archive shared;
titleData sharedDat;
bool opened = false;
switch(sharedMenu.getSelected())
{
case e0:
opened = openSharedExt(&shared, 0xE0000000);
sharedDat.nameSafe = tou16("E0000000");
break;
case f1:
opened = openSharedExt(&shared, 0xF0000001);
sharedDat.nameSafe = tou16("F0000001");
break;
case f2:
opened = openSharedExt(&shared, 0xF0000002);
sharedDat.nameSafe = tou16("F0000002");
break;
case f9:
opened = openSharedExt(&shared, 0xF0000009);
sharedDat.nameSafe = tou16("F0000009");
break;
case fb:
opened = openSharedExt(&shared, 0xF000000B);
sharedDat.nameSafe = tou16("F000000B");
break;
case fc:
opened = openSharedExt(&shared, 0xF000000C);
sharedDat.nameSafe = tou16("F000000C");
break;
case fd:
opened = openSharedExt(&shared, 0xF000000D);
sharedDat.nameSafe = tou16("F000000D");
break;
case fe:
opened = openSharedExt(&shared, 0xF000000E);
sharedDat.nameSafe = tou16("F0000000E");
break;
case back:
loop = false;
break;
}
if(opened)
{
sharedBackupMenu(sharedDat, shared);
}
FSUSER_CloseArchive(&shared);
}
else if(up & KEY_B)
break;
sf2d_start_frame(GFX_TOP, GFX_LEFT);
drawTopBar(info);
sharedMenu.draw();
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sftd_draw_text_wrap(yashi, 0, 0, RGBA8(255, 255, 255, 255), 12, 320, descs[sharedMenu.getSelected()].c_str());
sf2d_end_frame();
sf2d_swapbuffers();
}
}
int main() {
cfguInit();
CFGU_GetSystemModel(&MODEL_3DS);
FILE * file;
shouldRenderDebug = true;
if ((file = fopen("settings.bin", "r"))) {
fread(&shouldRenderDebug,sizeof(bool),1,file);
fread(&shouldSpeedup,sizeof(bool),1,file);
osSetSpeedupEnable(shouldSpeedup);
fclose(file);
}
sf2d_init();
csndInit();
noItem = newItem(ITEM_NULL, 0);
currentMenu = MENU_TITLE;
currentSelection = 0;
quitGame = false;
icons = sfil_load_PNG_buffer(icons2_png, SF2D_PLACE_RAM);
font = sfil_load_PNG_buffer(Font_png, SF2D_PLACE_RAM);
bottombg = sfil_load_PNG_buffer(bottombg_png, SF2D_PLACE_RAM);
dirtColor[0] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 0));
dirtColor[1] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 1));
dirtColor[2] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 2));
dirtColor[3] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 3));
dirtColor[4] = SWAP_UINT32(sf2d_get_pixel(icons, 16, 4));
loadSound(&snd_playerHurt, "resources/playerhurt.raw");
loadSound(&snd_playerDeath, "resources/playerdeath.raw");
loadSound(&snd_monsterHurt, "resources/monsterhurt.raw");
loadSound(&snd_test, "resources/test.raw");
loadSound(&snd_pickup, "resources/pickup.raw");
loadSound(&snd_bossdeath, "resources/bossdeath.raw");
loadSound(&snd_craft, "resources/craft.raw");
bakeLights();
int i;
for (i = 0; i < 5; ++i) {
minimap[i] = sf2d_create_texture(128, 128, TEXFMT_RGBA8,
SF2D_PLACE_RAM);
sf2d_texture_tile32(minimap[i]);
}
sf2d_set_vblank_wait(true);
sf2d_set_clear_color(0xFF000000);
k_up.input = KEY_DUP | KEY_CPAD_UP | KEY_CSTICK_UP;
k_down.input = KEY_DDOWN | KEY_CPAD_DOWN | KEY_CSTICK_DOWN;
k_left.input = KEY_DLEFT | KEY_CPAD_LEFT | KEY_CSTICK_LEFT;
k_right.input = KEY_DRIGHT | KEY_CPAD_RIGHT | KEY_CSTICK_RIGHT;
k_attack.input = KEY_A | KEY_B | KEY_L | KEY_ZR;
k_menu.input = KEY_X | KEY_Y | KEY_R | KEY_ZL;
k_pause.input = KEY_START;
k_accept.input = KEY_A;
k_decline.input = KEY_B;
k_delete.input = KEY_X;
k_menuNext.input = KEY_R;
k_menuPrev.input = KEY_L;
if ((file = fopen("btnSave.bin", "rb"))) {
fread(&k_up.input, sizeof(int), 1, file);
fread(&k_down.input, sizeof(int), 1, file);
fread(&k_left.input, sizeof(int), 1, file);
fread(&k_right.input, sizeof(int), 1, file);
fread(&k_attack.input, sizeof(int), 1, file);
fread(&k_menu.input, sizeof(int), 1, file);
fread(&k_pause.input, sizeof(int), 1, file);
fread(&k_accept.input, sizeof(int), 1, file);
fread(&k_decline.input, sizeof(int), 1, file);
fread(&k_delete.input, sizeof(int), 1, file);
fread(&k_menuNext.input, sizeof(int), 1, file);
fread(&k_menuPrev.input, sizeof(int), 1, file);
fclose(file);
}
if ((file = fopen("lastTP.bin", "r"))) {
char fnbuf[256];
fgets(fnbuf, 256, file); // get directory to texturepack
loadTexturePack(fnbuf);
fclose(file);
}
tickCount = 0;
initRecipes();
defineTables();
while (aptMainLoop()) {
++tickCount;
hidScanInput();
tickKeys(hidKeysHeld(), hidKeysDown());
if (quitGame) break;
if (initGame > 0) setupGame(initGame == 1 ? true : false);
if (currentMenu == 0) {
tick();
sf2d_start_frame(GFX_TOP, GFX_LEFT);
offsetX = xscr;
offsetY = yscr;
sf2d_draw_rectangle(0, 0, 400, 240, 0xFF0C0C0C); //RGBA8(12, 12, 12, 255)); //You might think "real" black would be better, but it actually looks better that way
renderLightsToStencil();
renderBackground(xscr, yscr);
renderEntities(player.x, player.y, &eManager);
renderPlayer();
resetStencilStuff();
offsetX = 0;
offsetY = 0;
if(shouldRenderDebug){
sprintf(fpsstr, " FPS: %.0f, X:%d, Y:%d, E:%d", sf2d_get_fps(), player.x, player.y, eManager.lastSlot[currentLevel]);
drawText(fpsstr, 2, 225);
}
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
if(!shouldRenderMap){
sf2d_draw_texture(bottombg, 0, 0);
renderGui();
} else {
renderZoomedMap();
}
sf2d_end_frame();
} else {
tickMenu(currentMenu);
renderMenu(currentMenu, xscr, yscr);
}
sf2d_swapbuffers();
}
freeRecipes();
freeLightBakes();
sf2d_free_texture(icons);
sf2d_free_texture(minimap[0]);
sf2d_free_texture(minimap[1]);
sf2d_free_texture(minimap[2]);
sf2d_free_texture(minimap[3]);
sf2d_free_texture(minimap[4]);
freeSounds();
csndExit();
cfguExit();
sf2d_fini();
return 0;
}
int main()
{
// Set the random seed based on the time
srand(time(NULL));
sf2d_init();
sf2d_set_clear_color(RGBA8(0x40, 0x40, 0x40, 0xFF));
sf2d_texture *tex1 = sf2d_create_texture_mem_RGBA8(dice_img.pixel_data, dice_img.width, dice_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
sf2d_texture *tex2 = sf2d_create_texture_mem_RGBA8(citra_img.pixel_data, citra_img.width, citra_img.height, TEXFMT_RGBA8, SF2D_PLACE_RAM);
float rad = 0.0f;
u16 touch_x = 320/2;
u16 touch_y = 240/2;
touchPosition touch;
circlePosition circle;
u32 held;
while (aptMainLoop()) {
hidScanInput();
hidCircleRead(&circle);
held = hidKeysHeld();
if (held & KEY_START) {
break;
} else if (held & KEY_TOUCH) {
hidTouchRead(&touch);
touch_x = touch.px;
touch_y = touch.py;
} else if (held & (KEY_L | KEY_R)) {
sf2d_set_clear_color(RGBA8(rand()%255, rand()%255, rand()%255, 255));
}
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_rectangle_rotate(260, 20, 40, 40, RGBA8(0xFF, 0xFF, 0x00, 0xFF), -2.0f*rad);
sf2d_draw_rectangle(20, 60, 40, 40, RGBA8(0xFF, 0x00, 0x00, 0xFF));
sf2d_draw_rectangle(5, 5, 30, 30, RGBA8(0x00, 0xFF, 0xFF, 0xFF));
sf2d_draw_texture_rotate(tex1, 400/2 + circle.dx, 240/2 - circle.dy, rad);
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_draw_rectangle_rotate(190, 160, 70, 60, RGBA8(0xFF, 0xFF, 0xFF, 0xFF), 3.0f*rad);
sf2d_draw_rectangle(30, 100, 40, 60, RGBA8(0xFF, 0x00, 0xFF, 0xFF));
sf2d_draw_texture_rotate(tex2, touch_x, touch_y, -rad);
sf2d_draw_rectangle(160-15 + cosf(rad)*50.0f, 120-15 + sinf(rad)*50.0f, 30, 30, RGBA8(0x00, 0xFF, 0xFF, 0xFF));
sf2d_draw_fill_circle(40, 40, 35, RGBA8(0x00, 0xFF, 0x00, 0xFF));
sf2d_end_frame();
rad += 0.2f;
sf2d_swapbuffers();
}
sf2d_free_texture(tex1);
sf2d_free_texture(tex2);
sf2d_fini();
return 0;
}
int main()
{
touchPosition touch;
sf2d_init();
sftd_init();
sftd_font *text = sftd_load_font_mem(Roboto_ttf, Roboto_ttf_size);
sftd_font *title = sftd_load_font_mem(RobotoThin_ttf, RobotoThin_ttf_size);
sf2d_texture *logo = sfil_load_PNG_buffer(logo_png, SF2D_PLACE_RAM);
sf2d_texture *record = sfil_load_PNG_buffer(record_png, SF2D_PLACE_RAM);
sf2d_texture *stop = sfil_load_PNG_buffer(stop_png, SF2D_PLACE_RAM);
sf2d_set_clear_color(RGBA8(0xFA, 0xFA, 0xFA, 0xFF));
sharedmem = (u32*)memalign(0x1000, sharedmem_size);
audiobuf = linearAlloc(audiobuf_size);
MIC_Initialize(sharedmem, sharedmem_size, control, 0, 3, 1, 1);//See mic.h.
// Threading stuff
svcCreateEvent(&threadRequest,0);
u32 *threadStack = memalign(32, STACKSIZE);
svcCreateThread(&threadHandle, threadMic, 0, &threadStack[STACKSIZE/4], 0x3f, 0);
while(aptMainLoop())
{
hidScanInput();
hidTouchRead(&touch);
u32 kDown = hidKeysDown();
if (kDown & KEY_START)
break; // break in order to return to hbmenu
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(logo, 60, 70);
sftd_draw_text(title, 177, 80, RGBA8(0, 0, 0, 222), 40, "Audio");
sftd_draw_text(title, 175, 120, RGBA8(0, 0, 0, 222), 40, "Recorder");
sf2d_end_frame();
sf2d_start_frame(GFX_BOTTOM, GFX_LEFT);
sf2d_draw_texture(record, 85, 85);
sf2d_draw_texture(stop, 165, 85);
sf2d_end_frame();
svcSignalEvent(threadRequest);
if(print == 1)
{
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(logo, 60, 70);
sftd_draw_text(title, 177, 80, RGBA8(0, 0, 0, 222), 40, "Audio");
sftd_draw_text(title, 175, 120, RGBA8(0, 0, 0, 222), 40, "Recorder");
sftd_draw_text(text, 130, 209, RGBA8(0, 0, 0, 222), 16, "Recording audio...");
sf2d_end_frame();
}
if(recording == 2)
{
sf2d_start_frame(GFX_TOP, GFX_LEFT);
sf2d_draw_texture(logo, 60, 70);
sftd_draw_text(title, 177, 80, RGBA8(0, 0, 0, 222), 40, "Audio");
sftd_draw_text(title, 175, 120, RGBA8(0, 0, 0, 222), 40, "Recorder");
sftd_draw_text(text, 130, 209, RGBA8(0, 0, 0, 222), 16, "Saving audio...");
sf2d_end_frame();
}
sf2d_swapbuffers();
}
MIC_Shutdown();
sftd_free_font(text);
sftd_free_font(title);
sf2d_free_texture(logo);
sf2d_free_texture(record);
sf2d_free_texture(stop);
// tell thread to exit
threadExit = true;
// signal the thread
svcSignalEvent(threadRequest);
// give it time to exit
svcSleepThread(10000000ULL);
// close handles and free allocated stack
svcCloseHandle(threadRequest);
svcCloseHandle(threadHandle);
free(threadStack);
free(sharedmem);
linearFree(audiobuf);
linearFree(nomute_audiobuf);
sf2d_fini();
sftd_fini();
return 0;
}