double Sys_FloatTime (void)
{
if(!initialTime){
initialTime = svcGetSystemTick();
}
u64 curTime = svcGetSystemTick();
return (curTime - initialTime)/TICKS_PER_SEC;
}
//---------------------------------------------------------------------------------
int __libctru_gtod(struct _reent *ptr, struct timeval *tp, struct timezone *tz) {
//---------------------------------------------------------------------------------
if (tp != NULL) {
datetime_t dt = getSysTime();
u64 delta = svcGetSystemTick() - dt.update_tick;
u32 offset = (u32)(u64_to_double(delta)/TICKS_PER_USEC);
// adjust from 1900 to 1970
u64 now = ((dt.date_time - 2208988800000ULL) * 1000) + offset;
tp->tv_sec = u64_to_double(now)/1000000.0;
tp->tv_usec = now - ((tp->tv_sec) * 1000000);
}
if (tz != NULL) {
tz->tz_minuteswest = 0;
tz->tz_dsttime = 0;
}
return 0;
}
int I_GetTime_RealTime (void)
{
u64 t = (100*(svcGetSystemTick() - startgametime))/26812348;
u64 i = t*(TICRATE/5)/200;
ms_to_next_tick = (i+1)*200/(TICRATE/5) - t;
if (ms_to_next_tick > 1000/TICRATE || ms_to_next_tick<1) ms_to_next_tick = 1;
return i;
}
// Returns number of milliseconds since 1st Jan 1900 00:00.
//---------------------------------------------------------------------------------
u64 osGetTime(void) {
//---------------------------------------------------------------------------------
datetime_t dt = getSysTime();
u64 delta = svcGetSystemTick() - dt.update_tick;
return dt.date_time + (u32)(u64_to_double(delta)/TICKS_PER_MSEC);
}
Time Time::getCurrentTime()
{
#ifdef _3DS
return seconds(svcGetSystemTick() / 268123480.0f);
#else
return seconds((float)glfwGetTime());
#endif // _3DS
}
void I_GetTime_SaveMS(void)
{
if (!movement_smooth)
return;
tic_vars.start = (100*(svcGetSystemTick() - startgametime))/26812348;
tic_vars.next = (unsigned int) ((tic_vars.start * tic_vars.msec + 1.0f) / tic_vars.msec);
tic_vars.step = tic_vars.next - tic_vars.start;
}
boolean I_StartDisplay(void)
{
if (InDisplay)
return false;
start_displaytime = svcGetSystemTick();
InDisplay = true;
return true;
}
int main()
{
srvInit();
aptInit();
hidInit(NULL);
irrstInit(NULL);
gfxInit();
gfxSet3D(false);
srand(svcGetSystemTick());
curQuote=rand()%numQuotes;
superStr[0]=0;
ftp_init();
int connfd=ftp_getConnection();
APP_STATUS status;
while((status=aptGetStatus())!=APP_EXITING)
{
if(status == APP_RUNNING)
{
ftp_frame(connfd);
drawFrame();
hidScanInput();
if(hidKeysDown()&KEY_B)break;
}
else if(status == APP_SUSPENDING)
{
aptReturnToMenu();
}
else if(status == APP_SLEEPMODE)
{
aptWaitStatusEvent();
}
gspWaitForEvent(GSPEVENT_VBlank0, false);
}
ftp_exit();
gfxExit();
irrstExit();
hidExit();
aptExit();
srvExit();
return 0;
}
fixed_t I_GetTimeFrac (void)
{
unsigned long now;
fixed_t frac;
now = (100*(svcGetSystemTick() - startgametime))/26812348;
if (tic_vars.step == 0)
return FRACUNIT;
else
{
frac = (fixed_t)((now - tic_vars.start + displaytime) * FRACUNIT / tic_vars.step);
if (frac < 0)
frac = 0;
if (frac > FRACUNIT)
frac = FRACUNIT;
return frac;
}
}
void I_FinishUpdate (void)
{
static u64 lasttic = 0;
u64 now, frametics;
int height, width;
u32 *bufAdr;
int w, h;
/* Update the display buffer (flipping video pages if supported)
* If we need to change palette, that implicitely does a flip */
if (newpal != NO_PALETTE_CHANGE) {
I_UploadNewPalette(newpal);
newpal = NO_PALETTE_CHANGE;
}
height=screens[0].height;
width=screens[0].width;
bufAdr=(u32*)gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL);
for (h=0; h<height; h++)
{
u32 *dest=&bufAdr[239-h];
u8 *src=screens[0].data + (h * screens[0].byte_pitch);
__builtin_prefetch(src);
for (w=0; w<width; w++)
{
*(dest)=palettes[(*src++) + currentPalette];
dest += 240;
}
}
gspWaitForVBlank();
gfxSwapBuffers();
gfxFlushBuffers();
now = svcGetSystemTick();
frametics = now - lasttic;
lasttic = now;
}
void TextureManager::drawLoadingBottomScreen()
{
u64 tick = svcGetSystemTick() / 10000000;
for (u8 i = 0; i < 17; i++) // row
for (u8 j = 0; j < 15; j++) // col
{
drawLoadingBackball(
rowBackball[i%3][0] + j * 24 - 32 + tick % 16,
(i/3) * 64 + rowBackball[i%3][1] - j * 8 - 16 + tick % 16
);
}
// for (u8 i = 0; i < 9; i++) // row
// for (u8 j = 0; j < 8; j++) // col
// {
// drawLoadingPokeball(
// rowBackball[(i*2)%3][0] + (j*2) * 24 - 32 + tick % 64,
// ((i*2)/3) * 64 + rowBackball[(i*2)%3][1] - (j*2) * 8 - 16 + tick % 64
// );
// }
drawLoadingText(300, 220);
}
static bool ctr_frame(void* data, const void* frame,
unsigned width, unsigned height, unsigned pitch, const char* msg)
{
ctr_video_t* ctr = (ctr_video_t*)data;
settings_t* settings = config_get_ptr();
static uint64_t currentTick,lastTick;
static float fps = 0.0;
static int total_frames = 0;
static int frames = 0;
extern bool select_pressed;
if (!width || !height)
{
gspWaitForEvent(GSPEVENT_VBlank0, true);
return true;
}
if(!aptMainLoop())
{
event_command(EVENT_CMD_QUIT);
return true;
}
if (select_pressed)
{
event_command(EVENT_CMD_QUIT);
return true;
}
svcWaitSynchronization(gspEvents[GSPEVENT_P3D], 20000000);
svcClearEvent(gspEvents[GSPEVENT_P3D]);
svcWaitSynchronization(gspEvents[GSPEVENT_PPF], 20000000);
svcClearEvent(gspEvents[GSPEVENT_PPF]);
gfxSwapBuffersGpu();
frames++;
if (ctr->vsync)
svcWaitSynchronization(gspEvents[GSPEVENT_VBlank0], U64_MAX);
svcClearEvent(gspEvents[GSPEVENT_VBlank0]);
currentTick = svcGetSystemTick();
uint32_t 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;
}
printf("fps: %8.4f frames: %i\r", fps, total_frames++);
fflush(stdout);
ctrGuSetMemoryFill(true, (u32*)CTR_GPU_FRAMEBUFFER, 0x00000000,
(u32*)(CTR_GPU_FRAMEBUFFER + 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)) < 0x1c000000)) /* frame in linear memory */
&& !((u32)frame & 0x7F) /* 128-byte aligned */
&& !((pitch) & 0xF)) /* 16-byte aligned */
{
/* can copy the buffer directly with the GPU */
ctrGuCopyImage(false, frame, pitch / 2, height, CTRGU_RGB565, false,
ctr->texture_swizzled, ctr->texture_width, CTRGU_RGB565, true);
}
else
{
int i;
uint16_t* dst = (uint16_t*)ctr->texture_linear;
const uint8_t* src = frame;
for (i = 0; i < height; i++)
{
memcpy(dst, src, width * sizeof(uint16_t));
dst += ctr->texture_width;
src += pitch;
}
GSPGPU_FlushDataCache(NULL, ctr->texture_linear,
ctr->texture_width * ctr->texture_height * sizeof(uint16_t));
ctrGuCopyImage(false, ctr->texture_linear, ctr->texture_width, ctr->menu.texture_height, CTRGU_RGB565, false,
ctr->texture_swizzled, ctr->texture_width, CTRGU_RGB565, true);
}
}
ctrGuSetTexture(GPU_TEXUNIT0, VIRT_TO_PHYS(ctr->texture_swizzled), ctr->texture_width, ctr->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_RGB565);
ctr->frame_coords->u = width;
ctr->frame_coords->v = height;
GSPGPU_FlushDataCache(NULL, (u8*)ctr->frame_coords, sizeof(ctr_vertex_t));
ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->frame_coords));
ctrGuSetVertexShaderFloatUniform(0, (float*)&ctr->scale_vector, 1);
GPU_DrawArray(GPU_UNKPRIM, 1);
if (ctr->menu_texture_enable)
{
GSPGPU_FlushDataCache(NULL, 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);
ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->menu.frame_coords));
ctrGuSetVertexShaderFloatUniform(1, (float*)&ctr->menu.scale_vector, 1);
GPU_DrawArray(GPU_UNKPRIM, 1);
}
GPU_FinishDrawing();
GPUCMD_Finalize();
ctrGuFlushAndRun(true);
ctrGuDisplayTransfer(true, CTR_GPU_FRAMEBUFFER, 240,400, CTRGU_RGBA8,
gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL), 240,400,CTRGU_RGB8, CTRGU_MULTISAMPLE_NONE);
ctr->frame_count++;
return true;
}
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;
}
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(GSPEVENT_VBlank0, true);
return true;
}
if(!aptMainLoop())
{
event_command(EVENT_CMD_QUIT);
return true;
}
if (select_pressed)
{
event_command(EVENT_CMD_QUIT);
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[GSPEVENT_P3D], 20000000);
svcClearEvent(gspEvents[GSPEVENT_P3D]);
svcWaitSynchronization(gspEvents[GSPEVENT_PPF], 20000000);
svcClearEvent(gspEvents[GSPEVENT_PPF]);
frames++;
if (ctr->vsync)
svcWaitSynchronization(gspEvents[GSPEVENT_VBlank0], U64_MAX);
svcClearEvent(gspEvents[GSPEVENT_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;
}
// extern u32 __linear_heap_size;
// extern u32 gpuCmdBufOffset;
// extern u32 __heap_size;
// printf("0x%08X 0x%08X 0x%08X\r", __heap_size, gpuCmdBufOffset, (__linear_heap_size - linearSpaceFree() +0x3FF) & ~0x3FF);
// printf("fps: %8.4f frames: %i (%X)\r", fps, total_frames++, (__linear_heap_size - linearSpaceFree()));
printf("fps: %8.4f frames: %i\r", fps, total_frames++);
fflush(stdout);
rarch_perf_init(&ctrframe_f, "ctrframe_f");
retro_perf_start(&ctrframe_f);
if (ctr->should_resize)
ctr_update_viewport(ctr);
ctrGuSetMemoryFill(true, (u32*)CTR_GPU_FRAMEBUFFER, 0x00000000,
(u32*)(CTR_GPU_FRAMEBUFFER + 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 */
{
/* can copy the buffer directly with the GPU */
ctrGuCopyImage(false, 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);
}
}
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->frame_coords->u = width;
ctr->frame_coords->v = height;
GSPGPU_FlushDataCache(ctr->frame_coords, sizeof(ctr_vertex_t));
ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->frame_coords));
ctrGuSetVertexShaderFloatUniform(0, (float*)&ctr->scale_vector, 1);
/* 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_DrawArray(GPU_GEOMETRY_PRIM, 0, 1);
/* restore */
if (ctr->rgb32)
{
GPU_SetTexEnv(0,
GPU_TEVSOURCES(GPU_TEXTURE0, GPU_PRIMARY_COLOR, 0),
GPU_TEVSOURCES(GPU_TEXTURE0, GPU_PRIMARY_COLOR, 0),
GPU_TEVOPERANDS(0, 0, 0),
GPU_TEVOPERANDS(0, 0, 0),
GPU_MODULATE, GPU_MODULATE,
0xFFFFFFFF);
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);
ctrGuSetAttributeBuffersAddress(VIRT_TO_PHYS(ctr->menu.frame_coords));
ctrGuSetVertexShaderFloatUniform(0, (float*)&ctr->menu.scale_vector, 1);
GPU_DrawArray(GPU_GEOMETRY_PRIM, 0, 1);
}
GPU_FinishDrawing();
GPUCMD_Finalize();
ctrGuFlushAndRun(true);
ctrGuDisplayTransfer(true, CTR_GPU_FRAMEBUFFER, 240,400, CTRGU_RGBA8,
gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL), 240,400,CTRGU_RGB8, CTRGU_MULTISAMPLE_NONE);
gfxSwapBuffersGpu();
retro_perf_stop(&ctrframe_f);
return true;
}
//---------------------------------------------------------------------------
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(void)
{
gfxInitDefault();
consoleInitDefault();
Result ret;
state = STATE_START;
ret = FS_Init();
if (R_FAILED(ret))
{
consoleLog("\nCouldn't initialize the FS module!\n");
consoleLog("Have you selected a title?\n");
consoleLog("Error code: 0x%lx\n", ret);
// state = STATE_ERROR; // TODO: Remove out of Citra
}
ret = saveInit();
if (R_FAILED(ret))
{
consoleLog("\nCouldn't initialize the Save module!\n");
consoleLog("Error code: 0x%lx\n", ret);
// state = STATE_ERROR; // TODO: Remove out of Citra
}
ret = saveGetTitleId(&titleid);
if (R_FAILED(ret))
{
consoleLog("\nCouldn't get the title id of the game!\n");
consoleLog("Error code: 0x%lx\n", ret);
// state = STATE_ERROR; // TODO: Remove out of Citra
}
fsDirInit();
fsBackInit(titleid);
switchState(&state);
consoleSelectNew(&consoleLog);
drawHelp();
u64 heldUp = 0;
u64 heldDown = 0;
u32 kDown, kHeld;
while (aptMainLoop())
{
gspWaitForVBlank();
hidScanInput();
kDown = hidKeysDown();
kHeld = hidKeysHeld();
switch (state)
{
case STATE_BROWSE:
{
if (kDown & (KEY_LEFT | KEY_RIGHT))
{
fsDirSwitch(NULL);
fsDirPrintSave();
fsDirPrintSdmc();
}
if (kDown & KEY_ZL)
{
fsDirSwitch(&saveDir);
fsDirPrintSave();
fsDirPrintSdmc();
}
if (kDown & KEY_ZR)
{
fsDirSwitch(&sdmcDir);
fsDirPrintSave();
fsDirPrintSdmc();
}
if (kDown & KEY_UP)
{
fsDirMove(-1);
fsDirPrintCurrent();
heldUp = svcGetSystemTick() + HELD_TICK * 2;
}
#ifndef NO_HELD_TICK
else if (kHeld & KEY_UP)
{
if (heldUp + HELD_TICK < svcGetSystemTick())
{
fsDirMove(-1);
fsDirPrintCurrent();
heldUp = svcGetSystemTick();
}
}
#endif
if (kDown & KEY_DOWN)
{
fsDirMove(+1);
fsDirPrintCurrent();
heldDown = svcGetSystemTick() + HELD_TICK * 2;
}
#ifndef NO_HELD_TICK
else if (kHeld & KEY_DOWN)
{
if (heldDown + HELD_TICK < svcGetSystemTick())
{
fsDirMove(+1);
fsDirPrintCurrent();
heldDown = svcGetSystemTick();
}
}
#endif
if (kDown & KEY_A)
{
ret = fsDirGotoSubDir();
consoleLog(" > fsDirGotoSubDir: %lx\n", ret);
fsDirPrintCurrent();
}
if (kDown & KEY_B)
{
ret = fsDirGotoParentDir();
consoleLog(" > fsDirGotoParentDir: %lx\n", ret);
fsDirPrintCurrent();
}
if (kDown & KEY_X)
{
ret = fsDirDeleteCurrentEntry();
consoleLog(" > fsDirDeleteCurrentEntry: %lx\n", ret);
fsDirPrintCurrent();
}
if (kDown & KEY_Y)
{
ret = fsDirCopyCurrentEntry(false);
consoleLog(" > fsDirCopyCurrentEntry: %lx\n", ret);
fsDirPrintDick();
}
break;
}
case STATE_BACKUP:
{
if (kDown & KEY_A)
{
ret = fsBackImport();
consoleLog(" > fsBackImport: %lx\n", ret);
fsBackPrintSave();
}
if (kDown & KEY_B)
{
state = STATE_BACKUP_KEY;
// TODO: setKeyboardString
consoleSelectNew(&logConsole);
}
if (kDown & KEY_X)
{
ret = fsBackDelete();
consoleLog(" > fsBackDelete: %lx\n", ret);
fsBackPrintBackup();
}
if (kDown & KEY_Y)
{
ret = fsBackExport();
consoleLog(" > fsBackExport: %lx\n", ret);
fsBackPrintBackup();
}
if (kDown & KEY_UP)
{
fsBackMove(-1);
fsBackPrintBackup();
heldUp = svcGetSystemTick() + HELD_TICK * 2;
}
#ifndef NO_HELD_TICK
else if (kHeld & KEY_UP)
{
if (heldUp + HELD_TICK < svcGetSystemTick())
{
fsBackMove(-1);
fsBackPrintBackup();
heldUp = svcGetSystemTick();
}
}
#endif
if (kDown & KEY_DOWN)
{
fsBackMove(+1);
fsBackPrintBackup();
heldDown = svcGetSystemTick() + HELD_TICK * 2;
}
#ifndef NO_HELD_TICK
else if (kHeld & KEY_DOWN)
{
if (heldDown + HELD_TICK < svcGetSystemTick())
{
fsBackMove(+1);
fsBackPrintBackup();
heldDown = svcGetSystemTick();
}
}
#endif
break;
}
case STATE_BACKUP_KEY:
{
// TODO: updateKeyboard
if (kDown & KEY_A)
{
state = STATE_BACKUP;
// TODO: getKeyboardString
drawBackup();
}
if (kDown & KEY_B)
{
state = STATE_BACKUP;
drawBackup();
}
break;
}
case STATE_ERROR:
{
consoleLog("\nAn error has occured...\n");
consoleLog("Please check previous logs!\n");
consoleLog("\nPress start to exit.\n");
state = STATE_EOF;
break;
}
default: break;
}
{
if (kDown & KEY_L)
{
// TODO: Prev
switchState(&state);
}
if (kDown & KEY_R)
{
// TODO: Next
switchState(&state);
}
if (kDown & KEY_SELECT)
{
drawHelp();
}
}
if (kDown & KEY_START)
break;
gfxFlushBuffers();
gfxSwapBuffers();
}
fsDirExit();
fsBackExit();
FS_Exit();
{
hidScanInput();
if (!(hidKeysHeld() & KEY_L) && !(hidKeysHeld() & KEY_R))
{
u8 out = 0;
FS_MediaType mediaType = 3;
FSUSER_GetMediaType(&mediaType);
Result ret = saveRemoveSecureValue(titleid, mediaType, &out);
if (R_FAILED(ret))
{
consoleSelect(&logConsole);
printf("\nSecure value not removed.\n");
printf("It might already be unitialized.\n");
printf("Error code: 0x%lx (%i)\n", ret, out);
printf("\n\nPress any key to exit.\n");
waitKey(KEY_ANY);
}
}
}
gfxExit();
return 0;
}
static bool switch_frame(void *data, const void *frame,
unsigned width, unsigned height,
uint64_t frame_count, unsigned pitch,
const char *msg, video_frame_info_t *video_info)
{
static uint64_t last_frame = 0;
unsigned x, y;
result_t r;
int tgtw, tgth, centerx, centery;
uint32_t *out_buffer = NULL;
switch_video_t *sw = data;
int xsf = 1280 / width;
int ysf = 720 / height;
int sf = xsf;
if (ysf < sf)
sf = ysf;
tgtw = width * sf;
tgth = height * sf;
centerx = (1280-tgtw)/2;
centery = (720-tgth)/2;
// clear image to black
for(y = 0; y < 720; y++)
{
for(x = 0; x < 1280; x++)
{
sw->image[y*1280+x] = 0xFF000000;
}
}
if(width > 0 && height > 0) {
if(sw->last_width != width ||
sw->last_height != height)
{
scaler_ctx_gen_reset(&sw->scaler);
sw->scaler.in_width = width;
sw->scaler.in_height = height;
sw->scaler.in_stride = pitch;
sw->scaler.in_fmt = sw->rgb32 ? SCALER_FMT_ARGB8888 : SCALER_FMT_RGB565;
sw->scaler.out_width = tgtw;
sw->scaler.out_height = tgth;
sw->scaler.out_stride = 1280 * sizeof(uint32_t);
sw->scaler.out_fmt = SCALER_FMT_ABGR8888;
sw->scaler.scaler_type = SCALER_TYPE_POINT;
if(!scaler_ctx_gen_filter(&sw->scaler)) {
RARCH_ERR("failed to generate scaler for main image\n");
return false;
}
sw->last_width = width;
sw->last_height = height;
}
scaler_ctx_scale(&sw->scaler, sw->image + (centery * 1280) + centerx, frame);
}
#if defined(HAVE_MENU)
if (sw->menu_texture.enable)
{
menu_driver_frame(video_info);
if (sw->menu_texture.pixels)
{
#if 0
if (sw->menu_texture.fullscreen)
{
#endif
scaler_ctx_scale(&sw->menu_texture.scaler, sw->image +
((720-sw->menu_texture.tgth)/2)*1280 +
((1280-sw->menu_texture.tgtw)/2), sw->menu_texture.pixels);
#if 0
}
else
{
}
#endif
}
}
else if (video_info->statistics_show)
{
struct font_params *osd_params = (struct font_params*)
&video_info->osd_stat_params;
if (osd_params)
{
font_driver_render_msg(video_info, NULL, video_info->stat_text,
(const struct font_params*)&video_info->osd_stat_params);
}
}
#endif
#if 0
if (frame_count > 6000)
{
display_finalize();
exit(0);
}
#endif
if (msg && strlen(msg) > 0)
RARCH_LOG("message: %s\n", msg);
r = surface_dequeue_buffer(&sw->surface, &out_buffer);
if (sw->vsync)
switch_wait_vsync(sw);
svcSleepThread(10000);
if(r != RESULT_OK) {
return true; // just skip the frame
}
gfx_slow_swizzling_blit(out_buffer, sw->image, 1280, 720, 0, 0);
r = surface_queue_buffer(&sw->surface);
if (r != RESULT_OK)
return false;
last_frame = svcGetSystemTick();
return true;
}
void I_EndDisplay(void)
{
displaytime = (100*(svcGetSystemTick() - start_displaytime))/26812348;
InDisplay = false;
}
uint32_t CtrUi::GetTicks() const {
double ticks = u64_to_double(svcGetSystemTick());
u64 usecs = (u64)(ticks/TICKS_PER_MSEC);
return usecs;
}
int main()
{
static char load_filename[512];
char *romname = NULL;
float audioStart; // this is a float to count the half sample per frame needed ho have precise timing
u32 audioTarget, audioEnd;
srvInit();
aptInit();
hidInit();
APT_CheckNew3DS(&isN3DS);
if(isN3DS)
osSetSpeedupEnable(true);
get_config_path();
sprintf(savename, "%s/Handy3ds.cfg", config_base_path); // using savename char buffer to save memory
do_config(savename);
handy_3ds_video_init();
sprintf(bios_path_and_name, "%s/%s", config_bios_path, "lynxboot.img");
// Call filebrowser
if(gui_LoadFile(load_filename)!= -1) {
romname = (char *)&load_filename;
do {
hidScanInput();
} while (hidKeysHeld());
} else {
handy_3ds_quit();
}
// Primary initalise of Handy - should be called AFTER _Init() but BEFORE handy_3ds_video_setup()
handy_3ds_core_init(romname);
// Initialise Handy 3ds video
handy_3ds_video_setup(1, 0, 0, 32, LynxScale, 0, 0);
// Initialise Handy 3ds audio
printf("\nInitialising 3DS Audio... ");
gAudioEnabled = handy_3ds_audio_init();
printf("[DONE]\n");
// Setup of Handy Core video
handy_3ds_video_reinit(32);
printf("Starting Lynx Emulation...\n");
bool touched = false;
audioStart = gAudioBufferPointer; // both should be 0 at this point
// initialize timers
u64 tickcurr, syncticknext,synctickres;
u64 fpsticknext,fpstickres;
int frameSyncPeriod;
if(isN3DS)
frameSyncPeriod = 1;
else
frameSyncPeriod = 12;
fpstickres= TICKS_PER_SEC;
synctickres = TICKS_PER_FRAME * frameSyncPeriod; // on o3ds the sync is every 12 frame, i.e. 5 times every sec
tickcurr=svcGetSystemTick();
fpsticknext = tickcurr + fpstickres;
syncticknext = tickcurr + synctickres;
int fpscnt = 0, synccnt = 0;
gThrottleMaxPercentage = isN3DS?100:50; // !! TO DO: check if 50 is the best value.
while(!emulation)
{
// Initialise Handy button events
int OldKeyMask, KeyMask = mpLynx->GetButtonData();
OldKeyMask = KeyMask;
// Getting events for keyboard and/or joypad handling
hidScanInput();
if (hidKeysHeld() & KEY_TOUCH) {
touched = true;
} else {
if (touched) {
handy_3ds_audio_pause();
gui_Run();
KeyMask = 0;
touched = false;
// audioStart = gAudioBufferPointer;
do {
hidScanInput();
} while (hidKeysHeld());
gThrottleMaxPercentage = isN3DS?100:50; // !! Loading a savestate overrides this value, so we force it again exiting menu
fpscnt = 0;
synccnt = 0;
tickcurr=svcGetSystemTick();
fpsticknext = tickcurr + fpstickres;
syncticknext = tickcurr + synctickres;
} else {
touched = false;
}
}
KeyMask = handy_3ds_on_key_down(hidKeysHeld(), KeyMask);
// Check if there are handling events and then update the Handy button events.
if (OldKeyMask != KeyMask)
mpLynx->SetButtonData(KeyMask);
// Update TimerCount
gTimerCount++;
while( handy_3ds_update() )
{
//!!
hidScanInput();
u32 held = hidKeysHeld();
if (held & KEY_SELECT) {
// handy_3ds_video_quit();
// handy_3ds_audio_quit();
// exit(EXIT_SUCCESS); //break;
touched = true; // enter menu
}
//!!
if(!gSystemHalt)
{
if (!handy_3ds_audio_getstate()) {
audioStart=0.0; // reset counter
gAudioBufferPointer = 0; // reset buffer. really not needed since we set it to 0 in handy_3ds_audio_pause().
}
// increase sound samples counter - 367,5 samples per frame at 60 fps
audioEnd = (int)(audioStart + 367.5) % HANDY_AUDIO_BUFFER_SIZE;
// filling 1 half of the buffer, roughly enough for slow frames on o3DS without risk of buffer head to reach the tail during the 10 frames before resync.
audioTarget = (int)(audioStart + HANDY_AUDIO_BUFFER_SIZE/2.1) % HANDY_AUDIO_BUFFER_SIZE;
if (audioTarget>audioStart)
while (gAudioBufferPointer<audioTarget) mpLynx->Update();
else
while ((gAudioBufferPointer>audioStart)||(gAudioBufferPointer<audioTarget)) mpLynx->Update();
if(Handy_cfg_Throttle && Handy_cfg_Sound && gAudioEnabled) {
if (handy_3ds_audio_getstate())
handy_3ds_audio_callback(audioStart, (int)(audioTarget-audioStart));
else
handy_3ds_audio_start(22050, audioStart);
}
audioStart = audioEnd;
}
else
{
printf("gSystemHalt : %ld\n", gSystemHalt);
gTimerCount++;
}
system_checkPolls();
}
// Timing
fpscnt++;
synccnt++;
if (Handy_cfg_Throttle) {
if (synccnt==frameSyncPeriod){
svcSleepThread((syncticknext - svcGetSystemTick()) / TICKS_PER_NSEC);
}
}
tickcurr=svcGetSystemTick();
if (tickcurr >= syncticknext) {
syncticknext += synctickres;
synccnt = 0;
}
if (tickcurr >= fpsticknext) {
fpsticknext += fpstickres;
fps_counter = fpscnt;
fpscnt = 0;
}
} // while(!emulation)
osSetSpeedupEnable(true);
return 0;
}