Result httpwn_setup(char *serverconfig_localpath) { Result ret = 0; u64 http_sysmodule_titleid = 0x0004013000002902ULL; AM_TitleEntry title_entry; u8 *cert = (u8*)builtin_rootca_der; u32 certsize = builtin_rootca_der_size; u8 *filebuffer; u32 filebuffer_size = 0x100000; u32 statuscode = 0; configctx config; targeturlctx *first_targeturlctx = NULL; FILE *f; memset(&config, 0, sizeof(configctx)); config.first_targeturlctx = &first_targeturlctx; ret = amInit(); if(ret!=0) { printf("Failed to initialize AM: 0x%08x.\n", (unsigned int)ret); if(ret==0xd8e06406) { printf("The AM service is inaccessible. With the *hax payloads this should never happen. This is normal with plain ninjhax v1.x: this app isn't usable from ninjhax v1.x without any further hax.\n"); } return ret; } ret = AM_ListTitles(0, 1, &http_sysmodule_titleid, &title_entry); amExit(); if(ret!=0) { printf("Failed to get the HTTP sysmodule title-version: 0x%08x.\n", (unsigned int)ret); return ret; } http_codebin_buf = NULL; http_codebin_buf32 = NULL; http_codebin_size = 0; ret = loadcodebin(http_sysmodule_titleid, MEDIATYPE_NAND, &http_codebin_buf, &http_codebin_size); if(R_FAILED(ret)) { printf("Failed to load the HTTP sysmodule codebin: 0x%08x.\n", (unsigned int)ret); return ret; } http_codebin_buf32 = (u32*)http_codebin_buf; ret = httpcInit(0x1000); if(ret!=0) { printf("Failed to initialize HTTPC: 0x%08x.\n", (unsigned int)ret); if(ret==0xd8e06406) { printf("The HTTPC service is inaccessible. With the *hax payload this may happen if the process this app is running under doesn't have access to that service. Please try rebooting the system, boot *hax payload, then directly launch the app.\n"); } free(http_codebin_buf); return ret; } filebuffer = malloc(filebuffer_size); if(filebuffer==NULL) { printf("Failed to allocate the config filebuffer.\n"); ret = -2; httpcExit(); free(http_codebin_buf); return ret; } memset(filebuffer, 0, filebuffer_size); printf("Downloading config...\n"); ret = download_config("https://yls8.mtheall.com/ctr-httpwn/config.php", cert, certsize, filebuffer, filebuffer_size-1, &statuscode); if(ret!=0) { printf("Config downloading failed: 0x%08x.\n", (unsigned int)ret); if(statuscode==500) { printf("HTTP status-code 500 was returned, server reply:\n%s\n", (char*)filebuffer); } f = fopen(serverconfig_localpath, "rb"); if(f) { printf("Use the cached server_config from SD instead?\nPress the A button to continue, B to abort.\n"); while(1) { gspWaitForVBlank(); hidScanInput(); if(hidKeysDown() & KEY_A)break; if(hidKeysDown() & KEY_B) { fclose(f); httpcExit(); free(http_codebin_buf); return ret; } } memset(filebuffer, 0, filebuffer_size); fread(filebuffer, 1, filebuffer_size-1, f); fclose(f); } else { httpcExit(); free(http_codebin_buf); return ret; } } else { unlink(serverconfig_localpath); f = fopen(serverconfig_localpath, "wb"); if(f) { fwrite(filebuffer, 1, strlen((char*)filebuffer), f); fclose(f); } } ret = config_parse(&config, (char*)filebuffer); if(ret==0) { if(title_entry.version != 13318) { printf("The installed HTTP sysmodule version(v%u) is not supported.", title_entry.version); if(config.incompatsysver_message[0])printf(" %s", config.incompatsysver_message); printf("\n"); httpcExit(); free(http_codebin_buf); free(filebuffer); return -1; } if(display_config_message(&config, "Message from the server:")) { httpcExit(); free(http_codebin_buf); free(filebuffer); return 0; } } if(ret==0) { f = fopen("user_config.xml", "rb"); if(f) { printf("Loading+parsing user_config.xml since it exists on SD...\n"); memset(filebuffer, 0, filebuffer_size); fread(filebuffer, 1, filebuffer_size-1, f); fclose(f); ret = config_parse(&config, (char*)filebuffer); if(ret==0) { if(display_config_message(&config, "Message from the user_config:")) { httpcExit(); free(http_codebin_buf); free(filebuffer); return 0; } } } } if(ret!=0) { printf("Config parsing failed: 0x%08x.\n", (unsigned int)ret); httpcExit(); free(http_codebin_buf); free(filebuffer); return ret; } f = fopen("user_nim_rootcertchain_rootca.der", "rb"); if(f) { printf("Loading user_nim_rootcertchain_rootca.der since it exists on SD, which will be used instead of the built-in ctr-httpwn cert...\n"); memset(filebuffer, 0, filebuffer_size); certsize = fread(filebuffer, 1, filebuffer_size, f); fclose(f); cert = filebuffer; } printf("Preparing the haxx...\n"); ret = http_haxx("http://localhost/", cert, certsize, first_targeturlctx);//URL doesn't matter much since this won't actually be requested over the network. config_freemem(&config); httpcExit(); free(http_codebin_buf); free(filebuffer); if(ret!=0) { printf("Haxx setup failed: 0x%08x.\n", (unsigned int)ret); return ret; } return ret; }
//--------------------------------------------------------------------------- int main(int argc, char** argv) { touchPosition lastTouch; int frame=0,lp_frame=0; CWebRequest::InitializeClient(); gfxInitDefault(); GPU_Init(NULL); gfxSet3D(false); srand(svcGetSystemTick()); CFBClient::Initialize(); while(aptMainLoop()){ hidScanInput(); u32 press = hidKeysDown(); u32 held = hidKeysHeld(); u32 release = hidKeysUp(); if((press & ~KEY_TOUCH)){ CFBClient::onKeysPressEvent(press,1); hidCircleRead(&lcp); } if((release & ~KEY_TOUCH)){ CFBClient::onKeysUpEvent(press,1); hidCircleRead(&lcp); } if (held & KEY_TOUCH){ hidTouchRead(<); if(!lp_frame){ lastTouch=lt; lp_frame++; } else{ int i=0; if(abs(lt.px-lastTouch.px) <= 5){ if(abs(lt.py-lastTouch.py) <= 5) i = 1; } if(i) lp_frame++; else{ lp_frame = 0; CFBClient::onTouchEvent(<,2); } } if(!frame) CFBClient::onTouchEvent(<,1); frame++; } else{ if(frame) CFBClient::onTouchEvent(<,lp_frame > 120 ? 8 : 4); frame = 0; lp_frame = 0; } CFBClient::main(0); gfxFlushBuffers(); gfxSwapBuffers(); gspWaitForVBlank(); } CFBClient::Destroy(); CWebRequest::DestroyClient(); fsExit(); hidExit(); gfxExit(); aptExit(); srvExit(); return 0; }
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"); bakeLights(); dirtColor[0] = 0xAD9291FF; dirtColor[1] = 0x826D6CFF; dirtColor[2] = 0x666666FF; dirtColor[3] = 0x555555FF; dirtColor[4] = 0x444444FF; 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; //if(currentLevel) sf2d_draw_rectangle(0, 0, 400, 240, 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; 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(); 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(); sf2d_fini(); return 0; }
int main() { Result ret=0; int draw=1; int ready=0; int type=0; gfxInit(GSP_RGB565_OES,GSP_BGR8_OES,false); consoleInit(GFX_BOTTOM, NULL); ret = romfsInit(); if(R_FAILED(ret)) { printf("romfsInit() failed: 0x%08x\n", (unsigned int)ret); ready = -1; } if(ready==0) { inaddr = linearMemAlign(0x1000000, 0x40); outaddr = linearMemAlign(0x100000, 0x40); if(!(inaddr && outaddr)) { ready = -2; printf("Failed to allocate memory.\n"); } } // Main loop while (aptMainLoop()) { gspWaitForVBlank(); hidScanInput(); if(draw && type==0) { consoleClear(); draw = 0; if(ready==0)printf("mvd example\n"); printf("Press START to exit.\n"); if(ready==0) { printf("Press A for color-format-conversion.\n"); printf("Press B for video(no sound).\n"); } } u32 kDown = hidKeysDown(); if(type) { if(kDown & KEY_A) { type = 0; continue; } } if(type)continue; if (kDown & KEY_START) break; // break in order to return to hbmenu if(ready==0) { type = 0; if (kDown & KEY_A)type = 1; if (kDown & KEY_B)type = 2; if(type) { memset(inaddr, 0, 0x100000); memset(outaddr, 0, 0x100000); if(type==1)mvd_colorconvert(); if(type==2)mvd_video(); draw = 1; printf("Press A to continue.\n"); } } } if(inaddr)linearFree(inaddr); if(outaddr)linearFree(outaddr); if(ready!=-1)romfsExit(); gfxExit(); return 0; }
static bool ctr_frame(void* data, const void* frame, unsigned width, unsigned height, uint64_t frame_count, unsigned pitch, const char* msg) { uint32_t diff; static uint64_t currentTick,lastTick; ctr_video_t *ctr = (ctr_video_t*)data; settings_t *settings = config_get_ptr(); static float fps = 0.0; static int total_frames = 0; static int frames = 0; static struct retro_perf_counter ctrframe_f = {0}; uint32_t state_tmp; touchPosition state_tmp_touch; extern bool select_pressed; if (!width || !height) { gspWaitForEvent(GSPGPU_EVENT_VBlank0, true); return true; } if(!aptMainLoop()) { command_event(CMD_EVENT_QUIT, NULL); return true; } if (select_pressed) { command_event(CMD_EVENT_QUIT, NULL); return true; } state_tmp = hidKeysDown(); hidTouchRead(&state_tmp_touch); if((state_tmp & KEY_TOUCH) && (state_tmp_touch.py < 120)) { Handle lcd_handle; u8 not_2DS; extern PrintConsole* currentConsole; gfxBottomFramebuffers[0] = ctr->lcd_buttom_on ? (u8*)ctr->empty_framebuffer: (u8*)currentConsole->frameBuffer; CFGU_GetModelNintendo2DS(¬_2DS); if(not_2DS && srvGetServiceHandle(&lcd_handle, "gsp::Lcd") >= 0) { u32 *cmdbuf = getThreadCommandBuffer(); cmdbuf[0] = ctr->lcd_buttom_on? 0x00120040: 0x00110040; cmdbuf[1] = 2; svcSendSyncRequest(lcd_handle); svcCloseHandle(lcd_handle); } ctr->lcd_buttom_on = !ctr->lcd_buttom_on; } svcWaitSynchronization(gspEvents[GSPGPU_EVENT_P3D], 20000000); svcClearEvent(gspEvents[GSPGPU_EVENT_P3D]); svcWaitSynchronization(gspEvents[GSPGPU_EVENT_PPF], 20000000); svcClearEvent(gspEvents[GSPGPU_EVENT_PPF]); frames++; if (ctr->vsync) svcWaitSynchronization(gspEvents[GSPGPU_EVENT_VBlank0], U64_MAX); svcClearEvent(gspEvents[GSPGPU_EVENT_VBlank0]); currentTick = svcGetSystemTick(); diff = currentTick - lastTick; if(diff > CTR_CPU_TICKS_PER_SECOND) { fps = (float)frames * ((float) CTR_CPU_TICKS_PER_SECOND / (float) diff); lastTick = currentTick; frames = 0; } //#define CTR_INSPECT_MEMORY_USAGE #ifdef CTR_INSPECT_MEMORY_USAGE uint32_t ctr_get_stack_usage(void); void ctr_linear_get_stats(void); extern u32 __linear_heap_size; extern u32 __heap_size; MemInfo mem_info; PageInfo page_info; u32 query_addr = 0x08000000; printf(PRINTFPOS(0,0)); while (query_addr < 0x40000000) { svcQueryMemory(&mem_info, &page_info, query_addr); printf("0x%08X --> 0x%08X (0x%08X) \n", mem_info.base_addr, mem_info.base_addr + mem_info.size, mem_info.size); query_addr = mem_info.base_addr + mem_info.size; if(query_addr == 0x1F000000) query_addr = 0x30000000; } // static u32* dummy_pointer; // if(total_frames == 500) // dummy_pointer = malloc(0x2000000); // if(total_frames == 1000) // free(dummy_pointer); printf("========================================"); printf("0x%08X 0x%08X 0x%08X\n", __heap_size, gpuCmdBufOffset, (__linear_heap_size - linearSpaceFree())); printf("fps: %8.4f frames: %i (%X)\n", fps, total_frames++, (__linear_heap_size - linearSpaceFree())); printf("========================================"); u32 app_memory = *((u32*)0x1FF80040); u64 mem_used; svcGetSystemInfo(&mem_used, 0, 1); printf("total mem : 0x%08X \n", app_memory); printf("used: 0x%08X free: 0x%08X \n", (u32)mem_used, app_memory - (u32)mem_used); static u32 stack_usage = 0; extern u32 __stack_bottom; if(!(total_frames & 0x3F)) stack_usage = ctr_get_stack_usage(); printf("stack total:0x%08X used: 0x%08X\n", 0x10000000 - __stack_bottom, stack_usage); printf("========================================"); ctr_linear_get_stats(); printf("========================================"); #else printf(PRINTFPOS(29,0)"fps: %8.4f frames: %i\r", fps, total_frames++); #endif fflush(stdout); performance_counter_init(&ctrframe_f, "ctrframe_f"); performance_counter_start(&ctrframe_f); if (ctr->should_resize) ctr_update_viewport(ctr); ctrGuSetMemoryFill(true, (u32*)CTR_TOP_FRAMEBUFFER, 0x00000000, (u32*)(CTR_TOP_FRAMEBUFFER + 2 * CTR_TOP_FRAMEBUFFER_WIDTH * CTR_TOP_FRAMEBUFFER_HEIGHT * sizeof(uint32_t)), 0x201, (u32*)CTR_GPU_DEPTHBUFFER, 0x00000000, (u32*)(CTR_GPU_DEPTHBUFFER + CTR_TOP_FRAMEBUFFER_WIDTH * CTR_TOP_FRAMEBUFFER_HEIGHT * sizeof(uint32_t)), 0x201); GPUCMD_SetBufferOffset(0); if (width > ctr->texture_width) width = ctr->texture_width; if (height > ctr->texture_height) height = ctr->texture_height; if(frame) { if(((((u32)(frame)) >= 0x14000000 && ((u32)(frame)) < 0x40000000)) /* frame in linear memory */ && !((u32)frame & 0x7F) /* 128-byte aligned */ && !(pitch & 0xF) /* 16-byte aligned */ && (pitch > 0x40)) { /* can copy the buffer directly with the GPU */ // GSPGPU_FlushDataCache(frame, pitch * height); ctrGuSetCommandList_First(true,(void*)frame, pitch * height,0,0,0,0); ctrGuCopyImage(true, frame, pitch / (ctr->rgb32? 4: 2), height, ctr->rgb32 ? CTRGU_RGBA8: CTRGU_RGB565, false, ctr->texture_swizzled, ctr->texture_width, ctr->rgb32 ? CTRGU_RGBA8: CTRGU_RGB565, true); } else { int i; uint8_t *dst = (uint8_t*)ctr->texture_linear; const uint8_t *src = frame; for (i = 0; i < height; i++) { memcpy(dst, src, width * (ctr->rgb32? 4: 2)); dst += ctr->texture_width * (ctr->rgb32? 4: 2); src += pitch; } GSPGPU_FlushDataCache(ctr->texture_linear, ctr->texture_width * ctr->texture_height * (ctr->rgb32? 4: 2)); ctrGuCopyImage(false, ctr->texture_linear, ctr->texture_width, ctr->texture_height, ctr->rgb32 ? CTRGU_RGBA8: CTRGU_RGB565, false, ctr->texture_swizzled, ctr->texture_width, ctr->rgb32 ? CTRGU_RGBA8: CTRGU_RGB565, true); } ctr->frame_coords->u0 = 0; ctr->frame_coords->v0 = 0; ctr->frame_coords->u1 = width; ctr->frame_coords->v1 = height; GSPGPU_FlushDataCache(ctr->frame_coords, sizeof(ctr_vertex_t)); ctrGuSetVertexShaderFloatUniform(0, (float*)&ctr->scale_vector, 1); } ctrGuSetTexture(GPU_TEXUNIT0, VIRT_TO_PHYS(ctr->texture_swizzled), ctr->texture_width, ctr->texture_height, (ctr->smooth? GPU_TEXTURE_MAG_FILTER(GPU_LINEAR) | GPU_TEXTURE_MIN_FILTER(GPU_LINEAR) : GPU_TEXTURE_MAG_FILTER(GPU_NEAREST) | GPU_TEXTURE_MIN_FILTER(GPU_NEAREST)) | GPU_TEXTURE_WRAP_S(GPU_CLAMP_TO_EDGE) | GPU_TEXTURE_WRAP_T(GPU_CLAMP_TO_EDGE), ctr->rgb32 ? GPU_RGBA8: GPU_RGB565); ctr_check_3D_slider(ctr); /* ARGB --> RGBA */ if (ctr->rgb32) { GPU_SetTexEnv(0, GPU_TEVSOURCES(GPU_TEXTURE0, GPU_CONSTANT, 0), GPU_TEVSOURCES(GPU_PRIMARY_COLOR, GPU_PRIMARY_COLOR, 0), GPU_TEVOPERANDS(GPU_TEVOP_RGB_SRC_G, 0, 0), GPU_TEVOPERANDS(0, 0, 0), GPU_MODULATE, GPU_MODULATE, 0x0000FF); GPU_SetTexEnv(1, GPU_TEVSOURCES(GPU_TEXTURE0, GPU_CONSTANT, GPU_PREVIOUS), GPU_TEVSOURCES(GPU_PREVIOUS, GPU_PREVIOUS, 0), GPU_TEVOPERANDS(GPU_TEVOP_RGB_SRC_B, 0, 0), GPU_TEVOPERANDS(0, 0, 0), GPU_MULTIPLY_ADD, GPU_MODULATE, 0x00FF00); GPU_SetTexEnv(2, GPU_TEVSOURCES(GPU_TEXTURE0, GPU_CONSTANT, GPU_PREVIOUS), GPU_TEVSOURCES(GPU_PREVIOUS, GPU_PREVIOUS, 0), GPU_TEVOPERANDS(GPU_TEVOP_RGB_SRC_ALPHA, 0, 0), GPU_TEVOPERANDS(0, 0, 0), GPU_MULTIPLY_ADD, GPU_MODULATE, 0xFF0000); } GPU_SetViewport(VIRT_TO_PHYS(CTR_GPU_DEPTHBUFFER), VIRT_TO_PHYS(CTR_TOP_FRAMEBUFFER), 0, 0, CTR_TOP_FRAMEBUFFER_HEIGHT, ctr->video_mode == CTR_VIDEO_MODE_800x240 ? CTR_TOP_FRAMEBUFFER_WIDTH * 2 : CTR_TOP_FRAMEBUFFER_WIDTH); if (ctr->video_mode == CTR_VIDEO_MODE_3D) { if (ctr->menu_texture_enable) { ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(&ctr->frame_coords[1])); GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1); ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(&ctr->frame_coords[2])); } else { ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->frame_coords)); GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1); } GPU_SetViewport(VIRT_TO_PHYS(CTR_GPU_DEPTHBUFFER), VIRT_TO_PHYS(CTR_TOP_FRAMEBUFFER_RIGHT), 0, 0, CTR_TOP_FRAMEBUFFER_HEIGHT, CTR_TOP_FRAMEBUFFER_WIDTH); } else ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->frame_coords)); GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1); /* restore */ if (ctr->rgb32) { GPU_SetTexEnv(0, GPU_TEXTURE0, GPU_TEXTURE0, 0, 0, GPU_REPLACE, GPU_REPLACE, 0); GPU_SetTexEnv(1, GPU_PREVIOUS, GPU_PREVIOUS, 0, 0, 0, 0, 0); GPU_SetTexEnv(2, GPU_PREVIOUS, GPU_PREVIOUS, 0, 0, 0, 0, 0); } if (ctr->menu_texture_enable) { GSPGPU_FlushDataCache(ctr->menu.texture_linear, ctr->menu.texture_width * ctr->menu.texture_height * sizeof(uint16_t)); ctrGuCopyImage(false, ctr->menu.texture_linear, ctr->menu.texture_width, ctr->menu.texture_height, CTRGU_RGBA4444,false, ctr->menu.texture_swizzled, ctr->menu.texture_width, CTRGU_RGBA4444, true); ctrGuSetTexture(GPU_TEXUNIT0, VIRT_TO_PHYS(ctr->menu.texture_swizzled), ctr->menu.texture_width, ctr->menu.texture_height, GPU_TEXTURE_MAG_FILTER(GPU_LINEAR) | GPU_TEXTURE_MIN_FILTER(GPU_LINEAR) | GPU_TEXTURE_WRAP_S(GPU_CLAMP_TO_EDGE) | GPU_TEXTURE_WRAP_T(GPU_CLAMP_TO_EDGE), GPU_RGBA4); ctrGuSetVertexShaderFloatUniform(0, (float*)&ctr->menu.scale_vector, 1); GPU_SetViewport(VIRT_TO_PHYS(CTR_GPU_DEPTHBUFFER), VIRT_TO_PHYS(CTR_TOP_FRAMEBUFFER), 0, 0, CTR_TOP_FRAMEBUFFER_HEIGHT, ctr->video_mode == CTR_VIDEO_MODE_800x240 ? CTR_TOP_FRAMEBUFFER_WIDTH * 2 : CTR_TOP_FRAMEBUFFER_WIDTH); ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->menu.frame_coords)); GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1); if (ctr->video_mode == CTR_VIDEO_MODE_3D) { GPU_SetViewport(VIRT_TO_PHYS(CTR_GPU_DEPTHBUFFER), VIRT_TO_PHYS(CTR_TOP_FRAMEBUFFER_RIGHT), 0, 0, CTR_TOP_FRAMEBUFFER_HEIGHT, CTR_TOP_FRAMEBUFFER_WIDTH); GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1); } } GPU_FinishDrawing(); GPUCMD_Finalize(); ctrGuFlushAndRun(true); ctrGuDisplayTransfer(true, CTR_TOP_FRAMEBUFFER, 240, ctr->video_mode == CTR_VIDEO_MODE_800x240 ? 800 : 400, CTRGU_RGBA8, gfxTopLeftFramebuffers[ctr->current_buffer_top], 240,CTRGU_RGB8, CTRGU_MULTISAMPLE_NONE); if ((ctr->video_mode == CTR_VIDEO_MODE_400x240) || (ctr->video_mode == CTR_VIDEO_MODE_3D)) ctrGuDisplayTransfer(true, CTR_TOP_FRAMEBUFFER_RIGHT, 240, 400, CTRGU_RGBA8, gfxTopRightFramebuffers[ctr->current_buffer_top], 240,CTRGU_RGB8, CTRGU_MULTISAMPLE_NONE); // Swap buffers : ctr->current_buffer_top ^= 1; extern GSPGPU_FramebufferInfo topFramebufferInfo; extern u8* gfxSharedMemory; extern u8 gfxThreadID; topFramebufferInfo.active_framebuf=ctr->current_buffer_top; topFramebufferInfo.framebuf0_vaddr=(u32*)gfxTopLeftFramebuffers[ctr->current_buffer_top]; if(ctr->video_mode == CTR_VIDEO_MODE_800x240) { topFramebufferInfo.framebuf1_vaddr=(u32*)(gfxTopLeftFramebuffers[ctr->current_buffer_top] + 240 * 3); topFramebufferInfo.framebuf_widthbytesize = 240 * 3 * 2; } else { topFramebufferInfo.framebuf1_vaddr=(u32*)gfxTopRightFramebuffers[ctr->current_buffer_top]; topFramebufferInfo.framebuf_widthbytesize = 240 * 3; } topFramebufferInfo.format=(1<<8)|(1<<5)|GSP_BGR8_OES; topFramebufferInfo.framebuf_dispselect=ctr->current_buffer_top; topFramebufferInfo.unk=0x00000000; u8* framebufferInfoHeader=gfxSharedMemory+0x200+gfxThreadID*0x80; GSPGPU_FramebufferInfo* framebufferInfo=(GSPGPU_FramebufferInfo*)&framebufferInfoHeader[0x4]; framebufferInfoHeader[0x0] ^= 1; framebufferInfo[framebufferInfoHeader[0x0]] = topFramebufferInfo; framebufferInfoHeader[0x1]=1; performance_counter_stop(&ctrframe_f); return true; }
int main(int argc, char **argv){ // Initialize services gfxInitDefault(); //Initialize console on top screen. Using NULL as the second argument tells the console library to use the internal console structure as current one consoleInit(GFX_TOP, NULL); int alevel=0, glevel = 0; //print GyroscopeRawToDpsCoefficient float gyroCoef; HIDUSER_GetGyroscopeRawToDpsCoefficient_(&gyroCoef); printf("\x1b[0;0HGyroCoef:%f", gyroCoef); //print GyroscopeLowCalibrateParam u8 Calibrate[20]; HIDUSER_GetGyroscopeLowCalibrateParam(Calibrate); for(int i = 0; i<3; ++i){ printf("\x1b[%d;0HGyroCalibrate(%d):", i+1, i+1); for(int j = 0; j<6; ++j){ printf("%02X ", Calibrate[i*6+j]); } } printf("\x1b[13;0HPad:\n"); printf("A:call EnableGyroscope\n"); printf("B:call DisableGyroscope\n"); printf("X:call EnableAccelerometer\n"); printf("Y:call DisableAccelerometer\n"); Result result=0; while(aptMainLoop()){ hidScanInput(); u32 kDown = hidKeysDown(); if(kDown & KEY_START) break; // break in order to return to hbmenu if(kDown & KEY_A){ ++glevel; result=HIDUSER_EnableGyroscope(); } if(kDown & KEY_B){ --glevel; result = HIDUSER_DisableGyroscope(); } if(kDown & KEY_X){ ++alevel; result = HIDUSER_EnableAccelerometer(); } if(kDown & KEY_Y){ --alevel; result = HIDUSER_DisableAccelerometer(); } //Read gyro data myAngularRate gyro; hidGyroRead((angularRate*)&gyro); printf("\x1b[5;0Hgyro(level=%3d)%6d;%6d;%6d",glevel, gyro.x, gyro.y, gyro.z); //Read raw gyro data gyro = *(myAngularRate*)&hidSharedMem[86+6]; printf("\x1b[6;0Hgyro(raw )%6d;%6d;%6d", gyro.x, gyro.y, gyro.z); //Read accel data accelVector vector; hidAccelRead(&vector); printf("\x1b[7;0Hacce(level=%3d)%6d;%6d;%6d",alevel, vector.x, vector.y, vector.z); //Read raw accel vector = *(accelVector*)&hidSharedMem[66+6]; printf("\x1b[8;0Hacce(raw )%6d;%6d;%6d", vector.x, vector.y, vector.z); //test if gyro and accel events are activated printf("\x1b[9;0Hgyro event: %s", hidTryWaitForEvent(HIDEVENT_Gyro, 10000000) ? "true " : "false"); printf("\x1b[10;0Hacce event: %s", hidTryWaitForEvent(HIDEVENT_Accel, 10000000)?"true ":"false"); //print the last result of enable/disable gyroscope/accelerometer call printf("\x1b[11;0Henable/disable call result=%08lX", result); // Flush and swap framebuffers gfxFlushBuffers(); gfxSwapBuffers(); //Wait for VBlank gspWaitForVBlank(); } // Exit services gfxExit(); return 0; }
int main(int argc, char **argv) { InitPlatform(argc, argv); HsfOpen(&HSF, "puzzle.hsf"); MIPS_R3000 Cpu; GPU Gpu; Cpu.CP1 = &Gpu; MapRegister(&Cpu, (mmr) {GPU_GP0, &Gpu, GpuGp0, empty_ret}); MapRegister(&Cpu, (mmr) {GPU_GP1, &Gpu, GpuGp1, GpuStat}); MapRegister(&Cpu, (mmr) {0x1F802064, &Cpu, std_out_putchar, empty_ret}); MapRegister(&Cpu, (mmr) {0x1F802068, &Cpu, CTRXFileOpen, CTRXFileOpenReturn}); MapRegister(&Cpu, (mmr) {0x1F802070, &Cpu, CTRXFileRead, CTRXFileReadReturn}); MapRegister(&Cpu, (mmr) {0x1F802074, &Cpu, CTRXFileSeek, CTRXFileSeekReturn}); MapRegister(&Cpu, (mmr) {0x1F802078, &Cpu, CTRXFirstFile, CTRXFirstFileReturn}); MapRegister(&Cpu, (mmr) {0x1F8010A0, &Cpu, DMA2Trigger, empty_ret}); MapRegister(&Cpu, (mmr) {JOY_TX_DATA, nullptr, JoyTxWrite, JoyRxRead}); MapRegister(&Cpu, (mmr) {0x1F801070, nullptr, empty_write, CTRXInterruptRegisterRead}); MapRegister(&Cpu, (mmr) {0x1F801070, nullptr, CTRXInterruptRegisterWrite, empty_ret}); FILE *f = fopen("psx_bios.bin", "rb"); fseek(f, 0, SEEK_END); long fsize = ftell(f); fseek(f, 0, SEEK_SET); u8 *BiosBuffer = (u8 *)linearAlloc(fsize + 1); fread(BiosBuffer, fsize, 1, f); fclose(f); for (int i = 0; i < fsize; ++i) { WriteMemByteRaw(&Cpu, RESET_VECTOR + i, BiosBuffer[i]); } linearFree(BiosBuffer); ResetCpu(&Cpu); bool Step = false; int CyclesToRun = 10000; bool EnableDisassembler = false; bool AutoStep = true; u32 IRQ0Steps = 0; while (MainLoopPlatform()) { #ifdef _3DS u32 KeysDown = hidKeysDown(); if (KeysDown & KEY_START) break; #endif if (Step || AutoStep) { StepCpu(&Cpu, CyclesToRun); IRQ0Steps += CyclesToRun; if (IRQ0Steps >= 50000) { C0GenerateException(&Cpu, C0_CAUSE_INT, Cpu.pc - 4); IRQ0Steps = 0; InterruptMask |= 1; } } if (EnableDisassembler) { printf("\x1b[0;0H"); DisassemblerPrintRange(&Cpu, Cpu.pc - (13 * 4), 29, Cpu.pc); } SwapBuffersPlatform(); } HsfClose(&HSF); ExitPlatform(); return 0; }
int main(int argc, char **argv) { Result res; // Initialize services gfxInitDefault(); PrintConsole topScreen; PrintConsole bottomScreen; consoleInit(GFX_TOP, &topScreen); consoleInit(GFX_BOTTOM, &bottomScreen); //Move the cursor to the top left corner of the screen consoleSelect(&topScreen); printf("\x1b[0;0H"); //Print a REALLY crappy poeam with colored text //\x1b[cm set a SGR (Select Graphic Rendition) parameter, where c is the parameter that you want to set //Please refer to http://en.wikipedia.org/wiki/ANSI_escape_code#CSI_codes to see all the possible SGR parameters //As of now ctrulib support only these parameters: //Reset (0), Half bright colors (2), Reverse (7), Text color (30-37) and Background color (40-47) printf("%sA:%s\tDump ticket.db\n", TEXT_GREEN, TEXT_RESET); consoleSelect(&bottomScreen); printf("\x1b[0;0H"); printf("%sPatching service access...%s\n", TEXT_GREEN, TEXT_RESET); saveConstants(); res = patchServices(); if(res) { printf("%sPatching failed!%s\n", TEXT_RED, TEXT_RESET); while(aptMainLoop()) { if(hidKeysDown()) { break; } } } // Main loop while (aptMainLoop() && res == 0) { //Scan all the inputs. This should be done once for each frame hidScanInput(); //hidKeysDown returns information about which buttons have been just pressed (and they weren't in the previous frame) u32 kDown = hidKeysDown(); if (kDown & KEY_A) { dumpTicket(); } // Flush and swap framebuffers gfxFlushBuffers(); gfxSwapBuffers(); //Wait for VBlank gspWaitForVBlank(); } // Exit services gfxExit(); return 0; }
//return true when we're ready to boot something //(TEMP ?) bool updateMenu(menu_s* m) { if(!m)return false; if(!m->numEntries)return false; //controls s8 move=0; circlePosition cstick; touchPosition touch; hidCstickRead(&cstick); hidTouchRead(&touch); cstick.dy=(abs(cstick.dy)<5)?0:cstick.dy; if(hidKeysDown()&KEY_DOWN)move++; if(hidKeysDown()&KEY_UP)move--; if(hidKeysDown()&KEY_RIGHT)move+=4; if(hidKeysDown()&KEY_LEFT)move-=4; u16 oldEntry=m->selectedEntry; if(hidKeysDown()&KEY_TOUCH) { m->touchTimer=0; m->firstTouch=touch; }else if((hidKeysUp()&KEY_TOUCH) && m->touchTimer<30 && abs(m->firstTouch.px-m->previousTouch.px)+abs(m->firstTouch.py-m->previousTouch.py)<12){ menuEntry_s* me=m->entries; int i=0; int p=0; while(me) { int h=(i==m->selectedEntry)?ENTRY_WIDTH_SELECTED:ENTRY_WIDTH; if((240-m->previousTouch.py)>=getEntryLocationPx(m,p)-h && (240-m->previousTouch.py)<getEntryLocationPx(m,p))break; p+=h; me=me->next; i++; } if(m->selectedEntry==i)return true; else m->selectedEntry=i; }else if(hidKeysHeld()&KEY_TOUCH){ //condition to make sure previousTouch is valid cstick.dy+=(touch.py-m->previousTouch.py)*16; m->touchTimer++; } if(move+m->selectedEntry<0)m->selectedEntry=0; else if(move+m->selectedEntry>=m->numEntries)m->selectedEntry=m->numEntries-1; else m->selectedEntry+=move; if(m->selectedEntry!=oldEntry)m->atEquilibrium=false; if(hidKeysDown()&KEY_A)return true; m->previousTouch=touch; //scrolling code const int maxScroll=240-(m->numEntries)*ENTRY_WIDTH; //cf getEntryLocation if(!m->atEquilibrium) { m->scrollTarget=intToFpt(getEntryLocation(m, m->selectedEntry)); if(m->scrollTarget>intToFpt(240-ENTRY_WIDTH) || (m->selectedEntry==0 && m->numEntries>3)) m->scrollVelocity+=(intToFpt(240-ENTRY_WIDTH)-m->scrollTarget)/SCROLLING_SPEED; if(m->scrollTarget<0 || (m->selectedEntry==m->numEntries-1 && m->numEntries>3)) m->scrollVelocity+=(intToFpt(0)-m->scrollTarget)/SCROLLING_SPEED; }else if(m->numEntries>3){ s32 val=-cstick.dy*16; // TODO : make it inversely proportional to numEntries ? if(m->scrollLocation>intToFpt(-maxScroll)) { m->scrollVelocity+=(intToFpt(-maxScroll)-m->scrollLocation)/SCROLLING_SPEED; if(val<0)m->scrollVelocity+=val; }else if(m->scrollLocation<intToFpt(0)){ m->scrollVelocity-=m->scrollLocation/SCROLLING_SPEED; if(val>0)m->scrollVelocity+=val; }else m->scrollVelocity+=val; } m->scrollLocation+=m->scrollVelocity; m->scrollVelocity=(m->scrollVelocity*3)/4; m->scrollBarSize=40; //TEMP : make it adaptive to number of menu entries ? m->scrollBarPos=-fptToInt(m->scrollLocation*(200-m->scrollBarSize))/maxScroll; if(m->scrollBarPos<0) { m->currentScrollBarSize=m->scrollBarSize+m->scrollBarPos; if(m->currentScrollBarSize<10)m->currentScrollBarSize=10; m->scrollBarPos=m->currentScrollBarSize-m->scrollBarSize; }else if(m->scrollBarPos>=200-m->scrollBarSize) { m->currentScrollBarSize=-(m->scrollBarPos-200); if(m->currentScrollBarSize<10)m->currentScrollBarSize=10; debugValues[3]=m->scrollBarPos-200; m->scrollBarPos=200-m->scrollBarSize; }else m->currentScrollBarSize=m->scrollBarSize; if(!m->scrollVelocity)m->atEquilibrium=true; // debugValues[0]=m->scrollLocation; // debugValues[1]=m->scrollTarget; // debugValues[1]=fptToInt(m->scrollLocation); // debugValues[2]=intToFpt(maxScroll); // debugValues[3]=maxScroll; return false; }
int main() { httpcInit(); gfxInitDefault(); gfxSet3D(false); Result ret = filesystemInit(); PrintConsole topConsole, bttmConsole; consoleInit(GFX_TOP, &topConsole); consoleInit(GFX_BOTTOM, &bttmConsole); consoleSelect(&topConsole); consoleClear(); state_t current_state = STATE_NONE; state_t next_state = STATE_INITIAL; static char top_text[2048]; top_text[0] = '\0'; int selected_slot = 0; int selected_iron_version = 1; int firmware_version[firmware_length] = {0, 0, 9, 0, 0}; int firmware_selected_value = 0; static char payload_name[256]; u8* payload_buf = NULL; u32 payload_size = 0; while (aptMainLoop()) { hidScanInput(); if(hidKeysDown() & KEY_START)break; // transition function if(next_state != current_state) { switch(next_state) { case STATE_INITIAL: strcat(top_text, " Welcome to the oot3dhax installer! Please proceedwith caution, as you might lose data if you don't.You may press START at any time to return to menu.\n Press A to continue.\n\n"); break; case STATE_SELECT_SLOT: strcat(top_text, " Please select the savegame slot oot3dhax will be\ninstalled to. D-Pad to select, A to continue.\n"); break; case STATE_SELECT_IRON_VERSION: strcat(top_text, "\n\n\n This is your last chance to cancel.\nOh, what's your favourite version of Ironfall?\n"); break; case STATE_SELECT_FIRMWARE: strcat(top_text, "\n\n\n Please select your console's firmware version.\nOnly select NEW 3DS if you own a New 3DS (XL).\nD-Pad to select, A to continue.\n"); break; case STATE_DOWNLOAD_PAYLOAD: getPayloadName(firmware_version, payload_name); sprintf(top_text, "%s\n\n\n Downloading payload... %s\n", top_text, payload_name); break; case STATE_COMPRESS_PAYLOAD: strcat(top_text, " Processing payload...\n"); break; case STATE_INSTALL_PAYLOAD: strcat(top_text, " Installing payload...\n"); break; case STATE_INSTALLED_PAYLOAD: strcat(top_text, " Done! oot3dhax was successfully installed."); break; case STATE_ERROR: strcat(top_text, " Looks like something went wrong. :(\n"); break; default: break; } current_state = next_state; } consoleSelect(&topConsole); printf("\x1b[0;%dHoot3dhax installer", (50 - 17) / 2); printf("\x1b[1;%dHmostly by smea\n\n\n", (50 - 7) / 2); printf(top_text); // state function switch(current_state) { case STATE_INITIAL: if(hidKeysDown() & KEY_A)next_state = STATE_SELECT_SLOT; break; case STATE_SELECT_SLOT: { if(hidKeysDown() & KEY_UP)selected_slot++; if(hidKeysDown() & KEY_DOWN)selected_slot--; if(hidKeysDown() & KEY_A)next_state = STATE_SELECT_IRON_VERSION; if(selected_slot < 0) selected_slot = 0; if(selected_slot > 2) selected_slot = 2; printf((selected_slot >= 2) ? " \n" : " ^\n"); printf(" Selected slot : %d \n", selected_slot + 1); printf((!selected_slot) ? " \n" : " v\n"); } break; case STATE_SELECT_IRON_VERSION: { if(hidKeysDown() & KEY_UP)selected_iron_version++; if(hidKeysDown() & KEY_DOWN)selected_iron_version--; if(hidKeysDown() & KEY_A)next_state = STATE_SELECT_FIRMWARE; if(selected_iron_version < 0) selected_iron_version = 0; if(selected_iron_version > 1) selected_iron_version = 1; printf((selected_iron_version >= 1) ? " \n" : " ^\n"); printf(" Selected IRONFALL version : 1.%d \n", selected_iron_version); printf((!selected_iron_version) ? " \n" : " v\n"); } break; case STATE_SELECT_FIRMWARE: { if(hidKeysDown() & KEY_LEFT)firmware_selected_value--; if(hidKeysDown() & KEY_RIGHT)firmware_selected_value++; if(firmware_selected_value < 0) firmware_selected_value = 0; if(firmware_selected_value >= firmware_length) firmware_selected_value = firmware_length - 1; if(hidKeysDown() & KEY_UP)firmware_version[firmware_selected_value]++; if(hidKeysDown() & KEY_DOWN)firmware_version[firmware_selected_value]--; if(firmware_version[firmware_selected_value] < 0) firmware_version[firmware_selected_value] = 0; if(firmware_version[firmware_selected_value] >= firmware_num_values[firmware_selected_value]) firmware_version[firmware_selected_value] = firmware_num_values[firmware_selected_value] - 1; if(hidKeysDown() & KEY_A)next_state = STATE_DOWNLOAD_PAYLOAD; int offset = 28 + firmware_format_offsets[firmware_selected_value]; printf((firmware_version[firmware_selected_value] < firmware_num_values[firmware_selected_value] - 1) ? "%*s^%*s" : "%*s-%*s", offset, " ", 50 - offset - 1, " "); printf(" Selected firmware : " "%s %s-%s-%s %s" "\n", firmware_labels[0][firmware_version[0]], firmware_labels[1][firmware_version[1]], firmware_labels[2][firmware_version[2]], firmware_labels[3][firmware_version[3]], firmware_labels[4][firmware_version[4]]); printf((firmware_version[firmware_selected_value] > 0) ? "%*sv%*s" : "%*s-%*s", offset, " ", 50 - offset - 1, " "); } break; case STATE_DOWNLOAD_PAYLOAD: { httpcContext context; static char url[512]; sprintf(url, "http://smealum.github.io/ninjhax2/Pvl9iD2Im5/otherapp/%s.bin", payload_name); Result ret = httpcOpenContext(&context, url, 0); if(ret) { sprintf(status, "Failed to open http context\n Error code : %08X", (unsigned int)ret); next_state = STATE_ERROR; break; } ret = http_download(&context, &payload_buf, &payload_size); if(ret) { sprintf(status, "Failed to download payload\n Error code : %08X", (unsigned int)ret); next_state = STATE_ERROR; break; } next_state = STATE_COMPRESS_PAYLOAD; } break; case STATE_COMPRESS_PAYLOAD: //payload_buf = BLZ_Code(payload_buf, payload_size, (unsigned int*)&payload_size, BLZ_NORMAL); next_state = STATE_INSTALL_PAYLOAD; break; case STATE_INSTALL_PAYLOAD: { static char filename[128]; sprintf(filename, "save0x.bin.%s", firmware_labels[4][firmware_version[4]]); read_payload(filename, save_buffer); sprintf(filename, "/save0%d.bin", selected_slot); Result ret = write_savedata(filename, save_buffer, save_size); if(ret) { sprintf(status, "Failed to install %s.\n Error code : %08X", filename, (unsigned int)ret); next_state = STATE_ERROR; break; } } { Result ret = write_savedata("/payload.bin", payload_buf, payload_size); if(ret) { sprintf(status, "Failed to install payload\n Error code : %08X", (unsigned int)ret); next_state = STATE_ERROR; break; } next_state = STATE_INSTALLED_PAYLOAD; } break; case STATE_INSTALLED_PAYLOAD: next_state = STATE_NONE; break; default: break; } consoleSelect(&bttmConsole); printf("\x1b[0;0H Current status :\n %s\n", status); gspWaitForVBlank(); } filesystemExit(); gfxExit(); httpcExit(); return 0; }
int menu_boot() { time_t start, end, elapsed; int boot_index = config->index; hidScanInput(); u32 k = hidKeysHeld(); if (config->timeout < 0 || k & BIT(config->recovery)) { // disable autoboot timer = false; } else if (config->timeout == 0) { // autoboot if(k) { int i = 0; for(i=0; i<config->count; i++) { if(k & BIT(config->entries[i].key)) { boot_index = i; break; } } } return autoBootFix(boot_index); } time(&start); while (aptMainLoop()) { hidScanInput(); u32 kDown = hidKeysDown(); if (timer) { time(&end); elapsed = end - start; if (elapsed >= config->timeout && config->count > boot_index) { return autoBootFix(boot_index); } } if (kDown & KEY_DOWN) { timer = false; boot_index++; if (boot_index > config->count) boot_index = 0; } if (kDown & KEY_UP) { timer = false; boot_index--; if (boot_index < 0) boot_index = config->count; } if (kDown & KEY_A) { timer = false; if (boot_index == config->count) { if (menu_more() == 0) { break; } } else { if (load(config->entries[boot_index].path, config->entries[boot_index].offset) == 0) { break; } } } if (kDown & KEY_X) { timer = false; if (boot_index != config->count) { if (confirm(3, "Delete boot entry: \"%s\" ?\n", config->entries[boot_index].title)) { configRemoveEntry(boot_index); boot_index--; } } } gfxClear(); if (!timer) { gfxDrawText(GFX_TOP, GFX_LEFT, &fontDefault, "*** Select a boot entry ***", 140, 20); } else { gfxDrawTextf(GFX_TOP, GFX_LEFT, &fontDefault, 100, 20, "*** Booting %s in %i ***", config->entries[boot_index].title, config->timeout - elapsed); } int minX = 16, maxX = 400 - 16; int minY = 32, maxY = 240 - 8; drawRect(GFX_TOP, GFX_LEFT, minX, minY, maxX, maxY, 0xFF, 0xFF, 0xFF); minY += 20; int i; for (i = 0; i < config->count; i++) { if (i >= config->count) break; if (i == boot_index) { gfxDrawRectangle(GFX_TOP, GFX_LEFT, (u8[]) {0xDC, 0xDC, 0xDC}, minX + 4, minY + (16 * i), maxX - 23, 15); gfxDrawTextf(GFX_TOP, GFX_LEFT, &fontSelected, minX + 6, minY + (16 * i), "%s", config->entries[i].title); gfxDrawText(GFX_BOTTOM, GFX_LEFT, &fontDefault, "Informations", minX + 6, 20); gfxDrawTextf(GFX_BOTTOM, GFX_LEFT, &fontDefault, minX + 12, 40, "Name: %s\nPath: %s\nOffset: 0x%lx\n\n\nPress (A) to launch\nPress (X) to remove entry\n", config->entries[i].title, config->entries[i].path, config->entries[i].offset); } else gfxDrawText(GFX_TOP, GFX_LEFT, &fontDefault, config->entries[i].title, minX + 6, minY + (16 * i)); }
int main(int argc, char **argv) { srvInit(); aptInit(); gfxInitDefault(); acInit(); cfguInit(); httpcInit(); ptmuInit(); hidInit(); irrstInit(); aptOpenSession(); Result ret=APT_SetAppCpuTimeLimit(30); aptCloseSession(); fsInit(); ftp_state = false; isTopLCDOn = true; isBottomLCDOn = true; Handle fileHandle; u64 size; u32 bytesRead; int restore; // Check user build and enables kernel access if (nsInit()==0){ CIA_MODE = true; nsExit(); }else CIA_MODE = false; isNinjhax2 = false; if (!hbInit()) khaxInit(); else isNinjhax2 = true; // Select Audio System (csnd:SND preferred) if (csndInit() == 0){ csndAccess = true; csndExit(); }else csndAccess = false; // Init Audio-Device int i = 0; for (i=0;i < 32; i++){ audioChannels[i] = false; if (!isNinjhax2 && (i < 0x08)) audioChannels[i] = true; else if (csndAccess && (i < 0x08)) audioChannels[i] = true; } // Set main script char path[256]; if (argc > 0){ int latest_slash = 0; int i=5; while (argv[0][i] != '\0'){ if (argv[0][i] == '/') latest_slash = i; i++; } strcpy(path,&argv[0][5]); path[latest_slash-5] = 0; strcpy(start_dir,path); strcpy(cur_dir,path); // Set current dir strcat(path,"/index.lua"); }else{ strcpy(start_dir,"/"); strcpy(cur_dir,"/"); // Set current dir for GW Mode strcpy(path,"/index.lua"); } while(aptMainLoop()) { restore=0; char error[2048]; // Load main script FS_Path filePath=fsMakePath(PATH_ASCII, path); FS_Archive script=(FS_Archive){ARCHIVE_SDMC, (FS_Path){PATH_EMPTY, 1, (u8*)""}}; Result ret = FSUSER_OpenFileDirectly(&fileHandle, script, filePath, FS_OPEN_READ, 0x00000000); if (!ret){ FSFILE_GetSize(fileHandle, &size); buffer = (unsigned char*)(malloc((size+1) * sizeof (char))); FSFILE_Read(fileHandle, &bytesRead, 0x0, buffer, size); buffer[size]=0; FSFILE_Close(fileHandle); svcCloseHandle(fileHandle); errMsg = runScript((const char*)buffer, true); free(buffer); }else errMsg = "index.lua file not found."; // Force LCDs power on if ((!isTopLCDOn) || (!isBottomLCDOn)){ gspLcdInit(); if (!isTopLCDOn) GSPLCD_PowerOnBacklight(GSPLCD_SCREEN_TOP); if (!isBottomLCDOn) GSPLCD_PowerOnBacklight(GSPLCD_SCREEN_BOTTOM); gspLcdExit(); isTopLCDOn = true; isBottomLCDOn = true; } // Fake error to force interpreter shutdown if (strstr(errMsg, "lpp_exit_04")) break; if (ftp_state) ftp_exit(); ftp_state = false; int connfd; while (restore==0){ gspWaitForVBlank(); RefreshScreen(); ClearScreen(0); ClearScreen(1); strcpy(error,"Error: "); strcat(error,errMsg); if (ftp_state){ u32 ip=(u32)gethostid(); char ip_address[64]; strcat(error,"\n\nPress A to restart\nPress B to exit\nPress Y to enable FTP server\n\nFTP state: ON\nIP: "); sprintf(ip_address,"%lu.%lu.%lu.%lu", ip & 0xFF, (ip>>8)&0xFF, (ip>>16)&0xFF, (ip>>24)&0xFF); strcat(error,ip_address); strcat(error,"\nPort: 5000"); if(connfd<0)connfd=ftp_getConnection(); else{ int ret=ftp_frame(connfd); if(ret==1) connfd=-1; } }else strcat(error,"\n\nPress A to restart\nPress B to exit\nPress Y to enable FTP server\n\nFTP state: OFF"); DebugOutput(error); hidScanInput(); if(hidKeysDown() & KEY_A){ strcpy(cur_dir,start_dir); restore=1; }else if(hidKeysDown() & KEY_B){ restore=2; }else if(hidKeysDown() & KEY_Y){ if (!ftp_state){ u32 wifiStatus; if ((u32)ACU_GetWifiStatus(&wifiStatus) != 0xE0A09D2E){ if (wifiStatus != 0){ ftp_init(); connfd = -1; ftp_state = true; } } } } gfxFlushBuffers(); gfxSwapBuffers(); } if (ftp_state) ftp_exit(); if (isCSND){ if (csndAccess) csndExit(); else ndspExit(); isCSND = false; } if (restore==2){ break; } }
Result configureTitle(char* cfg_path, u8* region_code, u8* language_code, u8* clock, char** romfs, char** code, u8* nim, int* nimversion) { u8 mediatype = 0; u64 tid = 0; getTitleInformation(&mediatype, &tid); if(!tid)return -1; static char _fn[256]; char* fn = _fn; if(cfg_path) fn = cfg_path; else sprintf(fn, "titles/%08X.txt", (unsigned int)(tid & 0xffffffff)); mkdir("titles", 777); u8 numChoices[] = {sizeof(regions) / sizeof(regions[0]), sizeof(languages) / sizeof(languages[0]), sizeof(yesno) / sizeof(yesno[0]), sizeof(clocks) / sizeof(clocks[0]), sizeof(yesno) / sizeof(yesno[0]), sizeof(yesno) / sizeof(yesno[0]), sizeof(yesno) / sizeof(yesno[0]), 0, 0}; int choice[] = {numChoices[0]-1, numChoices[1]-1, 1, 0, 1, 1, 1, 0, 0}; static char romfs_path[128]; static char code_path[128]; static char name[16]; // grab config name from path int i, j; int n = strlen(fn); for(j=n-1; j>=0; j--) if(fn[j] == '/') break; j++; for(i=j; i<n && fn[i] != '.' && (i-j)<10; i++) name[i-j] = fn[i]; name[i-j] = '\0'; snprintf(romfs_path, 128, "/hans/%s.romfs", name); snprintf(code_path, 128, "/hans/%s.code", name); Result romfsValid = checkRomfs(romfs_path); if(nimversion) *nimversion = 0; hidScanInput(); { FILE* f = fopen(fn, "r"); if(f) { static char l[256]; while(fgets(l, sizeof(l), f)) { if(sscanf(l, "region : %d", &choice[CHOICE_REGION]) != 1) if(sscanf(l, "language : %d", &choice[CHOICE_LANGUAGE]) != 1); if(sscanf(l, "nim_checkupdate : %d", &choice[CHOICE_NIMUPDATE]) != 1); if(nimversion && sscanf(l, "nim_version : %d", nimversion) != 1); if(sscanf(l, "clock : %d", &choice[CHOICE_CLOCK]) != 1); if(sscanf(l, "romfs : %d", &choice[CHOICE_ROMFS]) != 1); if(sscanf(l, "code : %d", &choice[CHOICE_CODE]) != 1); } choice[CHOICE_SAVE] = 0; fclose(f); if(!(hidKeysHeld() & KEY_L))goto end; }else{ u8* smdh_data = loadSmdh(tid, mediatype); if(smdh_data) { choice[CHOICE_REGION] = smdhGetRegionCode(smdh_data); free(smdh_data); } } } consoleClear(); int field = 0; while(1) { hidScanInput(); u32 kDown = hidKeysDown(); if((kDown & KEY_START) || ((kDown & KEY_A) && (field == CHOICE_OK || field == CHOICE_EXIT)))break; if(kDown & KEY_UP)field--; if(kDown & KEY_DOWN)field++; if(field < 0)field = CHOICE_NUM - 1; if(field >= CHOICE_NUM)field = 0; if(kDown & KEY_LEFT)choice[field]--; if(kDown & KEY_RIGHT)choice[field]++; if(choice[field] < 0) choice[field] = numChoices[field] - 1; if(choice[field] >= numChoices[field]) choice[field] = 0; consoleSelect(&topScreen); printf("\x1b[0;0H\n"); printf( " HANS \n"); printf("\n"); printf(field == CHOICE_REGION ? " Region : < %s > \n" : " Region : %s \n", regions[choice[CHOICE_REGION]]); printf(field == CHOICE_LANGUAGE ? " Language : < %s > \n" : " Language : %s \n", languages[choice[CHOICE_LANGUAGE]]); printf(field == CHOICE_NIMUPDATE ? " FW Version Spoof : < %s > \n" : " FW Version Spoof : %s \n", yesno[choice[CHOICE_NIMUPDATE]]); printf(field == CHOICE_CLOCK ? " N3DS CPU clock : < %s > \n" : " N3DS CPU clock : %s \n", clocks[choice[CHOICE_CLOCK]]); printf(field == CHOICE_CODE ? " Code -> SD : < %s > \n" : " Code -> SD : %s \n", yesno[choice[CHOICE_CODE]]); printf(field == CHOICE_ROMFS ? " Romfs -> SD : < %s > \n" : " Romfs -> SD : %s \n", yesno[choice[CHOICE_ROMFS]]); printf(field == CHOICE_SAVE ? " Save configuration : < %s > \n" : " Save configuration : %s \n", yesno[choice[CHOICE_SAVE]]); printf( " \n"); printf( " Current title : %08X%08X \n", (unsigned int)(tid >> 32), (unsigned int)(tid & 0xFFFFFFFF)); if(!choice[CHOICE_CODE]) printf( " Code path : sd:%s \n", code_path); if(!choice[CHOICE_ROMFS]) printf(!romfsValid ? " Romfs path : sd:%s\n" : " Romfs path (INVALID) : sd:%s\n", romfs_path); printf( " "); printf( " "); printf(field == CHOICE_OK ? " > OK \n" : " OK \n"); printf(field == CHOICE_EXIT ? " > EXIT\n" : " EXIT\n"); printf( " \n"); printf( " \n"); consoleSelect(&bottomScreen); printf("\x1b[0;0H\n"); printf("Description :\n"); printf(" %s%*s", descriptions[field], 240 - strlen(descriptions[field]), " "); gfxFlushBuffers(); gfxSwapBuffers(); gspWaitForVBlank(); } if(field == CHOICE_EXIT)return -1; if(choice[CHOICE_REGION] >= numChoices[CHOICE_REGION] - 1) choice[CHOICE_REGION] = -1; if(choice[CHOICE_LANGUAGE] >= numChoices[CHOICE_LANGUAGE] - 1) choice[CHOICE_LANGUAGE] = -1; if(choice[CHOICE_SAVE] == 0) { FILE* f = fopen(fn, "w"); if(f) { fprintf(f, "region : %d\nlanguage : %d\nclock : %d\nromfs : %d\ncode : %d\nnim_checkupdate : %d\n", choice[CHOICE_REGION], choice[CHOICE_LANGUAGE], choice[CHOICE_CLOCK], choice[CHOICE_ROMFS], choice[CHOICE_CODE], choice[CHOICE_NIMUPDATE]); fclose(f); } } end: if(region_code)*region_code = choice[CHOICE_REGION]; if(language_code)*language_code = choice[CHOICE_LANGUAGE]; if(nim)*nim = choice[CHOICE_NIMUPDATE] == 0; if(clock)*clock = choice[CHOICE_CLOCK]; // romfs_path and code_path are static so as long as we're not idiots this is totally fine if(romfs)*romfs = (choice[CHOICE_ROMFS] == 0) ? romfs_path : NULL; if(code)*code = (choice[CHOICE_CODE] == 0) ? code_path : NULL; return 0; }
int main(int argc, char **argv) { //mode //1 = only execute memchunkhax2 //2 = only execute service call //3 = execute memchunkhax2 and service call afterwards //4 = execute all u8 mode = 4; u8 success; const char* service = "am:u"; gfxInitDefault(); consoleInit(GFX_TOP, NULL); if (mode == 1) { // Run the exploit success = execute_memchunkhax2(); printf("Exploit returned: %s\n", success ? "Success!" : "Failure."); } if (mode == 2) { testService(service); } if (mode == 3) { // Run the exploit success = execute_memchunkhax2(); printf("Exploit returned: %s\n", success ? "Success!" : "Failure."); testService(service); } if (mode == 4) { // This one should fail testService(service); // Run the exploit success = execute_memchunkhax2(); printf("Exploit returned: %s\n", success ? "Success!" : "Failure."); // This one hopefully won't testService(service); } printf("Press START to reboot.\n"); printf("Press SELECT to (try to) exit.\n"); u8 debugFirst = 1; while(aptMainLoop()) { hidScanInput(); if (debugFirst == 1) { printf("entered loop"); debugFirst = 0; } if(hidKeysDown() & KEY_SELECT) { break; } if(hidKeysDown() & KEY_START) { //Reboot console aptOpenSession(); APT_HardwareResetAsync(); aptCloseSession(); } gfxFlushBuffers(); gfxSwapBuffers(); gspWaitForVBlank(); } gfxExit(); return 0; }
int main(int argc, char **argv) { int abort=0; FILE *f = NULL; char *serverconfig_localpath = "server_config.xml"; Result ret = 0; // Initialize services gfxInitDefault(); consoleInit(GFX_TOP, NULL); printf("ctr-httpwn %s by yellows8.\n", VERSION); f = fopen(serverconfig_localpath, "rb");//Only run the below block when this file doesn't exist, which normally only happens when this app wasn't run before with the config file being downloaded successfully. if(f) { fclose(f); } else { printf("Please read the documentation before continuing:\nhttps://github.com/yellows8/ctr-httpwn\nPress A to continue, B to abort.\n"); while(1) { gspWaitForVBlank(); hidScanInput(); if(hidKeysDown() & KEY_A)break; if(hidKeysDown() & KEY_B) { abort = 1; break; } } } if(!abort) { ret = httpwn_setup(serverconfig_localpath); if(ret==0)printf("Done.\n"); } if(ret==0xC920181A)printf("This error means the HTTP sysmodule crashed.\n"); if(ret!=0)printf("An error occured. If this is an actual issue not related to user failure, please report this to here if it persists(or comment on an already existing issue if needed), with a screenshot: https://github.com/yellows8/ctr-httpwn/issues\n"); printf("Press the START button to exit.\n"); // Main loop while (aptMainLoop()) { gspWaitForVBlank(); hidScanInput(); u32 kDown = hidKeysDown(); if (kDown & KEY_START) break; // break in order to return to hbmenu } // Exit services gfxExit(); return 0; }
int main() { srvInit(); aptInit(); hidInit(NULL); gfxInitDefault(); resetGame(); int x; while (aptMainLoop()) { hidScanInput(); hidTouchRead(&touch); u32 kDown = hidKeysDown(); //u32 kHeld = hidKeysHeld(); Not used an otherwise you'll get warning during compile, this makes compile more pleasant to look at yea! if (state != 0 && cur_row != 7) { if (secretCode() && state != 3) cheat=1; if (kDown & KEY_TOUCH) { cur_visable=false; } if (kDown & KEY_RIGHT) { cur_field+=1; if (cur_field > 3) cur_field=0; cur_visable=true; } if (kDown & KEY_LEFT) { cur_field-=1; if (cur_field < 0) cur_field=3; cur_visable=true; } if (kDown & KEY_UP) { local_field[cur_field]+=1; if (local_field[cur_field] > col_amount) local_field[cur_field]=1; cur_visable=true; } if (kDown & KEY_DOWN) { local_field[cur_field]-=1; if (local_field[cur_field] < 1) local_field[cur_field]=col_amount; cur_visable=true; } if (kDown & KEY_A) submitTry(); if (touchInBox(touch,231,163,84,44)) submitTry(); if (touchInBox(touch,7,28,71,16)) { local_field[0]+=1; if (local_field[0] > col_amount) local_field[0]=1; } if (touchInBox(touch,85,28,71,16)) { local_field[1]+=1; if (local_field[1] > col_amount) local_field[1]=1; } if (touchInBox(touch,163,28,71,16)) { local_field[2]+=1; if (local_field[2] > col_amount) local_field[2]=1; } if (touchInBox(touch,241,28,71,16)) { local_field[3]+=1; if (local_field[3] > col_amount) local_field[3]=1; } if (touchInBox(touch,7,119,71,16)) { local_field[0]-=1; if (local_field[0] <= 0) local_field[0]=col_amount; } if (touchInBox(touch,85,119,71,16)) { local_field[1]-=1; if (local_field[1] <= 0) local_field[1]=col_amount; } if (touchInBox(touch,163,119,71,16)) { local_field[2]-=1; if (local_field[2] <= 0) local_field[2]=col_amount; } if (touchInBox(touch,241,119,71,16)) { local_field[3]-=1; if (local_field[3] <= 0) local_field[3]=col_amount; } if (state != 2) { for (x=0; x < 4; x++) { full_field[cur_row*4+x]=local_field[x]; } } } else if (state == 0) { if (touchInBox(touch,65,66,98,34)) modeselector=1; if (touchInBox(touch,65,102,98,34)) modeselector=2; if (modeselector != 0) { if (touchInBox(touch,168,65,88,22)) { difficulty=0; startGame(modeselector); } if (touchInBox(touch,168,90,88,22)) { difficulty=1; startGame(modeselector); } if (touchInBox(touch,168,125,88,22)) { difficulty=2; startGame(modeselector); } } } if (touchInBox(touch,0,211,320,30)) { resetGame(); state=0; modeselector=0; } if (touchInBox(touch,0,0,74,21)) break; render(full_field, full_judgement, local_field, cur_field, cur_row, cur_visable, ans, win, cheat, state, modeselector); gfxFlushBuffers(); gfxSwapBuffers(); gspWaitForEvent(GSPEVENT_VBlank0, false); } gfxExit(); hidExit(); aptExit(); srvExit(); return 0; }
int menu_more() { menu_index = 0; while (aptMainLoop()) { hidScanInput(); u32 kDown = hidKeysDown(); if (kDown & KEY_DOWN) { menu_index++; if (menu_index >= menu_count) menu_index = 0; } if (kDown & KEY_UP) { menu_index--; if (menu_index < 0) menu_index = menu_count - 1; } if (kDown & KEY_A) { if (menu_index == 0 && menu_choose() == 0) { return 0; } else if (menu_index == 1 && menu_netloader() == 0) { return 0; } else if (menu_index == 2) { menu_config(); } else if (menu_index == 3) { reboot(); } else if (menu_index == 4) { poweroff(); } } if (kDown & KEY_B) { return -1; } gfxClear(); gfxDrawText(GFX_TOP, GFX_LEFT, &fontDefault, "*** Select an option ***", 140, 20); int minX = 16; int maxX = 400 - 16; int minY = 32; int maxY = 240 - 16; drawRect(GFX_TOP, GFX_LEFT, minX, minY, maxX, maxY, 0xFF, 0xFF, 0xFF); minY += 20; int i; for (i = 0; i < menu_count; i++) { if (i >= menu_count) break; if (i == menu_index) { gfxDrawRectangle(GFX_TOP, GFX_LEFT, (u8[]) { 0xDC, 0xDC, 0xDC }, minX + 4, minY + (16 * i), maxX - 23, 15); gfxDrawText(GFX_TOP, GFX_LEFT, &fontSelected, menu_item[i], minX + 6, minY + (16 * i)); } else gfxDrawText(GFX_TOP, GFX_LEFT, &fontDefault, menu_item[i], minX + 6, minY + (16 * i)); }
//---------------------------------------------------------------------------- int main(int argc, char **argv) { //---------------------------------------------------------------------------- PrintConsole topScreen; ndspWaveBuf waveBuf[2]; gfxInitDefault(); consoleInit(GFX_TOP, &topScreen); consoleSelect(&topScreen); printf("libctru streaming audio\n"); stb_vorbis_info info; int error; vorbisFile = stb_vorbis_open_filename("/mau5.ogg", &error, NULL); info = stb_vorbis_get_info(vorbisFile); Samples = info.sample_rate; u32 *audioBuffer = (u32*)linearAlloc(Samples*sizeof(s16)*2); bool fillBlock = false; ndspInit(); ndspSetOutputMode(NDSP_OUTPUT_STEREO); ndspChnSetInterp(0, NDSP_INTERP_LINEAR); ndspChnSetRate(0, Samples); ndspChnSetFormat(0, NDSP_FORMAT_STEREO_PCM16); float mix[12]; memset(mix, 0, sizeof(mix)); mix[0] = 1.0; mix[1] = 1.0; ndspChnSetMix(0, mix); int note = 4; memset(waveBuf,0,sizeof(waveBuf)); waveBuf[0].data_vaddr = &audioBuffer[0]; waveBuf[0].nsamples = Samples; waveBuf[1].data_vaddr = &audioBuffer[Samples]; waveBuf[1].nsamples = Samples; ndspChnWaveBufAdd(0, &waveBuf[0]); ndspChnWaveBufAdd(0, &waveBuf[1]); printf("Press up/down to change tone\n"); while(aptMainLoop()) { gfxSwapBuffers(); gfxFlushBuffers(); gspWaitForVBlank(); hidScanInput(); u32 kDown = hidKeysDown(); if (kDown & KEY_START) break; // break in order to return to hbmenu if (waveBuf[fillBlock].status == NDSP_WBUF_DONE) { fill_buffer(waveBuf[fillBlock].data_pcm16, waveBuf[fillBlock].nsamples); ndspChnWaveBufAdd(0, &waveBuf[fillBlock]); fillBlock = !fillBlock; } } ndspExit(); linearFree(audioBuffer); gfxExit(); return 0; }
int main() { Handle rsrc; bool failed = true; gfxInitDefault(); consoleInit(GFX_TOP, NULL); printf("\x1b[10;10HFetching DSP component...\x1b[12;10H"); rsrc = envGetHandle("hb:ndsp"); if (!rsrc) { printf("\x1b[31;1mFailed\x1b[0m: Need to run using *hax 2.0+"); } else do { Result rc; u32 len; void* bin; extern u32 fake_heap_end; char* filename = "sdmc:/3ds/dspfirm.cdc"; u32 mapAddr = (fake_heap_end+0xFFF) &~ 0xFFF; rc = svcMapMemoryBlock(rsrc, mapAddr, 0x3, 0x3); if (R_FAILED(rc)) break; len = *(u32*)(mapAddr + 0x104); bin = malloc(len); if (bin) memcpy(bin, (void*)mapAddr, len); svcUnmapMemoryBlock(rsrc, mapAddr); if (!bin) break; FILE* file = fopen(filename, "wb"); if (!file) break; fwrite(bin, 1, len, file); fclose(file); failed = false; printf("\x1b[32;1mDone\x1b[0m: No further steps needed!\n"); free(bin); } while (0); if (rsrc && failed) printf("\x1b[31;1mFailed\x1b[0m: Unknown error. Try again."); printf("\x1b[28;15HPress START to exit."); while (aptMainLoop()) { hidScanInput(); u32 kDown = hidKeysDown(); if (kDown & KEY_START) break; gfxFlushBuffers(); gfxSwapBuffers(); gspWaitForVBlank(); } gfxExit(); return 0; }
int main() { int i, x, y; touchPosition lastTouch; u32 repeatkeys = 0; int repeatstate = 0; int repeatcount = 0; running = 0; pause = 0; exitemu = 0; PPU_Init(); srvInit(); aptInit(); aptOpenSession(); APT_SetAppCpuTimeLimit(NULL, 30); // enables syscore usage aptCloseSession(); gfxInit(); hidInit(NULL); fsInit(); GPU_Init(NULL); gpuCmdSize = 0x40000; gpuCmd = (u32*)linearAlloc(gpuCmdSize*4); GPU_Reset(gxCmdBuf, gpuCmd, gpuCmdSize); shader = SHDR_ParseSHBIN((u32*)blarg_shbin, blarg_shbin_size); GX_SetMemoryFill(gxCmdBuf, (u32*)gpuOut, 0x404040FF, (u32*)&gpuOut[0x2EE00], 0x201, (u32*)gpuDOut, 0x00000000, (u32*)&gpuDOut[0x2EE00], 0x201); gfxSwapBuffersGpu(); UI_SetFramebuffer(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL)); BorderTex = (u32*)linearAlloc(512*256*4); MainScreenTex = (u32*)linearAlloc(512*256*4); SubScreenTex = (u32*)linearAlloc(512*256*4); BrightnessTex = (u8*)linearAlloc(8*256); borderVertices = (float*)linearAlloc(5*3 * 2 * sizeof(float)); screenVertices = (float*)linearAlloc(7*3 * 2 * sizeof(float)); float* fptr = &vertexList[0]; for (i = 0; i < 5*3*2; i++) borderVertices[i] = *fptr++; for (i = 0; i < 7*3*2; i++) screenVertices[i] = *fptr++; sdmcArchive = (FS_archive){0x9, (FS_path){PATH_EMPTY, 1, (u8*)""}}; FSUSER_OpenArchive(NULL, &sdmcArchive); if (!LoadBorder("/blargSnesBorder.bmp")) CopyBitmapToTexture(defaultborder, BorderTex, 400, 240, 0xFF, 0, 64, true); CopyBitmapToTexture(screenfill, PPU_MainBuffer, 256, 224, 0, 16, 64, false); memset(PPU_SubBuffer, 0, 256*256*4); memset(PPU_Brightness, 0xFF, 224); UI_Switch(&UI_ROMMenu); svcCreateEvent(&SPCSync, 0); aptSetupEventHandler(); APP_STATUS status; while((status = aptGetStatus()) != APP_EXITING) { if(status == APP_RUNNING) { svcSignalEvent(SPCSync); hidScanInput(); u32 press = hidKeysDown(); u32 held = hidKeysHeld(); u32 release = hidKeysUp(); GPUCMD_SetBuffer(gpuCmd, gpuCmdSize, 0); RenderTopScreen(); GPUCMD_Finalize(); GPUCMD_Run(gxCmdBuf); if (running) { // emulate CPU_Run(); // runs the SNES for one frame. Handles PPU rendering. // SRAM autosave check // TODO: also save SRAM under certain circumstances (pausing, returning to home menu, etc) framecount++; if (!(framecount & 7)) SNES_SaveSRAM(); } else { // update UI if (held & KEY_TOUCH) { hidTouchRead(&lastTouch); UI_Touch(true, lastTouch.px, lastTouch.py); held &= ~KEY_TOUCH; } else if (release & KEY_TOUCH) { UI_Touch(false, lastTouch.px, lastTouch.py); release &= ~KEY_TOUCH; } if (press) { UI_ButtonPress(press); // key repeat repeatkeys = press & (KEY_UP|KEY_DOWN|KEY_LEFT|KEY_RIGHT); repeatstate = 1; repeatcount = 15; } else if (held == repeatkeys) { repeatcount--; if (!repeatcount) { repeatcount = 7; if (repeatstate == 2) UI_ButtonPress(repeatkeys); else repeatstate = 2; } } } UI_SetFramebuffer(gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL)); UI_Render(); /*GPUCMD_SetBuffer(gpuCmd, gpuCmdSize, 0); RenderTopScreen(); GPUCMD_Finalize(); GPUCMD_Run(gxCmdBuf);*/ // flush the bottomscreen cache while the PICA200 is busy rendering GSPGPU_FlushDataCache(NULL, gfxGetFramebuffer(GFX_BOTTOM, GFX_LEFT, NULL, NULL), 0x38400); // wait for the PICA200 to finish drawing gspWaitForP3D(); // copy new screen textures // SetDisplayTransfer with flags=2 converts linear graphics to the tiled format used for textures GX_SetDisplayTransfer(gxCmdBuf, PPU_MainBuffer, 0x01000200, MainScreenTex, 0x01000200, 0x2); gspWaitForPPF(); GX_SetDisplayTransfer(gxCmdBuf, PPU_SubBuffer, 0x01000200, SubScreenTex, 0x01000200, 0x2); gspWaitForPPF(); // copy brightness. // TODO do better u8* bptr = BrightnessTex; for (i = 0; i < 224;) { u32 pixels = *(u32*)&PPU_Brightness[i]; i += 4; *bptr = (u8)pixels; pixels >>= 8; bptr += 2; *bptr = (u8)pixels; pixels >>= 8; bptr += 6; *bptr = (u8)pixels; pixels >>= 8; bptr += 2; *bptr = (u8)pixels; pixels >>= 8; bptr += 22; } // transfer the final color buffer to the LCD and clear it // we can mostly overlap those two operations GX_SetDisplayTransfer(gxCmdBuf, gpuOut, 0x019001E0, (u32*)gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL), 0x019001E0, 0x01001000); svcSleepThread(20000); GX_SetMemoryFill(gxCmdBuf, gpuOut, 0x404040FF, &gpuOut[0x2EE00], 0x201, gpuDOut, 0x00000000, &gpuDOut[0x2EE00], 0x201); gspWaitForPPF(); gspWaitForPSC0(); gspWaitForEvent(GSPEVENT_VBlank0, false); gfxSwapBuffersGpu(); } else if(status == APP_SUSPENDING)
static void eventThreadFunc(void *arg) { OSystem_3DS *osys = (OSystem_3DS *)g_system; auto eventQueue = (Common::Queue<Common::Event> *)arg; uint32 touchStartTime = osys->getMillis(); touchPosition lastTouch = {0, 0}; bool isRightClick = false; float cursorX = 0; float cursorY = 0; float cursorDeltaX = 0; float cursorDeltaY = 0; int circleDeadzone = 20; int borderSnapZone = 6; Common::Event event; while (!osys->exiting) { do { osys->delayMillis(10); } while (osys->sleeping && !osys->exiting); hidScanInput(); touchPosition touch; circlePosition circle; u32 held = hidKeysHeld(); u32 keysPressed = hidKeysDown(); u32 keysReleased = hidKeysUp(); // C-Pad used to control the cursor hidCircleRead(&circle); if (circle.dx < circleDeadzone && circle.dx > -circleDeadzone) circle.dx = 0; if (circle.dy < circleDeadzone && circle.dy > -circleDeadzone) circle.dy = 0; cursorDeltaX = (0.0002f + config.sensitivity / 100000.f) * circle.dx * abs(circle.dx); cursorDeltaY = (0.0002f + config.sensitivity / 100000.f) * circle.dy * abs(circle.dy); // Touch screen events if (held & KEY_TOUCH) { hidTouchRead(&touch); if (config.snapToBorder) { if (touch.px < borderSnapZone) touch.px = 0; if (touch.px > 319 - borderSnapZone) touch.px = 319; if (touch.py < borderSnapZone) touch.py = 0; if (touch.py > 239 - borderSnapZone) touch.py = 239; } cursorX = touch.px; cursorY = touch.py; osys->transformPoint(touch); osys->warpMouse(touch.px, touch.py); event.mouse.x = touch.px; event.mouse.y = touch.py; if (keysPressed & KEY_TOUCH) { touchStartTime = osys->getMillis(); isRightClick = (held & KEY_X || held & KEY_DUP); if (inputMode == MODE_DRAG) { event.type = isRightClick ? Common::EVENT_RBUTTONDOWN : Common::EVENT_LBUTTONDOWN; pushEventQueue(eventQueue, event); } } else if (touch.px != lastTouch.px || touch.py != lastTouch.py) { event.type = Common::EVENT_MOUSEMOVE; pushEventQueue(eventQueue, event); } lastTouch = touch; } else if (keysReleased & KEY_TOUCH) { event.mouse.x = lastTouch.px; event.mouse.y = lastTouch.py; if (inputMode == MODE_DRAG) { event.type = isRightClick ? Common::EVENT_RBUTTONUP : Common::EVENT_LBUTTONUP; pushEventQueue(eventQueue, event); } else if (osys->getMillis() - touchStartTime < 200) { // Process click in MODE_HOVER event.type = Common::EVENT_MOUSEMOVE; pushEventQueue(eventQueue, event); event.type = isRightClick ? Common::EVENT_RBUTTONDOWN : Common::EVENT_LBUTTONDOWN; pushEventQueue(eventQueue, event); event.type = isRightClick ? Common::EVENT_RBUTTONUP : Common::EVENT_LBUTTONUP; pushEventQueue(eventQueue, event); } } else if (cursorDeltaX != 0 || cursorDeltaY != 0) { cursorX += cursorDeltaX; cursorY -= cursorDeltaY; if (cursorX < 0) cursorX = 0; if (cursorY < 0) cursorY = 0; if (cursorX > 320) cursorX = 320; if (cursorY > 240) cursorY = 240; lastTouch.px = cursorX; lastTouch.py = cursorY; osys->transformPoint(lastTouch); osys->warpMouse(lastTouch.px, lastTouch.py); event.mouse.x = lastTouch.px; event.mouse.y = lastTouch.py; event.type = Common::EVENT_MOUSEMOVE; pushEventQueue(eventQueue, event); } // Button events if (keysPressed & KEY_R) { if (inputMode == MODE_DRAG) { inputMode = MODE_HOVER; osys->displayMessageOnOSD("Hover Mode"); } else { inputMode = MODE_DRAG; osys->displayMessageOnOSD("Drag Mode"); } } if (keysPressed & KEY_A || keysPressed & KEY_DLEFT || keysReleased & KEY_A || keysReleased & KEY_DLEFT) { // SIMULATE LEFT CLICK event.mouse.x = lastTouch.px; event.mouse.y = lastTouch.py; if (keysPressed & KEY_A || keysPressed & KEY_DLEFT) event.type = Common::EVENT_LBUTTONDOWN; else event.type = Common::EVENT_LBUTTONUP; pushEventQueue(eventQueue, event); } if (keysPressed & KEY_X || keysPressed & KEY_DUP || keysReleased & KEY_X || keysReleased & KEY_DUP) { // SIMULATE RIGHT CLICK event.mouse.x = lastTouch.px; event.mouse.y = lastTouch.py; if (keysPressed & KEY_X || keysPressed & KEY_DUP) event.type = Common::EVENT_RBUTTONDOWN; else event.type = Common::EVENT_RBUTTONUP; pushEventQueue(eventQueue, event); } if (keysPressed & KEY_L) { event.type = Common::EVENT_VIRTUAL_KEYBOARD; pushEventQueue(eventQueue, event); } if (keysPressed & KEY_START) { event.type = Common::EVENT_MAINMENU; pushEventQueue(eventQueue, event); } if (keysPressed & KEY_SELECT) { if (!optionMenuOpened) optionMenuOpening = true; } if (keysPressed & KEY_B || keysReleased & KEY_B || keysPressed & KEY_DDOWN || keysReleased & KEY_DDOWN) { if (keysPressed & KEY_B || keysPressed & KEY_DDOWN) event.type = Common::EVENT_KEYDOWN; else event.type = Common::EVENT_KEYUP; event.kbd.keycode = Common::KEYCODE_ESCAPE; event.kbd.ascii = Common::ASCII_ESCAPE; event.kbd.flags = 0; pushEventQueue(eventQueue, event); } // TODO: EVENT_PREDICTIVE_DIALOG // EVENT_SCREEN_CHANGED } }
int drawAlert(char * title, char * body, u8 * image, int numButtons, char buttonTitles[3][32]) { //int ret = alertButtonNone; if (hidKeysDown()&KEY_A) { return alertSelectedButton; } if (hidKeysDown()&KEY_B) { return alertButtonKeyB; } if (hidKeysDown()&KEY_DOWN) { alertSelectedButton++; if (alertSelectedButton >= numButtons) { alertSelectedButton = 0; } } if (hidKeysDown()&KEY_UP) { alertSelectedButton--; if (alertSelectedButton < 0) { alertSelectedButton = numButtons-1; } } MAGFXDrawPanel(GFX_TOP, true); MAGFXDrawPanel(GFX_BOTTOM, false); MAFont font = MAFontRobotoRegular16; int leftOffset = 30; int topOffset = 240 - 50 - font.lineHeight; rgbColour * textCol = titleTextColour(); MADrawText(GFX_TOP, GFX_LEFT, topOffset, leftOffset, title, &font, textCol->r, textCol->g, textCol->b); font = MAFontRobotoRegular10; topOffset -= font.lineHeight * 2; int totalWidthForText = 400; rgbColour * dark = darkTextColour(); MADrawTextWrap(GFX_TOP, GFX_LEFT, topOffset, leftOffset, body, &font, dark->r, dark->g, dark->b, totalWidthForText-(2*leftOffset), 0); //MADrawTextWrap(GFX_TOP, GFX_LEFT, topOffset, leftOffset, body, &font, dark->r, dark->g, dark->b, totalWidthForText, 0); /* WEIRD BUG ALERT! It was discovered that some alerts did not display their body text. In the process of trying to work out what was happening, I created a string containing the number of lines drawn by MADrawTextWrap and drew this on the screen so I could see what was actually happening. When I did this, the body text started appearing as well as the text showing how many lines it had drawn. I then found that it was the process of creating a string and putting something in it which was allowing the text to be drawn. I actually have no idea why this fixes the bug with drawing the body text. It feels like a memory management thing, but I can't figure it out. */ char s[64]; strcpy(s, "5"); int screenHeight = 240; int screenWidth = 320; int buttonGap = 10; int totalHeight = (numButtons*btnRectWidth) + ((numButtons-1)*buttonGap); int diff = screenHeight-totalHeight; int x = screenHeight - (diff/2) - btnRectWidth; int y = (screenWidth/2) - (btnRectHeight/2); touchPosition touch; hidTouchRead(&touch); int touchX = touch.px; int touchY = touch.py; int i; for (i=0; i<numButtons; i++) { button * aButton = malloc(sizeof(button)); btnSetButtonType(aButton, btnButtonTypeRect); strcpy(aButton->longText, buttonTitles[i]); strcpy(aButton->shortText1, ""); strcpy(aButton->shortText2, ""); aButton->x = x; aButton->y = y; aButton->highlighted = (i == alertSelectedButton); aButton->selected = false; x -= (btnRectWidth+buttonGap); btnDrawButton(aButton); if (!touchesAreBlocked && hidKeysDown()&KEY_TOUCH && btnTouchWithin(touchX, touchY, aButton)) { if (i == alertSelectedButton) { return alertSelectedButton; } else { alertSelectedButton = i; } } free(aButton); } return alertButtonNone; }
void mvd_video() { Result ret; size_t video_size, nalunitsize; u32 video_pos=0; u32 cur_nalunit_pos=0, prev_nalunit_pos=0; u32 nalcount=0; u8 *video; u32 flagval=0; FILE *f = NULL; u8* gfxtopadr=NULL; MVDSTD_Config config; u32 prefix_offset; u8 prefix[4] = {0x00, 0x00, 0x00, 0x01}; printf("Loading video...\n"); //This loads the entire video into memory, normally you'd use a library to stream it. f = fopen("romfs:/video.h264", "r"); if(f==NULL) { printf("Faile to open the video in romfs.\n"); return; } video = &inaddr[0x100000]; video_size = fread(video, 1, 0xF00000, f); fclose(f); if(video_size==0 || video_size>=0xF00000) { printf("Failed to read video / video is too large.\n"); return; } ret = mvdstdInit(MVDMODE_VIDEOPROCESSING, MVD_INPUT_H264, MVD_OUTPUT_BGR565, MVD_DEFAULT_WORKBUF_SIZE, NULL); printf("mvdstdInit(): 0x%08x\n", (unsigned int)ret); if(ret!=0)return; printf("Processing 0x%08x-byte video...\n", (unsigned int)video_size); mvdstdGenerateDefaultConfig(&config, 240, 400, 240, 400, NULL, (u32*)outaddr, (u32*)outaddr);//Normally you'd set the input dimensions here to dimensions loaded from the actual video. //Normally you'd use a library to load each NAL-unit, this example just parses the data manually. while(video_pos < video_size+1) { cur_nalunit_pos = video_pos; video_pos++; prefix_offset = 1; if(cur_nalunit_pos<video_size) { /* { if(memcmp(&video[cur_nalunit_pos], &prefix[1], 3)==0 && cur_nalunit_pos==0x2dd) { prefix_offset = 0; } } if(prefix_offset)*/ //else { if(memcmp(&video[cur_nalunit_pos], prefix, 4)) { continue; } else { video_pos++; } } } if(nalcount && prev_nalunit_pos!=cur_nalunit_pos) { nalunitsize = cur_nalunit_pos - prev_nalunit_pos - prefix_offset; if(nalunitsize > 0x100000) { printf("The NAL-unit at offset 0x%08x is too large.\n", (unsigned int)nalunitsize); break; } memcpy(inaddr, &video[prev_nalunit_pos+prefix_offset], nalunitsize); GSPGPU_FlushDataCache(inaddr, nalunitsize); MVDSTD_ProcessNALUnitOut tmpout;//Normally you don't really need to use this. //printf("Processing NAL-unit at offset 0x%08x size 0x%08x...\n", (unsigned int)prev_nalunit_pos, (unsigned int)nalunitsize); ret = mvdstdProcessVideoFrame(inaddr, nalunitsize, flagval, &tmpout); if(!MVD_CHECKNALUPROC_SUCCESS(ret)) { printf("mvdstdProcessVideoFrame() at NAL-unit offset 0x%08x size 0x%08x returned: 0x%08x. remaining_size=0x%08x.\n", (unsigned int)prev_nalunit_pos, (unsigned int)nalunitsize, (unsigned int)ret, (unsigned int)tmpout.remaining_size); break; } if(ret!=MVD_STATUS_PARAMSET && ret!=MVD_STATUS_INCOMPLETEPROCESSING) { gfxtopadr = gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL); config.physaddr_outdata0 = osConvertVirtToPhys(gfxtopadr); //This sets the MVD output to the framebuffer directly. This is to avoid doing the video->framebuffer image rotation on the ARM11. //Normally you'd use a seperate MVD output buffer, then transfer that to the framebuffer(such as with GPU rendering). ret = mvdstdRenderVideoFrame(&config, true); if(ret!=MVD_STATUS_OK) { printf("mvdstdRenderVideoFrame() at NAL-unit offset 0x%08x returned: 0x%08x\n", (unsigned int)prev_nalunit_pos, (unsigned int)ret); break; } hidScanInput(); if(hidKeysDown() & KEY_B)break; //Enable/disable the flag passed to mvdstdProcessVideoFrame(). if(hidKeysDown() & KEY_DOWN) { flagval-= 0x1; printf("0x%08x\n", (unsigned int)flagval); } if(hidKeysDown() & KEY_UP) { flagval+= 0x1; printf("0x%08x\n", (unsigned int)flagval); } //gspWaitForVBlank();//Can't use this under this example without a major slowdown. This is due to this example not doing any buffering for the frames. gfxSwapBuffersGpu(); } } nalcount++; prev_nalunit_pos = cur_nalunit_pos; } mvdstdExit(); }
int main(int argc, char *argv[]) { // char filename[]="/test400x240-mpeg4-witch.mp4"; // char filename[]="/test400x240-witch.mp4"; // char filename[]="/test800x400-witch-900kbps.mp4"; // char filename[]="/test800x400-witch-1pass.mp4"; // char filename[]="/test800x400-witch.mp4"; // char filename[]="/test800x480-witch-mpeg4.mp4"; // char filename[]="/test320x176-karanokyoukai.mp4"; char filename[] = "/test.mp4"; MovieState mvS; initServices(); // Register all formats and codecs av_register_all(); av_log_set_level(AV_LOG_INFO); printf("Press start to open the file\n"); waitForStart(); int ret = setup(&mvS, filename); if (ret) { waitForStartAndExit(); return -1; } printf("Press start to decompress\n"); waitForStart(); // Read frames and save first five frames to disk int i = 0; int frameFinished; u64 timeBeginning, timeEnd; u64 timeBefore, timeAfter; u64 timeDecodeTotal = 0, timeScaleTotal = 0, timeDisplayTotal = 0; timeBefore = osGetTime(); timeBeginning = timeBefore; bool stop = false; while (av_read_frame(mvS.pFormatCtx, &mvS.packet) >= 0 && !stop) { // Is this a packet from the video stream? if (mvS.packet.stream_index == mvS.videoStream) { /********************* * Decode video frame *********************/ int err = avcodec_decode_video2(mvS.pCodecCtx, mvS.pFrame, &frameFinished, &mvS.packet); if (err <= 0)printf("decode error\n"); // Did we get a video frame? if (frameFinished) { err = av_frame_get_decode_error_flags(mvS.pFrame); if (err) { char buf[100]; av_strerror(err, buf, 100); } timeAfter = osGetTime(); timeDecodeTotal += timeAfter - timeBefore; /******************************* * Conversion of decoded frame *******************************/ timeBefore = osGetTime(); colorConvert(&mvS); timeAfter = osGetTime(); /*********************** * Display of the frame ***********************/ timeScaleTotal += timeAfter - timeBefore; timeBefore = osGetTime(); if (mvS.renderGpu) { gpuRenderFrame(&mvS); gpuEndFrame(); } else display(mvS.outFrame); timeAfter = osGetTime(); timeDisplayTotal += timeAfter - timeBefore; ++i;//New frame hidScanInput(); u32 kDown = hidKeysDown(); if (kDown & KEY_START) stop = true; // break in order to return to hbmenu if (i % 50 == 0)printf("frame %d\n", i); timeBefore = osGetTime(); } } // Free the packet that was allocated by av_read_frame av_free_packet(&mvS.packet); } timeEnd = timeBefore; tearup(&mvS); printf("Played %d frames in %f s (%f fps)\n", i, (timeEnd - timeBeginning) / 1000.0, i / ((timeEnd - timeBeginning) / 1000.0)); printf("\tdecode:\t%llu\t%f perframe" "\n\tscale:\t%llu\t%f perframe" "\n\tdisplay:\t%llu\t%f perframe\n", timeDecodeTotal, timeDecodeTotal / (double) i, timeScaleTotal, timeScaleTotal / (double) i, timeDisplayTotal, timeDisplayTotal / (double) i); waitForStartAndExit(); return 0; }
int main() { L = luaL_newstate(); luaL_openlibs(L); luaL_requiref(L, "love", initLove, 1); sf2d_init(); // 2D Drawing lib. sftd_init(); // Text Drawing lib. cfguInit(); ptmuInit(); // consoleInit(GFX_BOTTOM, NULL); sf2d_set_clear_color(RGBA8(0x0, 0x0, 0x0, 0xFF)); // Reset background color. osSetSpeedupEnable(true); // Enables CPU speedup for a free performance boost. // Detect if we are running on a .cia, because if we are // we load from RomFS rather than the SD Card. // TODO: Load RomFS from .3dsx's aswell. Result rc = romfsInit(); romfsExists = (rc) ? false : true; // Change working directory if (romfsExists) { chdir("romfs:/"); } else { char cwd[256]; getcwd(cwd, 256); char newCwd[261]; strcat(newCwd, cwd); strcat(newCwd, "game"); chdir(newCwd); } luaL_dobuffer(L, boot_lua, boot_lua_size, "boot"); // Do some setup Lua side. // If main.lua exists, execute it. // If not then just load the nogame screen. if (fileExists("main.lua")) { if (luaL_dofile(L, "main.lua")) displayError(); } else { if (luaL_dobuffer(L, nogame_lua, nogame_lua_size, "nogame")) displayError(); } if (luaL_dostring(L, "love.timer.step()")) displayError(); if (luaL_dostring(L, "if love.load then love.load() end")) displayError(); while (aptMainLoop()) { if (shouldQuit) { if (forceQuit) break; bool shouldAbort = false; // lua_getfield(L, LUA_GLOBALSINDEX, "love"); // lua_getfield(L, -1, "quit"); // lua_remove(L, -2); // if (!lua_isnil(L, -1)) { // lua_call(L, 0, 1); // shouldAbort = lua_toboolean(L, 1); // lua_pop(L, 1); // }; TODO: Do this properly. if (luaL_dostring(L, "if love.quit then love.quit() end")) displayError(); if (!shouldAbort && !errorOccured) break; } // Quit event if (!errorOccured) { if (luaL_dostring(L, "love.keyboard.scan()\n" "love.timer.step()\n" "if love.update then love.update(love.timer.getDelta()) end")) { displayError(); } // Top screen // Left side sf2d_start_frame(GFX_TOP, GFX_LEFT); if (luaL_dostring(L, "if love.draw then love.draw() end")) displayError(); sf2d_end_frame(); // Right side if (is3D) { sf2d_start_frame(GFX_TOP, GFX_RIGHT); if (luaL_dostring(L, "if love.draw then love.draw() end")) displayError(); sf2d_end_frame(); } // Bot screen sf2d_start_frame(GFX_BOTTOM, GFX_LEFT); if (luaL_dostring(L, "if love.draw then love.draw() end")) displayError(); sf2d_end_frame(); luaL_dostring(L, "love.graphics.present()"); } else { hidScanInput(); u32 kTempDown = hidKeysDown(); if (kTempDown & KEY_START) { forceQuit = true; shouldQuit = true; } char *errMsg = lua_tostring(L, -1); sf2d_start_frame(GFX_TOP, GFX_LEFT); lua_getfield(L, LUA_GLOBALSINDEX, "love"); lua_getfield(L, -1, "errhand"); lua_remove(L, -2); if (!lua_isnil(L, -1)) { lua_pushstring(L, errMsg); lua_call(L, 1, 0); } sf2d_end_frame(); sf2d_start_frame(GFX_BOTTOM, GFX_LEFT); lua_getfield(L, LUA_GLOBALSINDEX, "love"); lua_getfield(L, -1, "errhand"); lua_remove(L, -2); if (!lua_isnil(L, -1)) { lua_pushstring(L, errMsg); lua_call(L, 1, 0); } sf2d_end_frame(); luaL_dostring(L, "love.graphics.present()"); } } luaL_dostring(L, "love.audio.stop()"); lua_close(L); sftd_fini(); sf2d_fini(); cfguExit(); ptmuExit(); if (soundEnabled) ndspExit(); if (romfsExists) romfsExit(); return 0; }
int main(int argc, char **argv) { srvInit(); aptInit(); gfxInit(); acInit(); initCfgu(); ptmInit(); hidInit(NULL); irrstInit(NULL); fsInit(); hbInit(); Handle fileHandle; u64 size; u32 bytesRead; int restore; // Set main script char path[256]; if (argc > 0){ int latest_slash = 0; int i=5; while (argv[0][i] != '\0'){ if (argv[0][i] == '/'){ latest_slash = i; } i++; } strcpy(path,&argv[0][5]); path[latest_slash-5] = 0; strcpy(start_dir,path); strcpy(cur_dir,path); // Set current dir }else{ strcpy(start_dir,"/"); strcpy(cur_dir,"/"); // Set current dir for GW Mode } while(aptMainLoop()) { restore=0; char error[256]; errMsg = runScript((const char*)index_lua, true); if (errMsg != NULL); { // Fake error to force interpreter shutdown if (strstr(errMsg, "lpp_exit_04")){ break; } strcpy(error,"Error: "); strcat(error,errMsg); strcat(error,"\n\nPress A to restart\nPress B to exit"); } while (restore==0){ gspWaitForVBlank(); RefreshScreen(); ClearScreen(0); ClearScreen(1); DebugOutput(error); hidScanInput(); if(hidKeysDown() & KEY_A){ strcpy(cur_dir,start_dir); restore=1; }else if(hidKeysDown() & KEY_B){ restore=2; } gfxFlushBuffers(); gfxSwapBuffers(); } if (restore==2){ break; } } fsExit(); irrstExit(); hidExit(); ptmExit(); hbExit(); acExit(); exitCfgu(); gfxExit(); aptExit(); srvExit(); return 0; }
int main() { char level_data_line[20*16]; LEVELDATA this_level_data = { {&level_data_line[0], &level_data_line[20], &level_data_line[40], &level_data_line[60], &level_data_line[80], &level_data_line[100],&level_data_line[120],&level_data_line[140], &level_data_line[160],&level_data_line[180],&level_data_line[200],&level_data_line[220], &level_data_line[240],&level_data_line[260],&level_data_line[280],&level_data_line[300]}, 19,11 }; // Initializations srvInit(); // services aptInit(); // applets hidInit(); // input gfxInitDefault(); // gfxSet3D(true); // uncomment if using stereoscopic 3D gfxSetDoubleBuffering(GFX_TOP, true); gfxSetDoubleBuffering(GFX_BOTTOM, false); PrintConsole /*topScreen, */bottomScreen; consoleInit(GFX_BOTTOM, &bottomScreen); // consoleInit(GFX_TOP, &topScreen); clear_char_stack(); int level = 0; int mode = MODE_INIT; // int mode_status = 0; hcount = 0; int timer = 0; // Main loop while (aptMainLoop()) { hidScanInput(); u32 kDown = hidKeysDown(); u32 kUp = hidKeysUp(); u32 kHeld = hidKeysHeld(); if (kDown & KEY_START){ break; // break in order to return to hbmenu } if (mode == MODE_INIT){ // consoleSelect(&topScreen); // printf("\033[2J"); copyGame(level,&this_level_data); gspWaitForVBlank(); printGame(&this_level_data); mode = MODE_GAME; }else if (mode == MODE_CLEAR){ if ((kUp & KEY_A) || (kUp & KEY_B) || (kUp & KEY_X) || (kUp & KEY_Y)){ level++; if (level >= sizeof(level_data)/sizeof(LEVELDATA)) { mode = MODE_ALL_CLEAR; }else{ mode = MODE_INIT; } } if (level < sizeof(level_data)/sizeof(LEVELDATA)) { consoleSelect(&bottomScreen); printf("\033[2J"); printf("\x1b[21;12HStage cleared!!"); printf("\x1b[23;12HPush A to next Next Stage"); } }else if (mode == MODE_ALL_CLEAR){ level = 0; consoleSelect(&bottomScreen); printf("\033[2J"); printf("\x1b[21;12HGame cleared!!!"); printf("\x1b[23;12HPush Start to exit game"); mode = MODE_NULL; }else if (mode == MODE_GAME){ // Your code goes here #ifdef DEBUG consoleSelect(&bottomScreen); if (timer%10==0){ //if (1 != 0){printf("\x1b[10;12HkUp =%08x",(unsigned int)kUp);} //if (1 != 0){printf("\x1b[11;12HkDown=%08x",(unsigned int)kDown);} //if (1 != 0){printf("\x1b[12;12HkHeld=%08x",(unsigned int)kHeld);} //printf("\x1b[22;12HKEY_CPAD_UP=%x",KEY_UP); //printf("\x1b[23;12HKEY_CPAD_DN=%x",KEY_DOWN); printf("\x1b[20;12HRest: [SELECT]"); printf("\x1b[22;12HExit: [START]"); printf("\x1b[24;12HTime: %08d",timer); } timer++; #endif if (kDown != 0 || kHeld != 0){ if (kDown & KEY_SELECT){ mode = MODE_INIT; }else{ moveMan(kDown, kHeld,level,&this_level_data); if(checkCleared(&this_level_data,level)==0){ mode = MODE_CLEAR;} gspWaitForVBlank(); draw_char_stack(this_level_data,spriteData, sizeof(spriteData)/sizeof(SPRITEDATA)); } }else{ gspWaitForVBlank(); } } // Flush and swap framebuffers gfxFlushBuffers(); gfxSwapBuffers(); } gfxExit(); hidExit(); aptExit(); srvExit(); return 0; }
int main (int argc, char *argv[]) { (void) argc; (void) argv; // init gfxInitDefault(); gfxSetMode(GfxMode_TiledDouble); // wide screen, keep aspect ratio gfxConfigureResolution(SCR_WIDTH + 136, SCR_HEIGHT); u32* gamebuf = (u32*) malloc(SCR_HEIGHT * SCR_WIDTH * sizeof(u32)); Game.InitSoundDriver(); Game.InitGame(); Game.LoadScores(); Game.StartGame(); int game_paused = 0; while(appletMainLoop()) { hidScanInput(); //1 Player input loop // Get Controller state JOYSTICK *jptr = &Game.m_GameTarget.m_Joy1; u32 keys_down = hidKeysDown(CONTROLLER_P1_AUTO); u32 keys_up = hidKeysUp(CONTROLLER_P1_AUTO); if (keys_down & KEY_PLUS) break; if (keys_down & KEY_LEFT) jptr->left = 1; if (keys_down & KEY_RIGHT) jptr->right = 1; if (keys_down & KEY_A) jptr->up = 1; if (keys_down & KEY_DOWN) jptr->down = 1; if (keys_down & KEY_B) jptr->fire = 1; if (keys_down & KEY_X) Game.m_GameTarget.m_Game.TogglePuffBlow(); if (keys_down & KEY_MINUS) game_paused ^= 1; if (keys_up & KEY_LEFT) jptr->left = 0; if (keys_up & KEY_RIGHT) jptr->right = 0; if (keys_up & KEY_A) jptr->up = 0; if (keys_up & KEY_DOWN) jptr->down = 0; if (keys_up & KEY_B) jptr->fire = 0; // Fake a key press (to pass getPlayerName screen) jptr->key = 13; // Execute game logic Game.MainLoop(gamebuf, game_paused); // Draw to screen, upscaling in hardware u32 *framebuf = (u32*) gfxGetFramebuffer(NULL, NULL); for (int y = 0; y < SCR_HEIGHT; y++) for (int x = 0; x < SCR_WIDTH; x++) framebuf[gfxGetFramebufferDisplayOffset(x + 68, y)] = gamebuf[y * SCR_WIDTH + x]; gfxFlushBuffers(); gfxSwapBuffers(); gfxWaitForVsync(); // Add a delay, FIXME: calculate this with: //u64 time_now = svcGetSystemTick(); svcSleepThread(40000000); } Game.SaveScores(); // save config here :) Game.RemoveSoundDriver(); // deinit free(gamebuf); gfxExit(); return 0; }