void draw() { sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT|GU_STENCIL_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); sceGuFinish(); sceGuSync(0, 0); }
void vidgu_init() { g_pBlitBuff = (unsigned short *)(0x40000000 | (unsigned int)&g_BlitBuff); sceGuInit(); // setup sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_5650,(void*)0,512); sceGuDispBuffer(480,272,(void*)0x88000,512); sceGuDepthBuffer((void*)0x110000,512); sceGuOffset(2048 - (480/2),2048 - (272/2)); sceGuViewport(2048,2048,480,272); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,480,272); sceGuEnable(GU_SCISSOR_TEST); sceGuFrontFace(GU_CW); sceGuEnable(GU_TEXTURE_2D); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(1); }
void MasterGuRenderer::guInit() { DEBUG_ENTER_FUNC(); sceGuInit(); sceGuStart(0, _displayList); guProgramDisplayBufferSizes(); sceGuOffset(2048 - (PSP_SCREEN_WIDTH / 2), 2048 - (PSP_SCREEN_HEIGHT / 2)); sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); sceGuDepthRange(0xC350, 0x2710); sceGuDisable(GU_DEPTH_TEST); // We'll use depth buffer area sceGuDepthMask(GU_TRUE); // Prevent writes to depth buffer sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuFrontFace(GU_CW); sceGuEnable(GU_TEXTURE_2D); sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); sceGuDisplay(1); }
void psp_init(void) { SceUID thid; char buff[128], *r; /* fw 1.5 sometimes returns 8002032c, although getcwd works */ r = getcwd(buff, sizeof(buff)); if (r) sceIoChdir(buff); main_thread_id = sceKernelGetThreadId(); lprintf("running on %08x kernel\n", sceKernelDevkitVersion()), lprintf("entered psp_init, threadId %08x, priority %i\n", main_thread_id, sceKernelGetThreadCurrentPriority()); thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, NULL); if (thid >= 0) { sceKernelStartThread(thid, 0, 0); } /* video */ sceDisplaySetMode(0, 480, 272); sceDisplaySetFrameBuf(VRAM_FB1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME); current_screen = 1; psp_screen = VRAM_FB0; /* gu */ sceGuInit(); sceGuStart(GU_DIRECT, guCmdList); sceGuDrawBuffer(GU_PSM_5650, (void *)VRAMOFFS_FB0, 512); sceGuDispBuffer(480, 272, (void *)VRAMOFFS_FB1, 512); // don't care sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); sceGuDepthBuffer((void *)VRAMOFFS_DEPTH, 512); sceGuOffset(2048 - (480 / 2), 2048 - (272 / 2)); sceGuViewport(2048, 2048, 480, 272); sceGuDepthRange(0xc350, 0x2710); sceGuScissor(0, 0, 480, 272); sceGuEnable(GU_SCISSOR_TEST); sceGuDepthMask(0xffff); sceGuDisable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuEnable(GU_TEXTURE_2D); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuAmbientColor(0xffffffff); sceGuColor(0xffffffff); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); /* input */ sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); }
// These are GU commands that should always stay the same inline void MasterGuRenderer::guPreRender() { DEBUG_ENTER_FUNC(); #ifdef USE_DISPLAY_CALLBACK _renderSema.take(); // Take the semaphore to prevent writes // to the palette/screen before we're done _renderFinished = false; // set to synchronize with callback thread #endif #ifdef ENABLE_RENDER_MEASURE _lastRenderTime = g_system->getMillis(); #endif /* ENABLE_RENDER_MEASURE */ sceGuStart(0, _displayList); sceGuClearColor(0xFF000000); sceGuClear(GU_COLOR_BUFFER_BIT); sceGuAmbientColor(0xFFFFFFFF); sceGuColor(0xFFFFFFFF); sceGuTexOffset(0, 0); sceGuTexFilter(GU_LINEAR, GU_LINEAR); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); // Also good enough for all purposes sceGuAlphaFunc(GU_GREATER, 0, 0xFF); // Also good enough for all purposes }
void clearScreenPrintHeader(int y) { i = 0; sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); drawStringCenter("warPSP", y, 0xFF990000, 0); drawStringCenter("warXing Suite", y ? y + 20 : y + 10, 0xFF550000, 0); drawStringCenter("Easy Installation Program", y ? y + 40 : y + 30, 0xFF000000, 0); drawStringCenter("by caliFrag", y ? y + 80 : y + 20, 0xFF006600, 0); }
void gClear(gColor color) { if (!start) _gStart(); sceGuClearColor(color); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT | (zclear ? GU_DEPTH_BUFFER_BIT : 0)); zclear = G_FALSE; }
int ClearDrawScreen() { GUINITCHECK; GUSTART; sceGuClear( GU_COLOR_BUFFER_BIT | (dxpGraphicsData.usedepth || dxpGraphicsData.usedepth3d ? GU_DEPTH_BUFFER_BIT : 0) | (dxpGraphicsData.clear_stencil ? GU_STENCIL_BUFFER_BIT : 0) ); return 0; }
void blit_start(int start, int end) { clip_min_y = start; clip_max_y = end + 1; spr_num = 0; spr_index = 0; if (start == FIRST_VISIBLE_LINE) { clut = (UINT16 *)PSP_UNCACHE_PTR(&video_palettebank[palette_bank]); fix_num = 0; spr_disable = 0; if (clear_spr_texture) blit_clear_spr_sprite(); if (clear_fix_texture) blit_clear_fix_sprite(); sceGuStart(GU_DIRECT, gulist); sceGuDrawBufferList(GU_PSM_5551, draw_frame, BUF_WIDTH); sceGuScissor(0, 0, BUF_WIDTH, SCR_WIDTH); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuDrawBufferList(GU_PSM_5551, work_frame, BUF_WIDTH); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuScissor(24, 16, 336, 240); sceGuClearColor(CNVCOL15TO32(video_palette[4095])); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuClearColor(0); sceGuEnable(GU_ALPHA_TEST); sceGuTexMode(GU_PSM_T8, 0, 0, GU_TRUE); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuFinish(); sceGuSync(0, GU_SYNC_FINISH); } }
MF_API void MFRenderer_ClearScreen(MFRenderClearFlags flags, MFVector colour, float z, int stencil) { MFCALLSTACK; clearColour = ((uint32)(a*255.0f) << 24) | ((uint32)(b*255.0f) << 16) | ((uint32)(g*255.0f) << 8) | (uint32)(r*255.0f); sceGuClearColor(clearColour); sceGuClearDepth(0xFFFF); sceGuClear( ((flags&CS_Colour) ? GU_COLOR_BUFFER_BIT : NULL) | ((flags&CS_ZBuffer) ? GU_DEPTH_BUFFER_BIT : NULL) ); }
void DrawScene( void ) { sceGuStart( GU_DIRECT, sceneList ); sceGuViewport( 2048, 2048, SCR_WIDTH, SCR_HEIGHT); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); sceGumMatrixMode(GU_MODEL); sceGumLoadIdentity(); // Reset the Matrix myScene->render(); // Render the scene sceGuFinish(); sceGuSync(0,0); }
void DrawScene( void ) { #warning Try taking out this display list at some point sceGuStart( GU_DIRECT, sceneList ); sceGuViewport( 2048, 2048, SCR_WIDTH, SCR_HEIGHT); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); sceGumMatrixMode(GU_MODEL); sceGumLoadIdentity(); // Reset the Matrix myScene.render(); // Render the scene sceGuFinish(); sceGuSync(0,0); }
void Red3dSetupScreen() { sceGuDisplay(GU_TRUE); sceGuStart(GU_DIRECT,list); sceGuClearColor(GRAY); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); sceGumMatrixMode(GU_VIEW); sceGumLoadIdentity(); { sceGumTranslate(&CameraPosition); sceGumRotateXYZ(&CameraRotation); } sceGumMatrixMode(GU_PROJECTION); sceGumLoadIdentity(); sceGumPerspective(25.0f,16.0f/9.0f,0.5f,1000.0f); }
int os_fb_init(int argc, char** argv) { int i; if (os_byte_fb != NULL) return 1; //os_byte_fb = //(os_byte_t*) malloc(640*480*4); os_byte_fb = pixels; for (i = 0; i < 256; ++i) { os_fb_palette[i].r = 0; os_fb_palette[i].g = 0; os_fb_palette[i].b = 0; } pspDebugScreenInit(); SetupCallbacks(); sceGuInit(); // setup sceGuStart(0,list); sceGuDrawBuffer(GE_PSM_4444,(void*)0,512); sceGuDispBuffer(480,272,(void*)0x88000,512); sceGuDepthBuffer((void*)0x110000,512); sceGuOffset(2048 - (480/2),2048 - (272/2)); sceGuViewport(2048,2048,480,272); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,480,272); sceGuEnable(GU_STATE_SCISSOR); sceGuFrontFace(GE_FACE_CW); sceGuEnable(GU_STATE_TEXTURE); sceGuClear(GE_CLEAR_COLOR|GE_CLEAR_DEPTH); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(1); return 0; /// return x11_display_init(640, 480, "dacube2", argc, argv); }
void StartRendering() { //printf("FrontEnd::StartRendering\n"); /* Increment the frame */ if (_frame >= 0xff) { _frame = 0; } else { ++_frame; } BlockUntilFrameReady(); /*< Blocks the program until the frame is ready */ /* Preps the display for rendering */ sceGuSwapBuffers(); sceGuStart(SCEGU_IMMEDIATE, (void*)disp_list, sizeof(disp_list)); sceGuClearColor(_bgColour); sceGuClear(SCEGU_CLEAR_ALL); }
void initGraphics() { dispBufferNumber = 0; sceGuInit(); guStart(); sceGuDrawBuffer(GU_PSM_8888, (void*)FRAMEBUFFER_SIZE, PSP_LINE_SIZE); sceGuDispBuffer(SCREEN_WIDTH, SCREEN_HEIGHT, (void*)0, PSP_LINE_SIZE); sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); sceGuDepthBuffer((void*) (FRAMEBUFFER_SIZE*2), PSP_LINE_SIZE); sceGuOffset(2048 - (SCREEN_WIDTH / 2), 2048 - (SCREEN_HEIGHT / 2)); sceGuViewport(2048, 2048, SCREEN_WIDTH, SCREEN_HEIGHT); sceGuDepthRange(0xc350, 0x2710); sceGuScissor(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuAlphaFunc(GU_GREATER, 0, 0xff); sceGuEnable(GU_ALPHA_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuEnable(GU_CLIP_PLANES); sceGuTexMode(GU_PSM_8888, 0, 0, 0); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuAmbient(0xffffffff); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); initialized = 1; }
/** * Created 24/02/2011 * Prepares and clears the PSP display for rendering */ bool FrontEnd::StartRendering(void) { //printf("FrontEnd::StartRendering\n"); /* Increment the frame */ ++_frame; /* Check controls */ if( _playerInput->IsLShoulderDown() ) { ++_viewMode; if( _viewMode >= 3 ) { _viewMode = 0; } } else if( _playerInput->IsRShoulderDown() ) { --_viewMode; if( _viewMode < 0 ) { _viewMode = 2; } } if( _playerInput->IsDPadLeft() ) { if( _rotationSpeed > 1 ) { --_rotationSpeed; } } else if( _playerInput->IsDPadRight() ) { if( _rotationSpeed < 180 ) { ++_rotationSpeed; } } /* Increment the rotation */ switch( _viewMode ) { case -1: break; case 0: _rotation.x += DEGSTORADS( _rotationSpeed ); if( _rotation.x > DEGSTORADS( 360.0f ) ) { _rotation.x = 0.0f; } break; case 1: _rotation.y += DEGSTORADS( _rotationSpeed ); if( _rotation.y > DEGSTORADS( 360.0f ) ) { _rotation.y = 0.0f; } break; case 2: _rotation.z += DEGSTORADS( _rotationSpeed ); if( _rotation.z > DEGSTORADS( 360.0f ) ) { _rotation.z = 0.0f; } break; } #ifdef PC /* Start the device */ _pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, IntToD3DColor( _bgColour ), 1.0f, 0 ); _pd3dDevice->BeginScene(); /* Set up the view matrix */ D3DXMATRIXA16 view; D3DXMatrixTranslation( &view, _view.x, _view.y, 25.0f ); _pd3dDevice->SetTransform( D3DTS_VIEW, &view ); /* Set up the projection matrix */ D3DXMATRIXA16 projection; D3DXMatrixPerspectiveFovLH( &projection, DEGSTORADS(45.0f), 1.7647f, 1.0f, 100.0f ); _pd3dDevice->SetTransform( D3DTS_PROJECTION, &projection ); #else /* Set up the starting matrices */ //sceGumPushMatrix(); ScePspFVector3 view; view.x = _view.x; view.y = _view.y; view.z = _view.z; sceGumLoadIdentity(); sceGumTranslate( &view ); //BlockUntilFrameReady(); /*< Blocks the program until the frame is ready */ /* Preps the display for rendering */ sceGuSwapBuffers(); sceGuStart(SCEGU_IMMEDIATE, (void*)_displist, sizeof(_displist)); sceGuClearColor(_bgColour); sceGuClear(SCEGU_CLEAR_ALL); #endif return true; }
bool8 S9xSceGUInit2 (void) { SceGU.line_size = 512; SceGU.max_texture_size = 512; if (SceGU.max_texture_size >= 512) { SceGU.texture_size = 512; // SceGU.num_textures = 2; // See note in 3d.h SceGU.num_textures = 1; } else { SceGU.texture_size = SceGU.max_texture_size; SceGU.num_textures = 1; } // TODO ///////Settings.SceGUEnable = TRUE; // 2nd texture may be reserved for transparency in the future. #if 0 if (SceGU.num_textures == 2) { } #endif // Use a 16-bit pixel format 5-bits for RGB and 1-bit for Alpha (unused) SceGU.texture_format = GU_PSM_5551; SceGU.pixel_format = GU_PSM_5551; SceGU.ct = GU_COLOR_5551; SceGU.tt = GU_TEXTURE_16BIT; SceGU.mt = GU_VERTEX_16BIT; SceGU.dm = GU_TRANSFORM_2D; sceGuStart (0, SceGU.list); sceGuDrawBufferList (SceGU.pixel_format, (void *)0, SceGU.line_size); sceGuDispBuffer (480, 272, (void *)0x88000, SceGU.line_size); sceGuDepthBuffer ( (void *)0x110000, SceGU.line_size); sceGuOffset (0, 0); sceGuViewport ((480 / 2), (272 / 2), 480, 272); sceGuDepthRange (0xc350, 0x2710); sceGuScissor (0, 0, 480, 272); sceGuEnable (GU_SCISSOR_TEST); sceGuDisable (GU_ALPHA_TEST); sceGuDisable (GU_DEPTH_TEST); sceGuEnable (GU_CULL_FACE); sceGuDisable (GU_LIGHTING); sceGuFrontFace (GU_CW); sceGuEnable (GU_TEXTURE_2D); sceGuClear (GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); #if 0 sceGuTexWrap (GE_WRAP_REPEAT, GE_WRAP_REPEAT); sceGuTexFunc (GU_TFX_MODULATE, /*GE_TCC_RGBA*/ GE_TCC_RGB); #endif sceGuFinish (); sceGuSync (0, 0); S9xSceGUSwapBuffers (); return (TRUE); }
void DrawTilePSP (uint32 Tile, uint32 Offset, uint32 StartLine, uint32 LineCount) { TILE_PREAMBLE float x = Offset % GFX.Pitch; float y = Offset / GFX.Pitch; #define X 0 #define Y 1 #define U 0 #define V 1 float pos [3][4]; float tex [2][4]; static bool8 init = FALSE; if (init == FALSE) { sceGuStart(0,list); sceGuDrawBufferList(GE_PSM_5551,(void*)0,512); sceGuDispBuffer(480,272,(void*)0x88000,512); sceGuDepthBuffer((void*)0x110000,512); sceGuOffset(0,0); sceGuViewport(480/2,272/2,480,272); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,480,272); sceGuEnable(GU_STATE_SCISSOR); sceGuDisable(GU_STATE_ATE); sceGuDisable(GU_STATE_ZTE); sceGuEnable(GU_STATE_CULL); sceGuDisable(GU_STATE_ALPHA); sceGuDisable(GU_STATE_LIGHTING); sceGuFrontFace(GE_FACE_CW); sceGuEnable(GU_STATE_TEXTURE); sceGuClear(GE_CLEAR_COLOR|GE_CLEAR_DEPTH); sceGuFinish(); sceGuSync(0,0); init = TRUE; } pos [0][X] = 0 + x * 1; pos [0][Y] = 0 + y * 1; pos [1][X] = 0 + (x + 8.0f) * 1; pos [1][Y] = 0 + y * 1; pos [2][X] = 0 + (x + 8.0f) * 1; pos [2][Y] = 0 + (y + LineCount) * 1; pos [3][X] = 0 + x * 1; pos [4][Y] = 0 + (y + LineCount) * 1; if (!(Tile & (V_FLIP | H_FLIP))) { // Normal tex [0][U] = 0.0f; tex [0][V] = StartLine; tex [1][U] = 8.0f; tex [1][V] = StartLine; tex [2][U] = 8.0f; tex [2][V] = StartLine + LineCount; tex [3][U] = 0.0f; tex [3][V] = StartLine + LineCount; } else if (!(Tile & V_FLIP)) { // Flipped tex [0][U] = 8.0f; tex [0][V] = StartLine; tex [1][U] = 0.0f; tex [1][V] = StartLine; tex [2][U] = 0.0f; tex [2][V] = StartLine + LineCount; tex [3][U] = 8.0f; tex [3][V] = StartLine + LineCount; } else if (Tile & H_FLIP) { // Horizontal and vertical flip tex [0][U] = 8.0f; tex [0][V] = StartLine + LineCount; tex [1][U] = 0.0f; tex [1][V] = StartLine + LineCount; tex [2][U] = 0.0f; tex [2][V] = StartLine; tex [3][U] = 8.0f; tex [3][V] = StartLine; } else { // Vertical flip only tex [0][U] = 0.0f; tex [0][V] = StartLine + LineCount; tex [1][U] = 8.0f; tex [1][V] = StartLine + LineCount; tex [2][U] = 8.0f; tex [2][V] = StartLine; tex [3][U] = 0.0f; tex [3][V] = StartLine; } sceGuStart(0,list); sceGuTexMode(GU_PSM_5551,0,0,0); sceGuTexFunc(GU_TFX_REPLACE,0); sceGuTexOffset(0,0); sceGuAmbientColor(0xffffffff); sceGuTexImage (0, 8, 8, 8, (void *)pCache); sceGuTexScale (1.0/8.0f, 1.0f/8.0f); struct Vertex *vertices; vertices = (struct Vertex *)sceGuGetMemory (4 * sizeof (struct Vertex)); vertices[0].u = tex[0][U]; vertices[0].v = tex[0][V]; vertices[0].x = pos[0][X]; vertices[0].y = pos[0][Y]; vertices[0].z = 0.0f; vertices[1].u = tex[1][U]; vertices[1].v = tex[1][V]; vertices[1].x = pos[1][X]; vertices[1].y = pos[1][Y]; vertices[1].z = 0.0f; vertices[2].u = tex[2][U]; vertices[2].v = tex[2][V]; vertices[2].x = pos[2][X]; vertices[2].y = pos[2][Y]; vertices[2].z = 0.0f; vertices[3].u = tex[3][U]; vertices[3].v = tex[3][V]; vertices[3].x = pos[3][X]; vertices[3].y = pos[3][Y]; vertices[3].z = 0.0f; sceGuDrawArray (GU_PRIM_TRIANGLES,GE_SETREG_VTYPE(GE_TT_16BIT,GE_CT_5551,0,GE_MT_16BIT,0,0,0,0,GE_BM_2D),4,0,vertices); sceGuFinish (); }
void app() { setupCallbacks(); #ifdef DEBUG pspDebugScreenInit(); #endif sceGuInit(); void* fbp0 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* fbp1 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* zbp = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_4444); sceGuStart(GU_DIRECT, list); sceGuDrawBuffer(GU_PSM_8888, fbp0, BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH, SCR_HEIGHT, fbp1, BUF_WIDTH); sceGuDepthBuffer(zbp, BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH / 2), 2048 - (SCR_HEIGHT / 2)); sceGuViewport(2048, 2048, SCR_WIDTH, SCR_HEIGHT); sceGuDepthRange(65535, 0); sceGuClearDepth(65535); sceGuDepthFunc(GU_LEQUAL); sceGuAlphaFunc(GU_GREATER, 0, 255); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA); sceGuTexFilter(GU_LINEAR, GU_LINEAR); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_DEPTH_TEST); sceGuEnable(GU_ALPHA_TEST); sceGuEnable(GU_SCISSOR_TEST); sceGuEnable(GU_BLEND); sceGuDisable(GU_CULL_FACE); sceGuDisable(GU_CLIP_PLANES); sceGuDisable(GU_DITHER); sceGuScissor(0, 0, SCR_WIDTH, SCR_HEIGHT); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); //g2dInit(); /*tileset_tex = g2dTexLoad((char *) "resources/tilemap.png", G2D_SWIZZLE); outline_tex = g2dTexLoad((char *) "resources/tilemap2.png", G2D_SWIZZLE); text_tex = g2dTexLoad((char *) "resources/ui-font.png", G2D_SWIZZLE); frame_tex = g2dTexLoad((char *) "resources/frame.png", G2D_SWIZZLE);*/ while (running()) { sceGuStart(GU_DIRECT,list); // Clear screen sceGuClearColor(0xff554433); // TODO change to black when everything works sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); // Process and draw a frame //menu.update(); //background.draw(); //menu.draw(); sceGuFinish(); sceGuSync(0,0); // Swap buffers and wait for VSYNC sceDisplayWaitVblankStart(); sceGuSwapBuffers(); } sceGuDisplay(GU_FALSE); sceGuTerm(); sceKernelExitGame(); }
int main() { SceCtrlData pad; int cancel = 0, uninstall = 0, reinstall = 0, lftv = 0, ok = 0, installed = 0, uninstalled = 0, autoExit = 0; SetupCallbacks(); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons & PSP_CTRL_LTRIGGER) { quickinstall = 1; lftv = 1; } else if (pad.Buttons & PSP_CTRL_RTRIGGER) { quickinstall = 1; } if (fileExist(PRX_LFTVBACKUP) | fileExist(PRX_RPLYBACKUP)) uninstall = 1; sceGuInit(); sceGuStart(GU_DIRECT, list); sceGuClearColor(0xFFFFFFFF); sceGuDrawBuffer(GU_PSM_8888, (void*)0, BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH, SCR_HEIGHT, (void*)0x88000, BUF_WIDTH); sceGuDepthBuffer((void*)0x110000, BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH / 2), 2048 - (SCR_HEIGHT / 2)); sceGuViewport(2048, 2048, SCR_WIDTH, SCR_HEIGHT); sceGuDepthRange(0xc350, 0x2710); sceGuScissor(0, 0, SCR_WIDTH, SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDisable(GU_DEPTH_TEST); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_8888, 0, 0, 0); sceGuTexImage(0, 256, 128, 256, font); sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA); sceGuTexEnvColor(0x0); sceGuTexOffset(0.0f, 0.0f); sceGuTexScale(1.0f / 256.0f, 1.0f / 128.0f); sceGuTexWrap(GU_REPEAT, GU_REPEAT); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuFinish(); sceGuSync(0,0); sceGuDisplay(GU_TRUE); // Check for low battery. if ((scePowerGetBatteryLifePercent() < 25) & !scePowerIsPowerOnline()) { sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); drawStringCenter("Battery charge should be at least 25% when modifying flash!", 40 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("Connect the AC adapter to ignore this warning and continue!", 40 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter(uninstall ? "Press any button to cancel uninstallation of warPSP." : "Press any button to cancel installation of warPSP.", 50 + (10 * i), 0xFF0000FF, 8); i += 2; drawObjects(); while (!scePowerIsPowerOnline()) { sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons) { cancel = 1; break; } } } if (!cancel) { float c = 0.0; for (c = 10.0; c <= 100.0; c++) { unsigned int col = 0xFF000000 | (unsigned int)((c / 100.0) * 255.0f) << 16 | (unsigned int)((c / 100.0) * 255.0f) << 8 | (unsigned int)((c / 100.0) * 255.0f) << 0; sceGuClearColor(col); clearScreenPrintHeader(90); if (quickinstall & (c > 50)) drawStringCenter("Quick Install Activated!", 250, 0xFF006600, 8); drawObjects(); } sceKernelDelayThread(3000000); for (c = 100.0; c >= 10.0; c--) { unsigned int col = 0xFF000000 | (unsigned int)((c / 100.0) * 255.0f) << 16 | (unsigned int)((c / 100.0) * 255.0f) << 8 | (unsigned int)((c / 100.0) * 255.0f) << 0; sceGuClearColor(col); clearScreenPrintHeader(90); drawObjects(); } } sceGuClearColor(0xFFFFFFFF); // Show disclaimer and options. if (!cancel & !quickinstall) { sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); drawStringCenter("!!! DISCLAIMER !!!", 40 + (10 * i), 0xFF0000FF, 10); i += 2; drawStringCenter("This program modifies the flash drive of your Sony PSP.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("You accept the risk when running this installation app.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("DO NOT REMOVE THE MEMORY STICK WHEN ORANGE LED FLASHES.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("DO NOT TURN OFF THE PSP SYSTEM WHEN ORANGE LED FLASHES.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("Press START to acknowledge and to continue to briefing.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("Press SELECT to decline and to abort installing warPSP.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("THE AUTHOR DOES NOT HOLD RESPONSIBILITY FOR ANY DAMAGE.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("THIS SOFTWARE IS PRESENTED WITHOUT WARRANTY/GUARANTEES.", 60 + (10 * i), 0xFF0000FF, 8); i += 4; drawObjects(); while (1) { sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons & PSP_CTRL_START) { break; } if (pad.Buttons & PSP_CTRL_SELECT) { cancel = 1; break; } } } // Check if backup file exists. if (!cancel & !quickinstall) { swapBuffers(); clearScreenPrintHeader(0); drawObjects(); clearScreenPrintHeader(0); drawStringCenter("Briefing", 50 + (10 * i), 0xFF000000, 0); i+= 2; drawStringCenter("Thanks for your interest in the warPSP Software Suite!", 50 + (10 * i), 0xFF006600, 0); i += 2; drawStringCenter("warPSP is an advanced warXing utility for the Sony PSP.", 50 + (10 * i), 0xFF000000, 8); i += 2; drawStringCenter("Please see the README.TXT file for more information.", 50 + (10 * i), 0xFF660000, 8); i += 3; drawStringCenter("Options", 50 + (10 * i), 0xFF000000, 0); i += 2; if (uninstall) { drawStringCenter("Press SQUARE to uninstall warPSP and restore backup files.", 50 + (10 * i), 0xFF000000, 8); i++; drawStringCenter("Press CIRCLE to reinstall warPSP to the last slot selected.", 50 + (10 * i), 0xFF000000, 8); i++; } else { drawStringCenter("Press SQUARE to install warPSP to the LFTV Player slot.", 50 + (10 * i), 0xFF000000, 8); i++; drawStringCenter("Press CIRCLE to install warPSP to the Remote Play slot.", 50 + (10 * i), 0xFF000000, 8); i++; } drawStringCenter(uninstall ? "Press SELECT to cancel uninstallation of warPSP and exit." : "Press SELECT to cancel installation of warPSP and exit.", 50 + (10 * i), 0xFF000099, 8); i += 2; drawObjects(); while (1) { sceCtrlReadBufferPositive(&pad, 1); if (uninstall) { if (pad.Buttons & PSP_CTRL_SQUARE) { break; } if (pad.Buttons & PSP_CTRL_CIRCLE) { uninstall = 0; reinstall = 1; if (fileExist(PRX_LFTVBACKUP)) lftv = 1; else lftv = 0; break; } } else { if (pad.Buttons & PSP_CTRL_SQUARE) { lftv = 1; break; } if (pad.Buttons & PSP_CTRL_CIRCLE) { lftv = 0; break; } } if (pad.Buttons & PSP_CTRL_SELECT) { cancel = 1; break; } } } if (!cancel) { if ((scePowerGetBatteryLifePercent() < 25) & !scePowerIsPowerOnline()) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter(" Battery is below 25%% and AC adapter is not connected!", 50 + (10 * i), 0xFF000099, 0); i += 2; cancel = 1; drawObjects(); } } if (cancel) { swapBuffers(); sceGuStart(GU_DIRECT, list); sprintf(buffer, "%sstallation cancelled!", uninstall ? "Unin" : "In"); drawStringCenter(buffer, 50 + (10 * i), 0xFF0000FF, 0); i += 2; drawObjects(); sceKernelDelayThread(1000000); } // Perform installation, uninstallation or reinstallation. if (!cancel) { scePowerLock(0); swapBuffers(); clearScreenPrintHeader(0); drawObjects(); clearScreenPrintHeader(0); drawObjects(); swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter(uninstall ? "Uninstallation" : "Installation", 50 + (10 * i), 0xFF990000, 0); i += 2; if (quickinstall) { drawStringCenter("Quick installing warPSP to the location free player slot.", 50 + (10 * i), 0xFF990000, 0); i += 2; } drawObjects(); swapBuffers(); sceGuStart(GU_DIRECT, list); if (uninstall) { if (fileExist(PRX_LFTVBACKUP)) { lftv = 1; ok = 1; } else if (fileExist(PRX_RPLYBACKUP)) { lftv = 0; ok = 1; } if (ok) { drawStringCenter("Backup prx found. Ok to uninstall!", 50 + (10 * i), 0xFF990000, 8); i++; drawStringCenter("The backup prx will be copied to the flash drive of your PSP!", 50 + (10 * i), 0xFF000000, 8); i += 2; drawObjects(); if (fileCopy(lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP, lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Backup file reinstalled successfully!", 50 + (10 * i), 0xFF006600, 8); sceIoRemove(lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP); uninstalled = 1; } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Backup file reinstallation failed!", 50 + (10 * i), 0xFF000099, 8); } i += 2; drawObjects(); if (uninstalled) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("To reinstall warPSP, rerun the Easy Installation Program.", 50 + (10 * i), 0xFF990000, 8); i += 2; drawObjects(); } } } else { if (fileExist(PRX_WARPSP_XMB)) { sceIoRemove(PRX_WARPSP_XMB); sceKernelDelayThread(1000000); } drawStringCenter("Extracting warPSP.prx to the root of the memory stick.", 50 + (10 * i), 0xFF000000, 8); i += 2; drawObjects(); sceKernelDelayThread(2000000); // Open PBP file and read contents into the buffer. int pbpFile, prxFile, pkgSize = 0, prxSize = 0; char buf[1024*1024]; pbpFile = sceIoOpen(PBP_WARPSP_EIP, PSP_O_RDONLY, 0); sceKernelDelayThread(1000000); if (pbpFile) { // Get size of entire package. pkgSize = sceIoRead(pbpFile, buf, sizeof(buf)); sceKernelDelayThread(1000000); if (pkgSize > 0) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("EBOOT.PBP loaded into memory successfully!", 50 + (10 * i), 0xFF006600, 8); i += 2; drawObjects(); // Calculate size of prx to extract (size of entire package - size of eboot.pbp). prxSize = pkgSize - pbpSize; // Open PRX file and write buffer into the contents. prxFile = sceIoOpen(PRX_WARPSP_XMB, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777); sceKernelDelayThread(100000); if (prxFile) { // Write prx file from end of eboot.pbp. sceIoWrite(prxFile, buf + pbpSize, prxSize); sceKernelDelayThread(1000000); sceIoClose(prxFile); sceKernelDelayThread(1000000); swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP.prx extracted from memory successfully!", 50 + (10 * i), 0xFF006600, 8); drawObjects(); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP.prx extraction from memory failed!", 50 + (10 * i), 0xFF000099, 8); drawObjects(); } i += 2; } sceIoClose(pbpFile); sceKernelDelayThread(1000000); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("EBOOT.PBP load into memory failed!", 50 + (10 * i), 0xFF000099, 8); i += 2; drawObjects(); } buf[0] = (char)"\0"; swapBuffers(); sceGuStart(GU_DIRECT, list); if (!fileExist(PRX_WARPSP_XMB)) { drawStringCenter("warPSP.prx not found! Install cancelled!", 50 + (10 * i), 0xFF000099, 8); } else { drawStringCenter("warPSP.prx found. Ok to install!", 50 + (10 * i), 0xFF006600, 8); ok = 1; } i += 2; drawObjects(); // Create backup of original file and install warPSP. if (ok) { if (!reinstall) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("The backup file will be copied to the memory stick!", 50 + (10 * i), 0xFF990000, 8); i++; drawObjects(); if (fileCopy(lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY, lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Original prx file backed up successfully!", 50 + (10 * i), 0xFF006600, 8); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Original prx file back up failed!", 50 + (10 * i), 0xFF000099, 8); } i += 2; drawObjects(); } if (fileCopy(PRX_WARPSP_XMB, lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP^xmb installed successfully!", 50 + (10 * i), 0xFF006600, 8); sceIoRemove(PRX_WARPSP_XMB); installed = 1; } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP^xmb installation failed!", 50 + (10 * i), 0xFF000099, 8); installed = 0; } i += 2; drawObjects(); } } scePowerUnlock(0); } if (installed | uninstalled) { sceKernelDelayThread(1000000); } if (!quickinstall) { swapBuffers(); sceGuStart(GU_DIRECT, list); sprintf(buffer, "Press any button to %s! (Auto-Exit in 10s).", (installed | uninstalled) ? "restart the PSP" : "return to the xmb"); drawStringCenter(buffer, 50 + (10 * i), 0xFF000000, 8); i++; if (installed) { drawStringCenter("Happy warXing!", 50 + (10 * i), 0xFF006600, 8); i++; } else if (uninstalled) { drawStringCenter("Thank you for using warPSP", 50 + (10 * i), 0xFF990000, 8); i++; } drawObjects(); // Wait for exit. while (1) { if (autoExit >= 1000) break; sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons) break; sceKernelDelayThread(10000); autoExit++; } } if (quickinstall) { sceKernelDelayThread(1000000); } swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Exiting!", 50 + (10 * i), (installed | uninstalled) ? 0xFF990000 : 0xFF0000FF, 8); drawObjects(); if (installed | uninstalled) { sceKernelExitGame(); scePower_0442D852(50000); } else { sceKernelExitGame(); } return 0; }
void gClearZ() { sceGuClear(GU_DEPTH_BUFFER_BIT | GU_FAST_CLEAR_BIT); zclear = G_TRUE; }
int main(int argc, char* argv[]) { SetupCallbacks(); // generate geometry genTorus( TORUS_ROWS, TORUS_SLICES, TORUS_RADIUS, TORUS_THICKNESS, torus_vertices, torus_indices ); // flush cache so that no stray data remains sceKernelDcacheWritebackAll(); // setup Edram buffers void* frameBuffer = (void*)0; const void* doubleBuffer = (void*)0x44000; const void* renderTarget = (void*)0x88000; const void* depthBuffer = (void*)0x110000; // setup GU sceGuInit(); sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_4444,frameBuffer,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)doubleBuffer,BUF_WIDTH); sceGuDepthBuffer((void*)depthBuffer,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // run sample int val = 0; Texture offscreenTexture = { GU_PSM_4444, 0, 128, 128, 128, sceGeEdramGetAddr() + (int)renderTarget }; for(;;) { sceGuStart(GU_DIRECT,list); { sceGuDrawBufferList(GU_PSM_4444,(void*)renderTarget,offscreenTexture.stride); // setup viewport sceGuOffset(2048 - (offscreenTexture.width/2),2048 - (offscreenTexture.height/2)); sceGuViewport(2048,2048,offscreenTexture.width,offscreenTexture.height); // clear screen sceGuClearColor(0xffffffff); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // draw torus to offscreen texture drawTorus( val ); } { // set frame buffer sceGuDrawBufferList(GU_PSM_4444,(void*)frameBuffer,BUF_WIDTH); // setup viewport sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); // clear screen sceGuClearColor(0xff554433); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // draw cube using offscreen texture drawCube( &offscreenTexture, val ); } sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); frameBuffer = sceGuSwapBuffers(); val++; } sceGuTerm(); sceKernelExitGame(); return 0; }
int main(int argc, char* argv[]) { setupCallbacks(); int i, j; // Load emd mesh from file EMD_MESH* mesh = EMD_LoadMeshFromFile("scene.emd"); int vert_count = EMD_GetVertexCount(mesh); int idx_count = 0; int elem_count = EMD_GetElementCount(mesh); for (i=0; i<elem_count; i++) { idx_count += EMD_GetIndexCount(mesh, i); } VERTEX* vert_buf = (VERTEX*)memalign(16, sizeof(VERTEX) * vert_count); GW_UINT16* idx_buf = (GW_UINT16*)memalign(16, sizeof(GW_UINT16) * idx_count); for (i=0; i<vert_count; i++) { EMD_GetVertexByIndex(mesh, i, &vert_buf[i].x, &vert_buf[i].y, &vert_buf[i].z); EMD_GetTexcoordByIndex(mesh, i, &vert_buf[i].u, &vert_buf[i].v); EMD_GetNormalByIndex(mesh, i, &vert_buf[i].nx, &vert_buf[i].ny, &vert_buf[i].nz); //vert_buf[i].color = 0xffffffff; } GW_UINT32 idx_head = 0; GW_UINT32* data; GW_UINT32 count; // Pack 32-bit index into 16-bit buffer for (i=0; i<elem_count; i++) { count = EMD_GetIndexCount(mesh, i); data = EMD_GetIndexArray(mesh, i); for (j=0; j<count; j++) { idx_buf[j + idx_head] = (GW_UINT16)data[j]; } idx_head += count; } EMD_FreeMesh(mesh); // flush cache so that no stray data remains sceKernelDcacheWritebackAll(); // setup GU void* fbp0 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* fbp1 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* zbp = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_4444); pspDebugScreenInit(); sceGuInit(); sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_8888,fbp0,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,fbp1,BUF_WIDTH); sceGuDepthBuffer(zbp,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(65535,0); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CCW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); //sceGuDisable(GU_TEXTURE_2D); sceGuEnable(GU_CLIP_PLANES); sceGuEnable(GU_LIGHTING); sceGuEnable(GU_LIGHT0); sceGuEnable(GU_LIGHT1); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // run sample int val = 0; while(running()) { sceGuStart(GU_DIRECT,list); // clear screen sceGuClearColor(0xff554433); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup lights ScePspFVector3 light_dir = { 1.0f, 1.0f, 1.0f }; // GU_DIRECTIONAL // GU_POINTLIGHT sceGuLight(0, GU_POINTLIGHT, GU_DIFFUSE, &light_dir); sceGuLightColor(0, GU_DIFFUSE, 0xffffffff); sceGuAmbient(0x00202020); light_dir.x = -light_dir.x; light_dir.y = -light_dir.y; light_dir.z = -light_dir.z; sceGuLight(1, GU_DIRECTIONAL, GU_DIFFUSE_AND_SPECULAR, &light_dir); sceGuLightColor(1, GU_DIFFUSE, 0xff7f7f7f); // setup matrices for cube sceGumMatrixMode(GU_PROJECTION); sceGumLoadIdentity(); sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f); sceGumMatrixMode(GU_VIEW); sceGumLoadIdentity(); sceGumMatrixMode(GU_MODEL); sceGumLoadIdentity(); { ScePspFVector3 pos = { 0, 0, -5.0f }; ScePspFVector3 rot = { val * 0.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f) }; sceGumTranslate(&pos); sceGumRotateXYZ(&rot); } // setup texture //sceGuTexMode(GU_PSM_4444,0,0,0); // sceGuTexImage(0,64,64,64,logo_start); //sceGuTexFunc(GU_TFX_ADD,GU_TCC_RGB); //sceGuTexEnvColor(0xffff00); //sceGuTexFilter(GU_LINEAR,GU_LINEAR); //sceGuTexScale(1.0f,1.0f); //sceGuTexOffset(0.0f,0.0f); //sceGuAmbientColor(0xff7f7f7f); // draw cube sceGuColor(0xffffff); sceGumDrawArray(GU_TRIANGLES, GU_TEXTURE_32BITF|GU_NORMAL_32BITF|GU_VERTEX_32BITF|GU_INDEX_16BIT|GU_TRANSFORM_3D, idx_count, idx_buf, vert_buf); pspDebugScreenSetXY(0, 0); pspDebugScreenPrintf("v: %d", vert_count); pspDebugScreenSetXY(0, 1); pspDebugScreenPrintf("i: %d", idx_count); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuSwapBuffers(); val++; } sceGuTerm(); // Release buffers free(vert_buf); free(idx_buf); sceKernelExitGame(); return 0; }
int main(int argc, char* argv[]) { pspDebugScreenInit(); setupCallbacks(); // setup GU void* fbp0 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* fbp1 = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_8888); void* zbp = getStaticVramBuffer(BUF_WIDTH,SCR_HEIGHT,GU_PSM_4444); sceGuInit(); sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_8888,fbp0,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,fbp1,BUF_WIDTH); sceGuDepthBuffer(zbp,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(65535,0); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); int val = 0; gettimeofday(&base_time,0); while(running()) { struct Vertex* vertices; struct timeval tv; sceGuStart(GU_DIRECT,list); // clear screen sceGuClearColor(0); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // draw triangle 1 (normal) sceGuColor(0xffffffff); vertices = (struct Vertex*)sceGuGetMemory(3*sizeof(struct Vertex)); vertices[0].x = (SCR_WIDTH/2) + cosf(val * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[0].y = (SCR_HEIGHT/2) + sinf(val * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[0].z = 0; vertices[1].x = (SCR_WIDTH/2) + cosf((val+120) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[1].y = (SCR_HEIGHT/2) + sinf((val+120) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[1].z = 0; vertices[2].x = (SCR_WIDTH/2) + cosf((val+240) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[2].y = (SCR_HEIGHT/2) + sinf((val+240) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[2].z = 0; sceGuDrawArray(GU_TRIANGLES,GU_VERTEX_32BITF|GU_TRANSFORM_2D,3,0,vertices); // draw triangle 2 (affected by logic op) sceGuEnable(GU_COLOR_LOGIC_OP); sceGuLogicalOp(curr_state); sceGuColor(0xffff00ff); vertices = (struct Vertex*)sceGuGetMemory(3*sizeof(struct Vertex)); vertices[0].x = (SCR_WIDTH/2) + cosf((val*1.1f) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[0].y = (SCR_HEIGHT/2) + sinf((val*1.1f) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[0].z = 0; vertices[1].x = (SCR_WIDTH/2) + cosf((val*1.1f+120) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[1].y = (SCR_HEIGHT/2) + sinf((val*1.1f+120) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[1].z = 0; vertices[2].x = (SCR_WIDTH/2) + cosf((val*1.1f+240) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[2].y = (SCR_HEIGHT/2) + sinf((val*1.1f+240) * (GU_PI/180)) * (SCR_HEIGHT/2); vertices[2].z = 0; sceGuDrawArray(GU_TRIANGLES,GU_VERTEX_32BITF|GU_TRANSFORM_2D,3,0,vertices); sceGuDisable(GU_COLOR_LOGIC_OP); sceGuFinish(); sceGuSync(0,0); gettimeofday(&tv,0); if ((tv.tv_sec-base_time.tv_sec) > TIME_SLICE) { curr_state = (curr_state + 1) & 15; base_time = tv; } sceDisplayWaitVblankStart(); sceGuSwapBuffers(); pspDebugScreenSetXY(0,0); pspDebugScreenPrintf("%s",names[curr_state]); val++; } sceGuTerm(); sceKernelExitGame(); return 0; }
static bool psp_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg) { static char fps_txt[128], fps_text_buf[128]; psp1_video_t *psp = (psp1_video_t*)data; #ifdef DISPLAY_FPS static uint64_t currentTick,lastTick; static float fps=0.0; static int frames; #endif if (!width || !height) return false; sceGuSync(0, 0); pspDebugScreenSetBase(psp->draw_buffer); pspDebugScreenSetXY(0,0); if(g_settings.fps_show) { gfx_get_fps(fps_txt, sizeof(fps_txt), fps_text_buf, sizeof(fps_text_buf)); pspDebugScreenSetXY(68 - strlen(fps_text_buf) - 1,0); pspDebugScreenPuts(fps_text_buf); pspDebugScreenSetXY(0,1); } else gfx_get_fps(fps_txt, sizeof(fps_txt), NULL, 0); if (msg) pspDebugScreenPuts(msg); if (psp->vsync) sceDisplayWaitVblankStart(); #ifdef DISPLAY_FPS frames++; sceRtcGetCurrentTick(¤tTick); uint32_t diff = currentTick - lastTick; if(diff > 1000000) { fps = (float)frames * 1000000.0 / diff; lastTick = currentTick; frames = 0; } pspDebugScreenSetXY(0,0); pspDebugScreenPrintf("%f", fps); #endif psp->draw_buffer = FROM_GU_POINTER(sceGuSwapBuffers()); g_extern.frame_count++; psp->frame_coords->v0.x = (SCEGU_SCR_WIDTH - width * SCEGU_SCR_HEIGHT / height) / 2; // psp->frame_coords->v0.y = 0; // psp->frame_coords->v0.u = 0; // psp->frame_coords->v0.v = 0; psp->frame_coords->v1.x = (SCEGU_SCR_WIDTH + width * SCEGU_SCR_HEIGHT / height) / 2; // psp->frame_coords->v1.y = SCEGU_SCR_HEIGHT; psp->frame_coords->v1.u = width; psp->frame_coords->v1.v = height; sceGuStart(GU_DIRECT, psp->main_dList); if ((uint32_t)frame&0x04000000) // frame in VRAM ? texture/palette was set in core so draw directly { sceGuClear(GU_COLOR_BUFFER_BIT); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_COLOR_4444 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, (void*)(psp->frame_coords)); } else { if (frame!=NULL) { sceKernelDcacheWritebackRange(frame,pitch * height); sceGuCopyImage(GU_PSM_5650, ((u32)frame & 0xF) >> psp->bpp_log2, 0, width, height, pitch >> psp->bpp_log2, (void*)((u32)frame & ~0xF), 0, 0, width, psp->texture); } sceGuClear(GU_COLOR_BUFFER_BIT); sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->texture); sceGuCallList(psp->frame_dList); }
int main(int argc, char* argv[]) { unsigned int i,j; pspDebugScreenInit(); SetupCallbacks(); #ifdef ENABLE_PROFILER // Enable profiling pspDebugProfilerClear(); pspDebugProfilerEnable(); #endif // initialize global context g_context.iterationCount = NUM_VERTEX_BUFFERS * NUM_ITERATIONS; g_context.t = 0; g_context.sint = 0; // initialize torus for (i = 0; i < NUM_SLICES; ++i) { for (j = 0; j < NUM_ROWS; ++j) { float s = i + 0.5f, t = j; float x,y,z; x = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * cosf(t * ((GU_PI*2)/NUM_ROWS)); y = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * sinf(t * ((GU_PI*2)/NUM_ROWS)); z = RING_RADIUS * sinf(s * ((GU_PI*2)/NUM_SLICES)); torus_vertices[j + i * NUM_ROWS].x = x; torus_vertices[j + i * NUM_ROWS].y = y; torus_vertices[j + i * NUM_ROWS].z = z; } } // initialize torus modifiers for (j = 0; j < NUM_ROWS; ++j) { float t = j; torus_modifiers[j].x = 0; torus_modifiers[j].y = 0; torus_modifiers[j].z = 0.3*cosf( t * 8.0f *((GU_PI*2)/NUM_ROWS) ); } // init GU and set callbacks sceGuInit(); // 0x01 - user callback // 0x04 - 'rendering finished' callback sceGuSetCallback(1, &mySignalHandler); sceGuSetCallback(4, &myFinishHandler); // setup GU sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_8888,(void*)0,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)0x88000,BUF_WIDTH); sceGuDepthBuffer((void*)0x110000,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuAlphaFunc(GU_GREATER,0,0xff); sceGuEnable(GU_ALPHA_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // run sample #ifdef USING_SIGNALS sceGuCallMode(1); #endif // generate callable command-list with texture setup { sceGuStart(GU_CALL, smallList1); // setup texture sceGuTexMode(GU_PSM_5551,0,0,0); sceGuTexImage(0,32,32,32,ball_start); // width, height, buffer width, tbp sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA); // NOTE: this enables reads of the alpha-component from the texture, otherwise blend/test won't work sceGuTexFilter(GU_NEAREST,GU_NEAREST); sceGuTexWrap(GU_CLAMP,GU_CLAMP); sceGuTexScale(1,1); sceGuTexOffset(0,0); sceGuAmbientColor(0xffffffff); sceGuFinish(); sceGuSync(0,0); } // generate callable command-list for cube rendering { sceGuStart(GU_CALL, smallList2); // draw cube sceGuDrawArray(GU_TRIANGLES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_3D,12*3,0,cubeVertices); sceGuFinish(); sceGuSync(0,0); } for(;;) { sceGuStart(GU_DIRECT,list); unsigned int i = 0; for( ; i < NUM_VERTEX_BUFFERS; i++ ) g_context.vbuffer[i] = sceGuGetMemory((NUM_SLICES/g_context.iterationCount) * 2 * NUM_ROWS * sizeof(Vertex)); g_context.vertsRendered = 0; // clear screen sceGuClearColor(0x00334455); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup matrices sceGumMatrixMode(GU_PROJECTION); sceGumLoadIdentity(); sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f); sceGumMatrixMode(GU_VIEW); sceGumLoadIdentity(); sceGumMatrixMode(GU_MODEL); { ScePspFVector3 pos = {0.0f,0.0f,-3.5f}; ScePspFVector3 rot = {g_context.t * 0.3f * (GU_PI/180.0f), g_context.t * 0.7f * (GU_PI/180.0f), g_context.t * 1.3f * (GU_PI/180.0f)}; sceGumLoadIdentity(); sceGumTranslate(&pos); sceGumRotateXYZ(&rot); } sceGumStoreMatrix(&g_context.world); // call pregenerated command-list to setup texture sceGuCallList(smallList1); // start billboard rendering render_billboards(0); // call pregenerated command-list to render cube { ScePspFVector3 scale = {0.3f, 0.3f, 0.3f}; sceGumScale(&scale); } sceGumUpdateMatrix(); sceGuCallList(smallList2); #ifndef USING_SIGNALS // HACK: sceGuFinish() is called inside the signal interupt handler when all rendering job is done // this is done in order to stall GPU if it is ahead of CPU sceGuFinish(); #endif sceGuSync(0,0); #ifndef ENABLE_FRAMERATE // wait for next frame sceDisplayWaitVblankStart(); #endif sceGuSwapBuffers(); pspDebugScreenSetXY(0,0); #ifdef ENABLE_PROFILER // Print profile information to the screen pspDebugProfilerPrint(); #endif #ifdef ENABLE_FRAMERATE // simple frame rate counter static float curr_ms = 1.0f; static struct timeval time_slices[16]; static int t = 0; float curr_fps = 1.0f / curr_ms; t++; float vertsPerSec = g_context.vertsRendered*curr_fps; float kbPerSec = vertsPerSec * sizeof(Vertex) / 1024.0f; gettimeofday(&time_slices[t & 15],0); pspDebugScreenPrintf("fps: %d.%03d ms: %d vert/s: %dK MB/s: %d.%03d",(int)curr_fps, ((int)(curr_fps*1000.0f)%1000), (int)(curr_ms*1000.0f), (int)(vertsPerSec/1000.0f), (int)(kbPerSec/1024.0f), (int)((1000.0f/1024.0f)*((int)kbPerSec%1024)) ); if (!(t & 15)) { struct timeval last_time = time_slices[0]; unsigned int i; curr_ms = 0; for (i = 1; i < 16; ++i) { struct timeval curr_time = time_slices[i]; int curr_time_usec = curr_time.tv_usec + curr_time.tv_sec * 1000000; int last_time_usec = last_time.tv_usec + last_time.tv_sec * 1000000; if( last_time_usec < curr_time_usec ) curr_ms += (( curr_time_usec - last_time_usec ) * (1.0f/1000000.0f)); last_time = time_slices[i]; } curr_ms /= 15.0f; } #endif } sceGuTerm(); sceKernelExitGame(); return 0; }
int main(int argc, char* argv[]) { SetupCallbacks(); // generate geometry genGrid( GRID_ROWS, GRID_COLUMNS, GRID_SIZE, grid_vertices, grid_indices ); genTorus( TORUS_ROWS, TORUS_SLICES, TORUS_RADIUS, TORUS_THICKNESS, torus_vertices, torus_indices ); // flush cache so that no stray data remains sceKernelDcacheWritebackAll(); // setup VRAM buffers void* frameBuffer = (void*)0; const void* doubleBuffer = (void*)0x44000; const void* renderTarget = (void*)0x88000; const void* depthBuffer = (void*)0x110000; // setup GU sceGuInit(); sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_4444,frameBuffer,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)doubleBuffer,BUF_WIDTH); sceGuDepthBuffer((void*)depthBuffer,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuEnable(GU_DITHER); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // setup matrices ScePspFMatrix4 identity; ScePspFMatrix4 projection; ScePspFMatrix4 view; gumLoadIdentity(&identity); gumLoadIdentity(&projection); gumPerspective(&projection,75.0f,16.0f/9.0f,0.5f,1000.0f); { ScePspFVector3 pos = {0,0,-5.0f}; gumLoadIdentity(&view); gumTranslate(&view,&pos); } ScePspFMatrix4 textureProjScaleTrans; gumLoadIdentity(&textureProjScaleTrans); textureProjScaleTrans.x.x = 0.5; textureProjScaleTrans.y.y = -0.5; textureProjScaleTrans.w.x = 0.5; textureProjScaleTrans.w.y = 0.5; ScePspFMatrix4 lightProjection; ScePspFMatrix4 lightProjectionInf; ScePspFMatrix4 lightView; ScePspFMatrix4 lightMatrix; gumLoadIdentity(&lightProjection); gumPerspective(&lightProjection,75.0f,1.0f,0.1f,1000.0f); gumLoadIdentity(&lightProjectionInf); gumPerspective(&lightProjectionInf,75.0f,1.0f,0.0f,1000.0f); gumLoadIdentity(&lightView); gumLoadIdentity(&lightMatrix); // define shadowmap Texture shadowmap = { GU_PSM_4444, 0, 128, 128, 128, sceGeEdramGetAddr() + (int)renderTarget }; // define geometry Geometry torus = { identity, sizeof(torus_indices)/sizeof(unsigned short), torus_indices, torus_vertices, 0xffffff }; Geometry grid = { identity, sizeof(grid_indices)/sizeof(unsigned short), grid_indices, grid_vertices, 0xff7777 }; // run sample int val = 0; for(;;) { // update matrices // grid { ScePspFVector3 pos = {0,-1.5f,0}; gumLoadIdentity(&grid.world); gumTranslate(&grid.world,&pos); } // torus { ScePspFVector3 pos = {0,0.5f,0.0f}; ScePspFVector3 rot = {val * 0.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f)}; gumLoadIdentity(&torus.world); gumTranslate(&torus.world,&pos); gumRotateXYZ(&torus.world,&rot); } // orbiting light { ScePspFVector3 lightLookAt = { torus.world.w.x, torus.world.w.y, torus.world.w.z }; ScePspFVector3 rot1 = {0,val * 0.79f * (GU_PI/180.0f),0}; ScePspFVector3 rot2 = {-(GU_PI/180.0f)*60.0f,0,0}; ScePspFVector3 pos = {0,0,LIGHT_DISTANCE}; gumLoadIdentity(&lightMatrix); gumTranslate(&lightMatrix,&lightLookAt); gumRotateXYZ(&lightMatrix,&rot1); gumRotateXYZ(&lightMatrix,&rot2); gumTranslate(&lightMatrix,&pos); } gumFastInverse(&lightView,&lightMatrix); // render to shadow map { sceGuStart(GU_DIRECT,list); // set offscreen texture as a render target sceGuDrawBufferList(GU_PSM_4444,(void*)renderTarget,shadowmap.stride); // setup viewport sceGuOffset(2048 - (shadowmap.width/2),2048 - (shadowmap.height/2)); sceGuViewport(2048,2048,shadowmap.width,shadowmap.height); // clear screen sceGuClearColor(0xffffffff); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup view/projection from light sceGuSetMatrix(GU_PROJECTION,&lightProjection); sceGuSetMatrix(GU_VIEW,&lightView); // shadow casters are drawn in black // disable lighting and texturing sceGuDisable(GU_LIGHTING); sceGuDisable(GU_TEXTURE_2D); // draw torus to shadow map drawShadowCaster( &torus ); sceGuFinish(); sceGuSync(0,0); } // render to frame buffer { sceGuStart(GU_DIRECT,list); // set frame buffer sceGuDrawBufferList(GU_PSM_4444,(void*)frameBuffer,BUF_WIDTH); // setup viewport sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); // clear screen sceGuClearColor(0xff554433); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup view/projection from camera sceGuSetMatrix(GU_PROJECTION,&projection); sceGuSetMatrix(GU_VIEW,&view); sceGuSetMatrix(GU_MODEL,&identity); // setup a light ScePspFVector3 lightPos = { lightMatrix.w.x, lightMatrix.w.y, lightMatrix.w.z }; ScePspFVector3 lightDir = { lightMatrix.z.x, lightMatrix.z.y, lightMatrix.z.z }; sceGuLight(0,GU_SPOTLIGHT,GU_DIFFUSE,&lightPos); sceGuLightSpot(0,&lightDir, 5.0, 0.6); sceGuLightColor(0,GU_DIFFUSE,0x00ff4040); sceGuLightAtt(0,1.0f,0.0f,0.0f); sceGuAmbient(0x00202020); sceGuEnable(GU_LIGHTING); sceGuEnable(GU_LIGHT0); // draw torus drawGeometry( &torus ); // setup texture projection sceGuTexMapMode( GU_TEXTURE_MATRIX, 0, 0 ); sceGuTexProjMapMode( GU_POSITION ); // set shadowmap as a texture sceGuTexMode(shadowmap.format,0,0,0); sceGuTexImage(shadowmap.mipmap,shadowmap.width,shadowmap.height,shadowmap.stride,shadowmap.data); sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGB); sceGuTexFilter(GU_LINEAR,GU_LINEAR); sceGuTexWrap(GU_CLAMP,GU_CLAMP); sceGuEnable(GU_TEXTURE_2D); // calculate texture projection matrix for shadowmap ScePspFMatrix4 shadowProj; gumMultMatrix(&shadowProj, &lightProjectionInf, &lightView); gumMultMatrix(&shadowProj, &textureProjScaleTrans, &shadowProj); // draw grid receiving shadow drawShadowReceiver( &grid, shadowProj ); sceGuFinish(); sceGuSync(0,0); } sceDisplayWaitVblankStart(); frameBuffer = sceGuSwapBuffers(); val++; } sceGuTerm(); sceKernelExitGame(); return 0; }
static bool psp_frame(void *data, const void *frame, unsigned width, unsigned height, unsigned pitch, const char *msg) { static char fps_txt[128], fps_text_buf[128]; psp1_video_t *psp = (psp1_video_t*)data; #ifdef DISPLAY_FPS static uint64_t currentTick,lastTick; static float fps=0.0; static int frames; #endif if (!width || !height) return false; if (((uint32_t)frame&0x04000000) || (frame == RETRO_HW_FRAME_BUFFER_VALID)) psp->hw_render = true; else if (frame) psp->hw_render = false; if (!psp->hw_render) sceGuSync(0, 0); /* let the core decide when to sync when HW_RENDER */ pspDebugScreenSetBase(psp->draw_buffer); pspDebugScreenSetXY(0,0); video_monitor_get_fps(fps_txt, sizeof(fps_txt), g_settings.fps_show ? fps_text_buf : NULL, g_settings.fps_show ? sizeof(fps_text_buf) : 0); if(g_settings.fps_show) { pspDebugScreenSetXY(68 - strlen(fps_text_buf) - 1,0); pspDebugScreenPuts(fps_text_buf); pspDebugScreenSetXY(0,1); } if (msg) pspDebugScreenPuts(msg); if ((psp->vsync)&&(psp->vblank_not_reached)) sceDisplayWaitVblankStart(); psp->vblank_not_reached = true; #ifdef DISPLAY_FPS frames++; sceRtcGetCurrentTick(¤tTick); uint32_t diff = currentTick - lastTick; if(diff > 1000000) { fps = (float)frames * 1000000.0 / diff; lastTick = currentTick; frames = 0; } pspDebugScreenSetXY(0,0); pspDebugScreenPrintf("%f", fps); #endif psp->draw_buffer = FROM_GU_POINTER(sceGuSwapBuffers()); g_extern.frame_count++; RARCH_PERFORMANCE_INIT(psp_frame_run); RARCH_PERFORMANCE_START(psp_frame_run); if (psp->should_resize) psp_update_viewport(psp); psp_set_tex_coords(psp->frame_coords, width, height); sceGuStart(GU_DIRECT, psp->main_dList); sceGuTexFilter(psp->tex_filter, psp->tex_filter); sceGuClear(GU_COLOR_BUFFER_BIT); /* frame in VRAM ? texture/palette was * set in core so draw directly */ if (psp->hw_render) sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, (void*)(psp->frame_coords)); else { if (frame) { sceKernelDcacheWritebackRange(frame,pitch * height); sceGuCopyImage(GU_PSM_5650, ((u32)frame & 0xF) >> psp->bpp_log2, 0, width, height, pitch >> psp->bpp_log2, (void*)((u32)frame & ~0xF), 0, 0, width, psp->texture); } sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->texture); sceGuCallList(psp->frame_dList); } sceGuFinish(); RARCH_PERFORMANCE_STOP(psp_frame_run); if(psp->menu.active) { sceGuSendList(GU_TAIL, psp->menu.dList, &(psp->menu.context_storage)); sceGuSync(0, 0); } return true; }
void draw() { int x = 10, y = 10; sceDisplaySetMode(0, SCR_WIDTH, SCR_HEIGHT); sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0); sceGuClutLoad(1, clut); drawBG(); // Reset things. sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 0); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x00); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x000000); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x00); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBox(&x, &y); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000); nextBox(&x, &y); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0x00FF00); nextBox(&x, &y); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0x0000FF); nextBox(&x, &y); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBoxHasColor(&x, &y, HASCOLOR_RGBA); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x00); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x00); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGBA); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x80); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x80); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGBA); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBoxHasColor(&x, &y, HASCOLOR_RGB); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGB); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGB); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF); sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10); sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1); nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT); sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0); nextBox(&x, &y); /*ScePspFVector3 pos = {x, y, 0}; sceGuLight(0, GU_DIRECTIONAL, GU_AMBIENT_AND_DIFFUSE, &pos); nextBox(&x, &y); pos.x = x; pos.y = y; sceGuLight(0, GU_DIRECTIONAL, GU_AMBIENT_AND_DIFFUSE, &pos); sceGuLightMode(GU_SINGLE_COLOR); sceGuLightColor(0, GU_AMBIENT, 0x00FF00); sceGuLightAtt(0, 1.0, 1.0, 1.0); nextBox(&x, &y);*/ sceGuFinish(); sceGuSync(GU_SYNC_LIST, GU_SYNC_WHAT_DONE); sceGuSync(0, 0); sceDisplayWaitVblankStart(); }