void pgeTextureActivate(pgeTexture *texture)
{
if(texture->format == PGE_PIXEL_FORMAT_T4)
{
sceGuClutMode(texture->palFormat, 0, 0xff, 0);
sceGuClutLoad(2, texture->palette);
}
else if(texture->format == PGE_PIXEL_FORMAT_T8)
{
sceGuClutMode(texture->palFormat, 0, 0xff, 0);
sceGuClutLoad(32, texture->palette);
}
sceGuEnable(GU_TEXTURE_2D);
sceGuTexWrap(GU_REPEAT, GU_REPEAT);
sceGuTexFilter(GU_NEAREST, GU_NEAREST);
sceGuTexFunc(pgeTextureMode, GU_TCC_RGBA);
sceGuTexEnvColor(0xFFFFFFFF);
sceGuColor(0xFFFFFFFF);
sceGuAmbientColor(0xFFFFFFFF);
sceGuTexOffset(0.0f, 0.0f);
sceGuTexScale(1.0f/(float)texture->textureWidth, 1.0f/(float)texture->textureHeight);
sceGuTexMode(texture->format, 0, 0, texture->swizzled);
sceGuTexImage(0, texture->textureWidth, texture->textureHeight, texture->textureWidth, texture->data);
}
// 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 Texture::use()
{
#ifdef ARCH_PSP
sceGuEnable( GU_TEXTURE_2D );
sceGuTexFilter( GU_LINEAR, GU_LINEAR );
sceGuTexMode( GU_PSM_8888, 0, 0, psp_texture.Swizzled() );
sceGuTexImage( 0, psp_texture.Width(), psp_texture.Height(), psp_texture.Width(), psp_texture.Image() );
sceGuTexFunc( GU_TFX_MODULATE, GU_TCC_RGB );
sceGuTexScale( 1.0f, 1.0f ); // No scaling
sceGuTexOffset( 0.0f, 0.0f );
#else
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,glTexId);
#endif
};
void drawCube( Texture* texture, int val )
{
// setup matrices for cube
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);
sceGumMatrixMode(GU_VIEW);
{
ScePspFVector3 pos = {0.0f,0.0f,-2.5f};
sceGumLoadIdentity();
sceGumTranslate(&pos);
}
sceGumMatrixMode(GU_MODEL);
{
ScePspFVector3 rot = {val * 0.263f * (GU_PI/180.0f), val * 0.32f * (GU_PI/180.0f), val * 0.44f * (GU_PI/180.0f)};
sceGumLoadIdentity();
sceGumRotateXYZ(&rot);
}
// setup texture
sceGuTexMode(texture->format,0,0,0);
sceGuTexImage(texture->mipmap,texture->width,texture->height,texture->stride,texture->data);
sceGuTexFunc(GU_TFX_ADD,GU_TCC_RGB);
sceGuTexFilter(GU_LINEAR,GU_LINEAR);
sceGuTexScale(1.0f,1.0f);
sceGuTexOffset(0.0f,0.0f);
sceGuAmbientColor(0xffffffff);
sceGuEnable(GU_TEXTURE_2D);
// draw cube
sceGumDrawArray(GU_TRIANGLES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_3D,12*3,0,cube_vertices);
sceGuDisable(GU_TEXTURE_2D);
}
void FZTexture::bindForDisplay() {
// support only for main ram textures - very slow
// TODO: investigate vram textures: when and how to
// transfer?
if (texImage->getCLUT() != NULL) {
int n = texImage->getCLUTSize();
sceGuClutMode(GU_PSM_8888, 0, n - 1, 0); // 32-bit palette
sceGuClutLoad((n/8), texImage->getCLUT()); // upload entries (8 colors base unit)
}
sceGuTexFunc(texenv, pixelComponent);
//sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
sceGuTexMode(pixelFormat, 0, 0, GU_TRUE);
//sceGuTexMode(pixelFormat, 0, 0, GU_FALSE);
sceGuTexImage(0, width, height, width, texImage->getData());
sceGuTexScale(1.0f, 1.0f);
sceGuTexOffset(0.0f, 0.0f);
sceGuTexFilter(texMin, texMag);
FZScreen::setBoundTexture((FZTexture*)this);
}
void InitGU( void )
{
// Init GU
sceGuInit();
sceGuStart( GU_DIRECT, dList );
// Set Buffers
sceGuDrawBuffer( GU_PSM_8888, fbp0, 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));
sceGuDepthRange( 65535, 0);
// Set Render States
sceGuScissor( 0, 0, SCR_WIDTH, SCR_HEIGHT);
sceGuEnable( GU_SCISSOR_TEST );
sceGuDepthFunc( GU_GEQUAL );
sceGuEnable( GU_DEPTH_TEST );
sceGuFrontFace( GU_CW );
sceGuEnable( GU_CULL_FACE );
sceGuShadeModel( GU_SMOOTH );
sceGuEnable( GU_CLIP_PLANES );
sceGuEnable( GU_TEXTURE_2D );
sceGuEnable( GU_LIGHTING );
sceGuEnable( GU_LIGHT0 ); // Enable Light 1 (NEW)
// setup texture
// 32-bit image, if we swizzled the texture will return true, otherwise false (NEW)
sceGuTexMode( GU_PSM_8888, 0, 0, true );
sceGuTexFunc( GU_TFX_MODULATE, GU_TCC_RGB ); // Modulate the color of the image
sceGuTexScale( 1.0f, 1.0f ); // No scaling
sceGuTexOffset( 0.0f, 0.0f );
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
// finish
}
int dxpGraphicsInit()
{
u32 i;
//構造体初期化
if(dxpGraphicsData.init)return 0;
{//深度バッファの初期化
dxpGraphicsData.depthbuffer.psm = GU_PSM_4444;
dxpGraphicsData.depthbuffer.ppalette = NULL;
dxpGraphicsData.depthbuffer.texdata = NULL;
dxpGraphicsData.depthbuffer.width = 480;
dxpGraphicsData.depthbuffer.height = 272;
dxpGraphicsData.depthbuffer.pitch = 512;
dxpGraphicsData.depthbuffer.umax = 480;
dxpGraphicsData.depthbuffer.vmax = 272;
dxpGraphicsData.depthbuffer.colorkey = 0;
dxpGraphicsData.depthbuffer.size2_nflag = 0;
dxpGraphicsData.depthbuffer.swizzledflag = 1;
dxpGraphicsData.depthbuffer.reloadflag = 1;
dxpGraphicsData.depthbuffer.alphabit = 0;
dxpGraphicsData.depthbuffer.refcount = 0;
dxpGraphicsData.depthbuffer.thisptrptr = NULL;
if(dxpGraphicsData.usedepth || dxpGraphicsData.usedepth3d)
{
dxpGraphicsData.depthbuffer.texvram = valloc(vgetMemorySize(512,272,GU_PSM_4444));
if(!dxpGraphicsData.depthbuffer.texvram)return -1;
}else dxpGraphicsData.depthbuffer.texvram = NULL;
}
for(i = 0;i < 2;++i)
{//フレームバッファの初期化
dxpGraphicsData.displaybuffer[i].psm = dxpGraphicsData.display_psm;
dxpGraphicsData.displaybuffer[i].ppalette = NULL;
dxpGraphicsData.displaybuffer[i].texdata = NULL;
dxpGraphicsData.displaybuffer[i].texvram = valloc(vgetMemorySize(512,272,dxpGraphicsData.display_psm));
dxpGraphicsData.displaybuffer[i].width = 480;
dxpGraphicsData.displaybuffer[i].height = 272;
dxpGraphicsData.displaybuffer[i].pitch = 512;
// dxpGraphicsData.displaybuffer[i].pitch = 480;//試したら見事に駄目だったｗ
dxpGraphicsData.displaybuffer[i].umax = 480;
dxpGraphicsData.displaybuffer[i].vmax = 272;
dxpGraphicsData.displaybuffer[i].colorkey = 0;
dxpGraphicsData.displaybuffer[i].size2_nflag = 0;
dxpGraphicsData.displaybuffer[i].swizzledflag = 0;
dxpGraphicsData.displaybuffer[i].reloadflag = 1;
dxpGraphicsData.displaybuffer[i].alphabit = 0;
dxpGraphicsData.displaybuffer[i].refcount = 0;
}
if(!dxpGraphicsData.displaybuffer[0].texvram || !dxpGraphicsData.displaybuffer[1].texvram)
{
vfree(dxpGraphicsData.displaybuffer[0].texvram);
vfree(dxpGraphicsData.displaybuffer[1].texvram);
vfree(dxpGraphicsData.depthbuffer.texvram);
return -1;
}
dxpGraphicsData.displaybuffer_back = &dxpGraphicsData.displaybuffer[0];
dxpGraphicsData.rendertarget = dxpGraphicsData.displaybuffer_back;
dxpGraphicsData.texture = NULL;
dxpGraphicsData.clear_color_value = 0;
dxpGraphicsData.clear_depth_value = 0;
dxpGraphicsData.clear_stencil_value = 0;
dxpGraphicsData.gustarted = 0;
dxpGraphicsData.clear_depth = 0;
dxpGraphicsData.clear_stencil = 0;
dxpGraphicsData.bilinear_enable = 0;
dxpGraphicsData.create_vram_graph = 1;
dxpGraphicsData.create_swizzled_graph = 1;
dxpGraphicsData.colorkey = 0;
dxpGraphicsData.blendmode = DX_BLENDMODE_NOBLEND;
dxpGraphicsData.drawstate = DXP_DRAWSTATE_EITHER;
dxpGraphicsData.flag = 0xffffffff;
dxpGraphicsData.forceupdate = 1;
dxpGraphicsData.z_2d = 0;
dxpGraphicsData.color = 0xffffffff;
//dxpGraphicsData.usedepth = 0;
//dxpGraphicsData.usedepth3d = 0;
dxpGraphicsData.writedepth = 0;
dxpGraphicsData.writedepth3d = 0;
dxpGraphicsData.fog_color = 0xffffffff;
dxpGraphicsData.fog_near = 10.0f;
dxpGraphicsData.fog_far = 100.0f;
dxpGraphicsData.intrafont_scissor[0] = 0;
dxpGraphicsData.intrafont_scissor[1] = 0;
dxpGraphicsData.intrafont_scissor[2] = 480;
dxpGraphicsData.intrafont_scissor[3] = 272;
dxpGraphicsData.depthfunc = GU_GEQUAL;
for(i = 0;i < DXP_BUILDOPTION_TEXTURE_MAXNUM;++i)dxpGraphicsData.texarray[i] = NULL;
for(i = 0;i < DXP_BUILDOPTION_GHANDLE_MAXNUM;++i)dxpGraphicsData.grapharray[i] = NULL;
//GEのセットアップ
sceGuInit();
GUSTART
sceGuDrawBuffer(dxpGraphicsData.display_psm,vGuPointer(dxpGraphicsData.displaybuffer[0].texvram),dxpGraphicsData.displaybuffer[0].pitch);
sceGuDispBuffer(480,272,vGuPointer(dxpGraphicsData.displaybuffer[1].texvram),dxpGraphicsData.displaybuffer[1].pitch);
sceGuOffset(2048 - (480/2),2048 - (272/2));
sceGuViewport(2048,2048,480,272);
sceGuScissor(
dxpGraphicsData.intrafont_scissor[0],
dxpGraphicsData.intrafont_scissor[1],
dxpGraphicsData.intrafont_scissor[2],
dxpGraphicsData.intrafont_scissor[3]
);
sceGuClearDepth(0);
sceGuDepthRange(65535,0);
sceGuEnable(GU_SCISSOR_TEST);
sceGuFrontFace(GU_CW);
sceGuShadeModel(GU_FLAT);
sceGuTexScale(1.0f,1.0f);
sceGuTexOffset(0.0f,0.0f);
sceGuTexFilter(GU_NEAREST,GU_NEAREST);
sceGuTexWrap(GU_CLAMP,GU_CLAMP);
/*
memo
カメラ位置（画面横幅/2,画面縦幅/2,画面縦幅/(2 * tan(fovy)))
注視点位置（画面横幅/2,画面縦幅/2,1)
上 （0,1,0）
*/
#ifndef DXP_BUILDOPTION_NO3D
VECTOR v[3] = {{240,136,-235.5589f},{240,136,0},{0,1,0}};
SetCameraPositionAndTargetAndUpVec(v[0],v[1],v[2]);
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
dxpGraphicsData.camera.aspect = 480.0f / 272.0f;
dxpGraphicsData.camera.near = 0.5f;
dxpGraphicsData.camera.far = 1000.0f;
dxpGraphicsData.camera.fov = 60;
dxpGraphics3dUpdateProjectionMatrix();
#endif
GUFINISH;
sceDisplayWaitVblankStart();
GUSTART;
sceGuDisplay(GU_TRUE);
dxpGraphicsData.init = 1;
return 0;
}
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 S9xSceGURenderTex (char *tex, int width, int height, int x, int y, int xscale, int yscale, int xres, int yres)
{
// If you don't call this, Gu will run into cache problems with
// reading pixel data...
sceKernelDcacheWritebackAll ();
unsigned int j;
const int slice_scale = ((float)xscale / (float)width) * (float)SLICE_SIZE;
const int tex_filter = (PSP_Settings.bBilinearFilter ? GU_LINEAR :
GU_NEAREST);
struct Vertex* vertices;
struct Vertex* vtx_iter;
// If the x/y scale matches the width/height, we can take a shortcut and
// merely copy tex into the VRAM at the given (x,y) coordinate.
//
// NOTE: This disables bilinear filtering, but that's not saying a whole
// lot, since the image will not require a min / mag filter.
if ((xscale == width) && (yscale == height)) {
sceGuStart (0, SceGU.list);
sceGuCopyImage (SceGU.pixel_format, 0, 0, xres, yres, width, tex, x, y,
SceGU.line_size,
(void *)(0x04000000 + (uint32)SceGU.vram_offset));
sceGuFinish ();
}
// If the scale doesn't match the width/height, we have to perform a
// special blit to stretch the image.
else {
#ifdef SCEGU_DIRECT_COPY
sceGuStart (0, SceGU.list);
sceGuCopyImage (SceGU.pixel_format, 0, 0, width, height, width, tex, 0, 0,
SceGU.line_size,
(void *)(0x04000000 + (uint32)SceGU.vram_offset));
#endif
sceGuStart (0, SceGU.list);
sceGuTexMode (SceGU.texture_format, 0, 0, 0);
#ifndef SCEGU_DIRECT_COPY
sceGuTexImage (0, width, height, width, tex);
#else
sceGuTexImage (0, width, height, SceGU.line_size, (void *)(0x04000000 + (uint32)SceGU.vram_offset));
#endif
sceGuTexFunc (GU_TFX_REPLACE, 0);
sceGuTexFilter (tex_filter, tex_filter);
sceGuTexScale (1, 1);
sceGuTexOffset (0, 0);
sceGuAmbientColor (0xffffffff);
sceGuScissor (x, y, xres, yres);
#ifdef DRAW_SINGLE_BATCH
// Allocate (memory map) the "vertex array" beforehand
const int num_verts = (width / SLICE_SIZE) * 2;
const int vtx_alloc = num_verts * sizeof (struct Vertex);
vertices = (struct Vertex *)sceGuGetMemory (vtx_alloc);
vtx_iter = vertices;
#endif
// Do a striped blit (takes the page-cache into account)
for (j = 0; j < width; j += SLICE_SIZE, x += slice_scale)
{
#ifndef DRAW_SINGLE_BATCH
vtx_iter = (struct Vertex *)sceGuGetMemory (sizeof (struct Vertex) * 2);
#endif
vtx_iter [0].u = j; vtx_iter [0].v = 0;
vtx_iter [0].x = x; vtx_iter [0].y = y; vtx_iter [0].z = 0;
vtx_iter [1].u = (j + SLICE_SIZE); vtx_iter [1].v = height;
vtx_iter [1].x = (x + slice_scale); vtx_iter [1].y = (y + yscale); vtx_iter [1].z = 0;
vtx_iter [0].color = vtx_iter [1].color = 0;
#ifndef DRAW_SINGLE_BATCH
sceGuDrawArray (GU_SPRITES, SceGU.tt | SceGU.ct | SceGU.mt | SceGU.dm, 2, 0, vtx_iter);
vtx_iter += 2;
#endif
}
#ifdef DRAW_SINGLE_BATCH
sceGuDrawArray (GU_SPRITES, GE_SETREG_VTYPE (SceGU.tt,
SceGU.ct,
0,
SceGU.mt,
0, 0, 0, 0,
SceGU.dm),
num_verts,
0,
vertices);
#endif
sceGuFinish ();
}
#ifdef SCEGU_DOUBLE_BUFFERED
sceGuSync (0, 0);
if (PSP_Settings.bVSync)
sceDisplayWaitVblankStart ();
#endif
#ifdef SCEGU_DOUBLE_BUFFERED
S9xSceGUSwapBuffers ();
#endif
}
static void dod_init_gu()
{
void* pDrawBuffer = dod_get_static_vram_buffer(DOD_BUFFER_WIDTH, DOD_SCREEN_HEIGHT, GU_PSM_8888);
void* pDispBuffer = dod_get_static_vram_buffer(DOD_BUFFER_WIDTH, DOD_SCREEN_HEIGHT, GU_PSM_8888);
void* pZBuffer = dod_get_static_vram_buffer(DOD_BUFFER_WIDTH, DOD_SCREEN_HEIGHT, GU_PSM_4444);
sceGuInit();
sceGuStart(GU_DIRECT, s_list);
sceGuDrawBuffer(GU_PSM_8888, pDrawBuffer, DOD_BUFFER_WIDTH);
sceGuDispBuffer(DOD_SCREEN_WIDTH, DOD_SCREEN_HEIGHT, pDispBuffer, DOD_BUFFER_WIDTH);
sceGuDepthBuffer(pZBuffer, DOD_BUFFER_WIDTH);
sceGuOffset(2048 - (DOD_SCREEN_WIDTH / 2), 2048 - (DOD_SCREEN_HEIGHT / 2));
sceGuViewport(2048, 2048, DOD_SCREEN_WIDTH, DOD_SCREEN_HEIGHT);
sceGuDepthRange(65535, 0);
sceGuScissor(0, 0, DOD_SCREEN_WIDTH, DOD_SCREEN_HEIGHT);
sceGuEnable(GU_SCISSOR_TEST);
sceGuEnable(GU_CULL_FACE);
sceGuFrontFace(GU_CCW);
sceGuShadeModel(GU_SMOOTH);
//sceGuDepthFunc(GU_GEQUAL);
//sceGuDepthMask(GU_TRUE); // disable z-writes
//sceGuEnable(GU_DEPTH_TEST);
sceGuEnable(GU_TEXTURE_2D);
//sceGuEnable(GU_CLIP_PLANES);
sceGuDisable(GU_COLOR_TEST);
sceGuDisable(GU_ALPHA_TEST);
sceGuDisable(GU_CLIP_PLANES);
// Lighting
sceGuDisable(GU_LIGHTING);
sceGuDisable(GU_LIGHT0);
sceGuDisable(GU_LIGHT1);
sceGuDisable(GU_LIGHT2);
sceGuDisable(GU_LIGHT3);
// Texturing
sceGuTexWrap(GU_CLAMP, GU_CLAMP);
sceGuTexFilter(GU_LINEAR, GU_LINEAR);
sceGuTexOffset(0.f, 0.f);
sceGuTexScale(1.f, 1.f);
//sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
//sceGuTexEnvColor(0xffffffff);
//sceGuColor(0xffffffff);
//sceGuAmbientColor(0xffffffff);
// Blending
//sceGuEnable(GU_BLEND);
//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);
sceGuDisable(GU_DITHER);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
}
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;
}
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[]) {
/* Setup Homebutton Callbacks */
setupCallbacks();
sceKernelDcacheWritebackAll();
// setup GU
SceCtrlData pad;
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
sceGuInit();
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);
sceGuDepthFunc(GU_GEQUAL);
sceGuEnable(GU_DEPTH_TEST);
sceGuFrontFace(GU_CCW);
sceGuColor(0xffffffff);
sceGuShadeModel(GU_SMOOTH);
// sceGuEnable(GU_CULL_FACE);
sceGuEnable(GU_CLIP_PLANES);
sceGuEnable(GU_TEXTURE_2D);
sceGuTexMode(GU_PSM_8888, 0, 0, 0);
sceGuTexImage(0, 16, 16, 16, texture);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
sceGuTexEnvColor(0xffffff);
sceGuTexFilter(GU_LINEAR, GU_LINEAR);
sceGuTexWrap(GU_REPEAT, GU_REPEAT);
sceGuTexScale(1.0f, 1.0f);
sceGuTexOffset(0.0f, 0.0f);
sceGuAmbientColor(0xffffffff);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
void* buffer = 0;
pspDebugScreenInit();
unsigned int old = 0;
unsigned int flags = PSP_CTRL_CIRCLE | PSP_CTRL_CROSS;
int tex = 1;
while(running()) {
sceGuStart(GU_DIRECT,list);
sceGuClearColor(0);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(90.0f, 480.0/272.0f, 0.1f, 10.0f);
sceGumMatrixMode(GU_VIEW);
sceGumLoadIdentity();
ScePspFVector3 trans = { 0.0f, 0.0f, -1.8f };
sceGumTranslate(&trans);
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
sceGumDrawArray(objects[o].prim, objects[o].flags, objects[o].count, 0, objects[o].data);
sceCtrlReadBufferPositive(&pad, 1);
if(old != pad.Buttons) {
if(pad.Buttons & PSP_CTRL_CROSS) {
o++;
if(o >= sizeof(objects) / sizeof(Object)) {
o = 0;
}
}
if(pad.Buttons & PSP_CTRL_CIRCLE) {
tex = !tex;
if(tex) {
sceGuEnable(GU_TEXTURE_2D);
} else {
sceGuDisable(GU_TEXTURE_2D);
}
}
}
old = pad.Buttons;
sceGuFinish();
sceGuSync(0,0);
pspDebugScreenSetOffset((int)buffer);
pspDebugScreenSetXY(0, 0);
pspDebugScreenPrintf("Mode: %s (X to change) Texture: %s (O to change)", objects[o].text, tex ? "on " : "off");
sceDisplayWaitVblankStart();
buffer = sceGuSwapBuffers();
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
