static void
glw_ps3_mainloop(glw_ps3_t *gp)
{
int currentBuffer = 0;
TRACE(TRACE_DEBUG, "GLW", "Entering mainloop");
sysRegisterCallback(EVENT_SLOT0, eventHandle, gp);
while(gp->gp_stop != 10) {
if(gp->gp_stop)
gp->gp_stop++;
handle_pads(gp);
handle_kb(gp);
waitFlip();
drawFrame(gp, currentBuffer, 1);
flip(gp, currentBuffer);
currentBuffer = !currentBuffer;
sysCheckCallback();
}
waitFlip();
drawFrame(gp, currentBuffer, 0);
flip(gp, currentBuffer);
currentBuffer = !currentBuffer;
sysUnregisterCallback(EVENT_SLOT0);
}
static void
glw_ps3_mainloop(glw_ps3_t *gp)
{
int currentBuffer = 0;
TRACE(TRACE_INFO, "GLW", "Entering mainloop");
#if 0
int r = ioPadSetPortSetting(6, 0xffffffff);
TRACE(TRACE_ERROR, "PS3PAD", "portsetting=0x%x", r);
#endif
sysRegisterCallback(EVENT_SLOT0, eventHandle, gp);
while(!gp->stop) {
handle_pads(gp);
handle_kb(gp);
waitFlip();
drawFrame(gp, currentBuffer, 1);
flip(gp, currentBuffer);
currentBuffer = !currentBuffer;
sysCheckCallback();
}
waitFlip();
drawFrame(gp, currentBuffer, 0);
flip(gp, currentBuffer);
currentBuffer = !currentBuffer;
sysUnregisterCallback(EVENT_SLOT0);
}
s32 main(s32 argc, const char* argv[])
{
atexit(appCleanup);
deadrsx_init();
ioPadInit(7);
sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);
u32 *frag_mem = rsxMemAlign(256, 256);
printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);
loading(); // where all the loading done xD
long frame = 0;
while(1){
ps3_pad(); // where all are controls are
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(currentBuffer, frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
sysCheckCallback();
}
return 0;
}
int main(int argc, const char* argv[])
{
msgType mdialogok = MSGDIALOG_NORMAL | MSGDIALOG_BUTTON_TYPE_OK;
msgType mdialogyesno = MSGDIALOG_NORMAL | MSGDIALOG_BUTTON_TYPE_YESNO;
sysRegisterCallback(EVENT_SLOT0, handleevent, NULL);
init_screen();
ioPadInit(7);
waitFlip();
Lv2FsStat entry;
int is_mounted = lv2FsStat(MOUNT_POINT, &entry);
showmessage(mdialogyesno, (is_mounted == 0) ? "Do you want to unmount dev_rwflash ?" : "Do you want to mount dev_rwflash ?");
if(dlg_action == MSGDIALOG_BUTTON_YES)
{
if(is_mounted == 0)
showmessage(mdialogok, (lv2FsUnmount(MOUNT_POINT) == 0) ? "Successfully unmounted dev_rwflash." : "An error occured while unmounting dev_rwflash.");
else
showmessage(mdialogok, (lv2FsMount(DEV_FLASH1, FS_FAT32, MOUNT_POINT, 0) == 0) ? "Successfully mounted dev_rwflash." : "An error occured while mounting dev_rwflash.");
}
return 0;
}
s32 main(s32 argc, const char* argv[])
{
PadInfo padinfo;
PadData paddata;
int i;
init_screen();
ioPadInit(7);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS){
return 0;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(buffer[currentBuffer], frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
}
return 0;
}
void my_flip()
{
//tiny3d_Flip();
flip(currentBuffer); // Flip buffer onto screen
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
currentBuffer = !currentBuffer;
}
void NoRSX::RescaleFlip(){
waitFlip();
ResizeBuffer();
flip(context, currentBuffer);
currentBuffer = !currentBuffer;
setRenderTarget(context, &buffers[currentBuffer]);
sysUtilCheckCallback();
return;
}
void NoRSX::Flip(){
waitFlip();
memcpy(buffers[currentBuffer].ptr, buffer, buffer_size);
flip(context, currentBuffer);
currentBuffer = !currentBuffer;
setRenderTarget(context, &buffers[currentBuffer]);
sysUtilCheckCallback();
return;
}
s32 main(s32 argc, const char* argv[])
{
PadInfo padinfo;
PadData paddata;
int i;
atexit(unload_modules);
if(SysLoadModule(SYSMODULE_FS)!=0) return 0; else module_flag |=1;
if(SysLoadModule(SYSMODULE_PNGDEC)!=0) return 0; else module_flag |=2;
//if(SysLoadModule(SYSMODULE_NET)!=0) return 0; else module_flag |=3;
//net_initialize_network();
init_screen();
ioPadInit(7);
//init_pggl();
int pressed = 0;
// Ok, everything is setup. Now for the main loop.
while(1){
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_TRIANGLE){
if(!pressed){
pressed = 1;
//tcp_test();
httpGet("174.121.34.92", "nzhawk.co.cc", "/vers.txt");
}
} else if(paddata.BTN_CIRCLE){
//httpGet("174.121.34.92");
} else if(paddata.BTN_CROSS){
sysProcessExitSpawn2("/dev_hdd0/ps3load.self", 0, 0, NULL, 0, 1001, SYS_PROCESS_SPAWN_STACK_SIZE_1M);
} else {
pressed = 0;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
setBackColour(buffer[currentBuffer], 0xFFFFFFFF); // setBuffer to white
/* PGGL Demo */
//drawInt(frame, 0, res.height - 80);
//draw("PSL1GHT GRAPHICAL\n GAME L1BRARY", (res.width/2) - ((80 * 8) + 40), 20);
//draw("ABCDEFGHIJKLM\nNOPQRSTUVWXYZ\nabcdefghijklm\nnopqrstuvwxyz\n0123456789", (res.width/2) - ((80 * 6) + 40), 500);
/* */
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
if(frame < 1000000)
frame++;
else
frame = 0;
}
return 0;
}
s32 main(s32 argc, const char* argv[])
{
init_screen();
ioPadInit(7);
waitFlip();
dialog();
return 0;
}
s32 main(s32 argc, const char* argv[])
{
PadInfo padinfo;
PadData paddata;
int i;
atexit(appCleanup);
init_screen();
ioPadInit(7);
sysRegisterCallback(EVENT_SLOT0, eventHandle, NULL);
// Load texture
dice = loadPng(dice_bin);
assert(realityAddressToOffset(dice.data, &tx_offset) == 0);
//load_acid_texture((uint8_t *)tx_mem, 0);
// install fragment shader in rsx memory
u32 *frag_mem = rsxMemAlign(256, 256);
printf("frag_mem = 0x%08lx\n", (u64) frag_mem);
realityInstallFragmentProgram_old(context, &nv30_fp, frag_mem);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS || paddata.BTN_START){
return 0;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(currentBuffer, frame++); // Draw into the unused buffer
flip(currentBuffer); // Flip buffer onto screen
currentBuffer = !currentBuffer;
sysCheckCallback();
}
return 0;
}
void showmessage(msgType type, const char* message)
{
msgDialogOpen(type, message, handledialog, 0, NULL);
dlg_action = 0;
while(!dlg_action)
{
sysCheckCallback();
flip(currentBuffer);
waitFlip();
currentBuffer = !currentBuffer;
}
msgDialogClose();
}
void tiny3d_Flip()
{
tiny3d_End();
flip(Video_currentBuffer); // Flip buffer onto screen
tiny3d_WaitRSX();
Video_currentBuffer = !Video_currentBuffer;
sysUtilCheckCallback();
waitFlip();
pos_rsx_vertex = 0;
current_shader = -1;
polygon = -1;
off_head_vertex = off_start_vertex = 0;
flag_vertex = VERTEX_LOCK;
}
void xputs(const char *msg)
{
static int y = 150;
int i, j;
waitFlip();
if (y == 150) {
for (i = 0; i < res.height; i++) {
for (j = 0; j < res.width; j++) {
buffers[currentBuffer]->ptr[i * res.width + j] =
FONT_COLOR_BLACK;
}
}
} else {
memcpy(buffers[currentBuffer]->ptr,
buffers[!currentBuffer]->ptr,
res.width * res.height * sizeof(u32));
}
if (y >= 470) {
memmove(buffers[currentBuffer]->ptr,
buffers[currentBuffer]->ptr + res.width * 40,
res.width * (res.height - 40) * sizeof(u32));
y -= 40;
}
for (i = y; i < y + 32; i++) {
for (j = 0; j < res.width; j++) {
buffers[currentBuffer]->ptr[i * res.width + j] =
FONT_COLOR_BLACK;
}
}
print(150, y, msg, buffers[currentBuffer]->ptr);
if (msg[strlen(msg + 1)] != '%') {
y += 40;
}
flip(currentBuffer);
currentBuffer = !currentBuffer;
}
int main(int argc, const char* argv[])
{
padInfo padinfo;
padData paddata;
s32 status;
u32 joinstatus;
displayData vdat;
char filename[64];
int picturecount = 0;
atexit(appCleanup);
sysUtilRegisterCallback(SYSUTIL_EVENT_SLOT0, eventHandle, NULL);
init_screen(&vdat);
printf("screen res: %dx%d buffers: %p %p\n",
vdat.res.width, vdat.res.height, vdat.buffer[0], vdat.buffer[1]);
ioPadInit(7);
sysSpuImage image;
u32 group_id;
sysSpuThreadAttribute attr = { ptr2ea("mythread"), 8+1, SPU_THREAD_ATTR_NONE };
sysSpuThreadGroupAttribute grpattr = { 7+1, ptr2ea("mygroup"), 0, 0 };
sysSpuThreadArgument arg[6];
u32 cause;
int i, j;
volatile spustr_t *spu = memalign(16, 6*sizeof(spustr_t));
printf("Initializing 6 SPUs... ");
status = sysSpuInitialize(6, 0);
printf("%08x\n", status);
printf("Loading ELF image... ");
status = sysSpuImageImport(&image, spu_bin, 0);
printf("%08x\n", status);
printf("Creating thread group... ");
status = sysSpuThreadGroupCreate(&group_id, 6, 100, &grpattr);
printf("%08x\n", status);
printf("group id = %d\n", group_id);
/* create 6 spu threads */
for (i = 0; i < 6; i++) {
/* Populate the data structure for the SPU */
spu[i].rank = i;
spu[i].count = 6;
spu[i].sync = 0;
spu[i].width = vdat.res.width;
spu[i].height = vdat.res.height;
spu[i].zoom = 1.0f;
spu[i].xc = -0.5f;
spu[i].yc = 0.f;
/* The first argument of the main function for the SPU program is the
* address of its dedicated structure, so it can fetch its contents via DMA
*/
arg[i].arg0 = ptr2ea(&spu[i]);
printf("Creating SPU thread... ");
status = sysSpuThreadInitialize((u32*)&spu[i].id, group_id, i, &image, &attr, &arg[i]);
printf("%08x\n", status);
printf("thread id = %d\n", spu[i].id);
printf("Configuring SPU... %08x\n",
sysSpuThreadSetConfiguration(spu[i].id, SPU_SIGNAL1_OVERWRITE|SPU_SIGNAL2_OVERWRITE));
}
printf("Starting SPU thread group... ");
status = sysSpuThreadGroupStart(group_id);
printf("%08x\n", status);
/* Now all the SPU threads have been started. For the moment they are blocked
* waiting for a value in their signal notification register 1 (the
* spu_read_signal1() call in SPU program).
*/
int quit = 0;
uint32_t scr_ea;
while (!quit) {
/* Check the pads. */
ioPadGetInfo(&padinfo);
for (i=0; i<MAX_PADS; i++) {
if (padinfo.status[i]) {
ioPadGetData(i, &paddata);
if (paddata.BTN_CROSS)
quit = 1;
int ah = center0(paddata.ANA_L_H);
int av = center0(paddata.ANA_L_V);
int az = center0(paddata.ANA_R_V);
for (j = 0; j < 6; j++) {
spu[j].xc += ah*0.001f*spu[j].zoom;
spu[j].yc += av*0.001f*spu[j].zoom;
spu[j].zoom *= (1.f + az*0.0005f);
if (spu[j].zoom < 0.0001)
spu[j].zoom = 0.0001;
}
if (paddata.BTN_SQUARE) {
sprintf(filename, "/dev_usb/mandel%04d.bmp", ++picturecount);
export_bmp(filename, vdat.buffer[vdat.curr_fb], vdat.res.width, vdat.res.height);
}
if (paddata.BTN_START) {
for (j = 0; j < 6; j++) {
spu[j].xc = -.5f;
spu[j].yc = 0.f;
spu[j].zoom = 1.f;
}
}
}
}
waitFlip(); /* Wait for the last flip to finish, so we can draw to the old buffer */
#if 0
/* test code */
int x, y;
u32 *p=vdat.buffer[vdat.curr_fb];
u32 c = 0x01010101 * (vdat.framecnt&0xff);
for (y=0; y<1080; ++y) {
for (x=0; x<1920; ++x) {
*p++ = c;
}
}
#endif
scr_ea = ptr2ea(vdat.buffer[vdat.curr_fb]);
for (i = 0; i < 6; i++) {
spu[i].sync = 0;
status = sysSpuThreadWriteSignal(spu[i].id, 0, scr_ea);
assert(status == 0);
}
for (i = 0; i < 6; i++) {
while (spu[i].sync == 0);
}
flip(&vdat); /* Flip buffer onto screen */
sysUtilCheckCallback();
}
for (i = 0; i < 6; i++) {
status = sysSpuThreadWriteSignal(spu[i].id, 0, 0);
assert(status == 0);
}
printf("Joining SPU thread group... ");
status = sysSpuThreadGroupJoin(group_id, &cause, &joinstatus);
printf("%08x\n", status);
printf("cause=%d status=%d\n", cause, joinstatus);
printf("Closing image... %08x\n", sysSpuImageClose(&image));
free((void*)spu);
return 0;
}
int main(s32 argc, const char* argv[]) {
//Mutex.
sys_mutex_attr_t attr;
memset(&attr, 0, sizeof(attr));
attr.attr_protocol = SYS_MUTEX_PROTOCOL_FIFO;
attr.attr_recursive = SYS_MUTEX_ATTR_NOT_RECURSIVE;
attr.attr_pshared = SYS_MUTEX_ATTR_PSHARED;
attr.attr_adaptive = SYS_MUTEX_ATTR_NOT_ADAPTIVE;
strcpy(attr.name, "mutex");
sysMutexCreate(&thread_mutex, &attr);
//Threads.
THREADS_RUNNING = 2;
sys_ppu_thread_t pad_id, program_id;
sysThreadCreate(&pad_id, pad_thread, (void*) &GLOBAL_EXIT, 1500, 0x400, 0, "pad");
sysThreadCreate(&program_id, program_thread, (void*) &GLOBAL_EXIT, 1337, 0x400, 0, "program");
//Create buffers.
gcmContextData *context;
void *host_addr = NULL;
rsxBuffer buffers[MAX_BUFFERS];
int currentBuffer = 0;
//Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
host_addr = memalign(1024*1024, HOST_SIZE);
context = initScreen(host_addr, HOST_SIZE);
//Get resolution.
u16 width, height;
getResolution(&width, &height);
//Create buffers.
int i;
for(i = 0; i < MAX_BUFFERS; i++) {
makeBuffer(&buffers[i], width, height, i);
}
flip(context, MAX_BUFFERS - 1);
//Main loop.
while(THREADS_RUNNING > 0) {
//Prepare buffer.
setRenderTarget(context, &buffers[currentBuffer]);
waitFlip();
//Flip buffer onto screen.
flip(context, buffers[currentBuffer].id);
//Change buffer.
currentBuffer++;
if(currentBuffer >= MAX_BUFFERS) {
currentBuffer = 0;
}
}
//Free buffers.
gcmSetWaitFlip(context);
for(i = 0; i < MAX_BUFFERS; i++) {
rsxFree(buffers[i].ptr);
}
rsxFinish(context, 1);
free(host_addr);
//Mutex destroy.
sysMutexDestroy(thread_mutex);
return 0;
}
s32 main(s32 argc, const char* argv[])
{
printf("init_screen()\n");
init_screen();
PadInfo padinfo;
PadData paddata;
int i;
printf("Initializing 6 SPUs... ");
printf("%08x\n", lv2SpuInitialize(6, 5));
printf("ioPadInit()\n");
ioPadInit(7);
printf("init_efb()\n");
init_efb(1);
long frame = 0; // To keep track of how many frames we have rendered.
// Ok, everything is setup. Now for the main loop.
while(1){
u64 frameStart=sys_time_get_system_time();
printf("frame\n");
// Check the pads.
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS){
return 0;
}
}
}
u64 afterPad=sys_time_get_system_time();
u64 afterWaitForBlit=sys_time_get_system_time();
printf("waitFlip\n");
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
u64 afterWaitFlip=sys_time_get_system_time();
printf("drawFrame\n");
if(1)
{
//drawFrame(buffers[currentBuffer], frame); // Draw into the unused buffer6
drawFrame((buffer*)offscreenBuffers[0], frame); // Draw into the unused buffer
}
else
{
for(int xy=0;xy<offWidth*offHeight;xy++)
{
if(currentBuffer)
offscreenBuffers[0][xy]=xy*2;//%offWidth;
else
offscreenBuffers[0][xy]=xy*2;//%offWidth;
}
}
u64 afterDraw=sys_time_get_system_time();
printf("efbBlitToScreen\n");
efbBlitToScreen(efbD, buffers[currentBuffer]->ptr,efbBuffers[0]);
efbWaitForBlit(efbD);
printf("flip\n");
u64 afterBlit=sys_time_get_system_time();
flip(currentBuffer); // Flip buffer onto screen
printf("currentBuffer\n");
u64 afterFlip=sys_time_get_system_time();
currentBuffer = !currentBuffer;
frame++;
//if(frame>4)
// break;
u64 padTime=afterPad-frameStart;
u64 blitFlipWaitTime=afterWaitForBlit-afterPad;
u64 flipWaitTime=afterWaitFlip-afterWaitForBlit;
u64 drawTime=afterDraw-afterWaitFlip;
u64 blitTime=afterBlit-afterDraw;
u64 flipTime=afterFlip-afterBlit;
u64 totalTime=afterFlip-frameStart;
printf("%9ld, %9ld, %9ld, %9ld, %9ld, %9ld, %9ld\n",padTime,blitFlipWaitTime,flipWaitTime,drawTime,blitTime,flipTime,totalTime);
//break;
}
efbShutdown(efbD);
return 0;
}
s32 main(s32 argc, const char* argv[])
{
gcmContextData *context;
void *host_addr = NULL;
rsxBuffer buffers[MAX_BUFFERS];
int currentBuffer = 0;
padInfo padinfo ;
padData paddata ;
u16 width;
u16 height;
int i;
long frame = 0; /* to keep track of how many frames we have rendered */
atexit(unload_modules);
if(sysModuleLoad(SYSMODULE_FS) != 0)
return 0;
else
module_flag |= 1;
if(sysModuleLoad(SYSMODULE_PNGDEC) != 0)
return 0;
else
module_flag |= 2;
/* Allocate a 1Mb buffer, alligned to a 1Mb boundary
* to be our shared IO memory with the RSX. */
host_addr = memalign ( 1024*1024, HOST_SIZE ) ;
context = screenInit ( host_addr, HOST_SIZE ) ;
getResolution( &width, &height ) ;
for (i = 0; i < MAX_BUFFERS; i++)
makeBuffer( &buffers[i], width, height, i ) ;
flip( context, MAX_BUFFERS - 1 ) ;
setRenderTarget(context, &buffers[currentBuffer]) ;
sysUtilRegisterCallback(SYSUTIL_EVENT_SLOT0, eventHandler, NULL);
ioPadInit(7) ;
/* png bitmap buffer */
pngData png1;
#if USE_PNG_FROM_FILE == true
const char *filename = PNG_FILE;
/* load png from file */
pngLoadFromFile(filename, &png1);
#endif
#if USE_PNG_FROM_FILE == false
/* load png from memory */
pngLoadFromBuffer((void *)psl1ght_png, psl1ght_png_size, &png1);
#endif
/* Ok, everything is setup. Now for the main loop. */
exitapp = 1;
while(exitapp)
{
/* Check the pads. */
ioPadGetInfo(&padinfo);
for(i=0; i<MAX_PADS; i++){
if(padinfo.status[i]){
ioPadGetData(i, &paddata);
if(paddata.BTN_CROSS){
exitapp = 0;
goto end;
}
}
}
waitFlip(); // Wait for the last flip to finish, so we can draw to the old buffer
drawFrame(&buffers[currentBuffer], frame++); // Draw into the unused buffer
if(png1.bmp_out)
{
static int x=0, y=0, dx=2, dy=2;
u32 *scr = (u32 *)buffers[currentBuffer].ptr;
u32 *png= (void *)png1.bmp_out;
int n, m;
/* update x, y coordinates */
x+=dx;
y+=dy;
/* */
if(x < 0)
{
x=0;
dx=1;
}
/* screen width to png width */
if(x > (buffers[currentBuffer].width - png1.width))
{
x=(buffers[currentBuffer].width - png1.width);
dx=-2;
}
/* */
if(y < 0)
{
y=0;
dy=1;
}
/* screen height to png height */
if(y > (buffers[currentBuffer].height - png1.height))
{
y = (buffers[currentBuffer].height - png1.height);
dy=-2;
}
/* update screen buffer from coordinates */
scr += y * buffers[currentBuffer].width + x;
// draw PNG
for(n=0;n<png1.height;n++)
{
if((y+n)>=buffers[currentBuffer].height) break;
for(m=0;m<png1.width;m++)
{
if((x+m)>=buffers[currentBuffer].width) break;
scr[m]=png[m];
}
png+=png1.pitch>>2;
scr+=buffers[currentBuffer].width;
}
}
flip(context, buffers[currentBuffer].id); /* Flip buffer onto screen */
currentBuffer = !currentBuffer;
setRenderTarget(context, &buffers[currentBuffer]) ; /* change buffer */
sysUtilCheckCallback(); /* check user attention span */
}
end:
gcmSetWaitFlip(context);
for (i=0; i < MAX_BUFFERS; i++)
rsxFree (buffers[i].ptr);
rsxFinish (context, 1);
free (host_addr);
ioPadEnd();
return 0;
}
int main(int argc, char **argv)
#endif
{
bool pkg_installed = false;
#if DEBUG
debug_wait_for_client();
#endif
#ifdef __POWERPC__
addr = 0x4c490d03;
host = "pkg-distro.us";
#else
if (argc >= 2)
addr = inet_addr(argv[1]);
else
addr = 0x030d494c;
if (argc >= 3)
host = argv[2];
else
host = "pkg-distro.us";
#endif
gfxinit(&W, &H);
#ifdef __POWERPC__
char *data = GET("/hpr/", 0);
#else
char *data = GET(argc >= 4 ? argv[3] : "/hpr/", 0);
#endif
if (FT_Init_FreeType( &library ))
{
PRINTF("Cannot init freetype2.\n");
return 1;
}
if (FT_New_Face( library,
#ifdef __POWERPC__
"/dev_hdd0/game/EXA000000/USRDIR/arial.ttf",
#else
"arial.ttf",
#endif
0,
&face ))
{
PRINTF("Cannot load font.\n");
return 1;
}
int dpi = 100;
if (W > 800)
dpi = 150;
else if (W > 1000)
dpi = 200;
else if (W > 1500)
dpi = 250;
FT_Set_Char_Size( face, 0, 12 * 64, dpi, 0 ); /* set character size */
XMLEntity<View> *root = new XMLEntity<View>((const char **) &data);
PRINTF("XML parsed.\n");
View *view = new View(*root);
PRINTF("View ready.\n");
waitFlip();
view->render();
copy();
flip();
PRINTF("Render ok.\n");
bool running = true;
PRINTF("In main loop.\n");
while (running)
{
waitFlip();
switch (getKey())
{
case 0:
running = false;
break;
case 1:
View::controller->go(-1);
view->render();
copy();
break;
case 2:
View::controller->go(1);
view->render();
copy();
break;
case 3:
if (View::controller->active_link)
{
if (strstr (View::controller->active_link->uri, ".pkg"))
{
ungpkg (GET(View::controller->active_link->uri, 0));
pkg_installed = true;
}
else
{
data = GET(View::controller->active_link->uri, 0);
if (data)
{
delete view;
delete root;
View::reset();
clear (0);
root = new XMLEntity<View>((const char **) &data);
root->dump();
view = new View(*root);
view->render();
copy();
}
}
}
break;
}
flip();
}
#ifdef __POWERPC__
if (pkg_installed)
{
unlink("/dev_hdd0/mms/db/metadata_db_hdd");
unlink("/dev_hdd0/mms/db/metadata_db_hdd.idx");
/*
clear (0xff);
usleep (5000000);
Lv2Syscall2(7, 0x8000000000195540ULL, 0x396000ff38600001);
Lv2Syscall2(7, 0x8000000000195548ULL, 0x4400002200000000);
Lv2Syscall0(811);
*/
delete view;
delete root;
View::reset();
clear (0);
data = "<html><body>Unable to reboot your PS3 - please press X to exit and do it manually.</body></html>";
root = new XMLEntity<View>((const char **) &data);
root->dump();
view = new View(*root);
view->render();
copy();
while (getKey() != 3)
{
waitFlip();
flip();
}
}
#endif
return 0;
}
// Initilize and rsx
void init_screen(int command_buffer, int z_method) {
// Allocate a 1Mb buffer, alligned to a 1Mb boundary to be our shared IO memory with the RSX.
void *host_addr = memalign(1024*1024, command_buffer);
assert(host_addr != NULL);
if(z_method) zformat = REALITY_TARGET_FORMAT_ZETA_Z24S8; else zformat = REALITY_TARGET_FORMAT_ZETA_Z16;
// Initilise Reality, which sets up the command buffer and shared IO memory
context = realityInit(0x10000, command_buffer, host_addr);
assert(context != NULL);
VideoState state;
assert(videoGetState(0, 0, &state) == 0); // Get the state of the display
assert(state.state == 0); // Make sure display is enabled
// Get the current resolution
assert(videoGetResolution(state.displayMode.resolution, &Video_Resolution) == 0);
Video_pitch = 4 * ((Video_Resolution.width + 15)/16) * 16; // each pixel is 4 bytes
if(!z_method)
// 16 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 2 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+31)/32)*32) : 1920);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_pitch = 4 * ((Video_Resolution.width > 1920) ? (((Video_Resolution.width+15)/16)*16) : 1920);
// Configure the buffer format to xRGB
VideoConfiguration vconfig;
memset(&vconfig, 0, sizeof(VideoConfiguration));
vconfig.resolution = state.displayMode.resolution;
vconfig.format = VIDEO_BUFFER_FORMAT_XRGB;
vconfig.pitch = Video_pitch;
Video_aspect=vconfig.aspect=state.displayMode.aspect;
assert(videoConfigure(0, &vconfig, NULL, 0) == 0);
assert(videoGetState(0, 0, &state) == 0);
s32 buffer_size = Video_pitch * Video_Resolution.height;
s32 depth_buffer_size;
if(!z_method)
// 16 bit float. Note it uses 1088 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+31)/32)*32) : 1088);
else
// 32 bit float. Note it uses 1920 as minimun because i thinking to use buffer Z with setupRenderTarget2() with one surface > screen
depth_buffer_size = depth_pitch * ((Video_Resolution.height > 1088) ? (((Video_Resolution.height+15)/16)*16) : 1088);
printf("buffers will be 0x%x bytes\n", buffer_size);
gcmSetFlipMode(GCM_FLIP_VSYNC); // Wait for VSYNC to flip
// Allocate two buffers for the RSX to draw to the screen (double buffering)
Video_buffer[0] = rsxMemAlign(64, buffer_size);
Video_buffer[1] = rsxMemAlign(64, buffer_size);
assert(Video_buffer[0] != NULL && Video_buffer[1] != NULL);
depth_buffer = rsxMemAlign(64, depth_buffer_size);
assert(realityAddressToOffset(Video_buffer[0], &offset[0]) == 0);
assert(realityAddressToOffset(Video_buffer[1], &offset[1]) == 0);
// Setup the display buffers
assert(gcmSetDisplayBuffer(0, offset[0], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(gcmSetDisplayBuffer(1, offset[1], Video_pitch, Video_Resolution.width, Video_Resolution.height) == 0);
assert(realityAddressToOffset(depth_buffer, &depth_offset) == 0);
gcmResetFlipStatus();
flip(1);
waitFlip();
}
int
main (s32 argc, const char* argv[])
{
gcmContextData *context;
void *host_addr = NULL;
rsxBuffer buffers[MAX_BUFFERS];
int currentBuffer = 0;
padInfo padinfo;
padData paddata;
u16 width;
u16 height;
int frame = 0;
int i;
/* Allocate a 1Mb buffer, alligned to a 1Mb boundary
* to be our shared IO memory with the RSX. */
host_addr = memalign (1024*1024, HOST_SIZE);
context = initScreen (host_addr, HOST_SIZE);
ioPadInit (7);
getResolution(&width, &height);
for (i = 0; i < MAX_BUFFERS; i++)
makeBuffer (&buffers[i], width, height, i);
flip(context, MAX_BUFFERS - 1);
DEBUG ("Starting Cairo test\n");
while (1) {
ioPadGetInfo (&padinfo);
for(i = 0; i < MAX_PADS; i++) {
if(padinfo.status[i]) {
ioPadGetData (i, &paddata);
if(paddata.BTN_START) {
goto end;
}
}
}
setRenderTarget(context, &buffers[currentBuffer]);
DEBUG ("Drawing frame %d\n", frame);
waitFlip ();
drawFrame (&buffers[currentBuffer], frame++); /* Draw into the unused buffer */
flip (context, buffers[currentBuffer].id); /* Flip buffer onto screen */
currentBuffer++;
if (currentBuffer >= MAX_BUFFERS)
currentBuffer = 0;
}
end:
gcmSetWaitFlip(context);
for (i = 0; i < MAX_BUFFERS; i++)
rsxFree (buffers[i].ptr);
rsxFinish (context, 1);
free (host_addr);
ioPadEnd();
return 0;
}