void ya2d_drawRotateTexture(ya2d_Texture *texp, int x, int y, float angle)
{
if(!texp->data) return;
sceGuEnable(GU_TEXTURE_2D);
sceGuTexMode(texp->texPSM, 0, 0, texp->isSwizzled);
sceGuTexFunc(GU_TFX_REPLACE, texp->hasAlpha ? GU_TCC_RGBA : GU_TCC_RGB);
ya2d_setTexture(texp);
sceGumPushMatrix();
sceGumLoadIdentity();
{
ScePspFVector3 pos = {x + (float)texp->centerX, y + (float)texp->centerY, 0.0f};
sceGumTranslate(&pos);
sceGumRotateZ(angle);
}
ya2d_FloatTextureVertex *vertices = (ya2d_FloatTextureVertex *)sceGuGetMemory(4 * sizeof(ya2d_FloatTextureVertex));
vertices[0] = (ya2d_FloatTextureVertex){0.0f, 0.0f, (float)-texp->centerX, (float)-texp->centerY, 0.0f};
vertices[1] = (ya2d_FloatTextureVertex){0.0f, 1.0f, (float)-texp->centerX, (float)texp->centerY, 0.0f};
vertices[2] = (ya2d_FloatTextureVertex){1.0f, 0.0f, (float)texp->centerX, (float)-texp->centerY, 0.0f};
vertices[3] = (ya2d_FloatTextureVertex){1.0f, 1.0f, (float)texp->centerX, (float)texp->centerY, 0.0f};
sceGumDrawArray(GU_TRIANGLE_STRIP, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_3D, 4, 0, vertices);
sceKernelDcacheWritebackRange(vertices, 4 * sizeof(ya2d_FloatTextureVertex));
sceGumPopMatrix();
}
void RenderCube(unsigned char x, unsigned char y, unsigned char z)
{
ScePspFVector3 vec;
//printf("FrontEnd::RenderCube() started\n");
vec.x = -(float)x;
vec.y = -(float)y;
vec.z = -(float)z;
sceGumTranslate(&vec);
sceGumDrawArray(SCEGU_PRIM_TRIANGLES, SCEGU_VERTEX_FLOAT, 36, 0, Cube);
}
void drawTorus( int val )
{
// setup a light
ScePspFVector3 dir = { 0, 0, 1 };
sceGuLight(0,GU_DIRECTIONAL,GU_DIFFUSE,&dir);
sceGuLightColor(0,GU_DIFFUSE,0x00ff4040 );
sceGuLightAtt(0,1.0f,0.0f,0.0f);
sceGuAmbient(0x00202020);
// setup texture
sceGuDisable(GU_TEXTURE_2D);
sceGuEnable(GU_LIGHTING);
sceGuEnable(GU_LIGHT0);
// setup matrices for torus
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.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f)};
sceGumLoadIdentity();
sceGumRotateXYZ(&rot);
}
// draw torus
sceGuColor(0xffffff);
sceGumDrawArray(GU_TRIANGLES,GU_NORMAL_32BITF|GU_VERTEX_32BITF|GU_INDEX_16BIT|GU_TRANSFORM_3D,sizeof(torus_indices)/sizeof(unsigned short),torus_indices,torus_vertices);
// restore state
sceGuDisable(GU_LIGHTING);
sceGuDisable(GU_LIGHT0);
sceGuEnable(GU_TEXTURE_2D);
}
void Sprite::Draw()
{
sceGumPushMatrix();
ScePspFVector3 loc = {posX,posY,0.0f};
sceGumTranslate(&loc);
sceGuEnable(GU_TEXTURE_2D);
TextureManager::Instance()->SetTexture(imageName,GU_NEAREST,GU_NEAREST);
sceGumDrawArray(GU_TRIANGLE_STRIP,GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_3D, 4, 0, vertices);
sceGuDisable(GU_TEXTURE_2D);
sceGumPopMatrix();
}
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 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 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;
}
/**
* Created: 01/03/2011
* Renders a cube to the demo space according to it's game location
*/
void FrontEnd::RenderCube(float x, float y, float z)
{
#ifdef PC
/* Set the colour */
_pd3dDevice->SetRenderState( D3DRS_AMBIENT, IntToD3DColor( _fgColour ) );
D3DXMATRIXA16 rotation;
D3DXMATRIXA16 world;
D3DXMATRIXA16 temp;
D3DXMatrixIdentity( &rotation );
D3DXMatrixIdentity( &world );
/* Create the rotation matrix */
D3DXMatrixIdentity( &temp );
D3DXMatrixRotationX( &temp, _rotation.y );
rotation *= temp;
D3DXMatrixRotationY( &temp, _rotation.z );
rotation *= temp;
D3DXMatrixRotationZ( &temp, _rotation.x );
rotation *= temp;
/* Translate the cube */
D3DXMatrixIdentity( &temp );
D3DXMatrixTranslation( &temp, -x, -y, z );
world *= temp;
/* Rotate the cube */
D3DXMatrixIdentity( &temp );
D3DXMatrixTranslation( &temp, _view.x, _view.y, -_view.z );
world *= temp;
world *= rotation;
D3DXMatrixIdentity( &temp );
D3DXMatrixTranslation( &temp, -_view.x, -_view.y, _view.z );
world *= temp;
/* Set the world matrix */
_pd3dDevice->SetTransform( D3DTS_WORLD, &world );
/* Render the cube */
_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 36 );
#else
ScePspFVector3 vec;
/* Create the rotation matrix */
ScePspFMatrix4 rotation;
ScePspFVector3 rotator;
rotator.x = _rotation.x;
rotator.y = _rotation.y;
rotator.z = _rotation.z;
sceGumPushMatrix();
sceGumRotateXYZ( &rotator );
sceGumStoreMatrix( &rotation);
sceGumPopMatrix();
/* Push a new matrix */
sceGumPushMatrix();
//printf("FrontEnd::RenderCube() started\n");
/* Rotate the cube's translation */
ScePspFVector3 view;
view.x = -_view.x;
view.y = -_view.y;
view.z = -_view.z;
sceGumTranslate( &view );
sceGumRotateXYZ( &rotator );
view.x = -view.x;
view.y = -view.y;
view.z = -view.z;
sceGumTranslate( &view );
vec.x = (float)-x;
vec.y = (float)-y;
vec.z = (float)-z;
sceGumTranslate( &vec );
/* Set the colour */
sceGuColor( _fgColour );
/* Render the cube */
sceGumDrawArray(SCEGU_PRIM_TRIANGLES, SCEGU_VERTEX_FLOAT, 36, 0, Cube);
/* Pop the matrix */
sceGumPopMatrix();
#endif
}
/**
* 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;
}
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;
}
int main(int argc, char* argv[])
{
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(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_CLIP_PLANES);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuDisplay(GU_TRUE);
setupSH();
indicesSH();
// run sample
int val = 0;
while(running())
{
sceGuStart(GU_DIRECT,list);
// clear screen
sceGuClearColor(0x000000);
sceGuClearDepth(0);
sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT);
// light settings
sceGuEnable(GU_LIGHTING);
sceGuEnable(GU_LIGHT0);
sceGuEnable(GU_LIGHT1);
sceGuEnable(GU_LIGHT2);
sceGuLightMode(1);
{
unsigned int i;
for (i = 0; i < 3; ++i)
{
sceGuLight(i,GU_DIRECTIONAL,GU_DIFFUSE_AND_SPECULAR,&lsettings[i].position);
sceGuLightColor(i,GU_DIFFUSE,lsettings[i].diffuse);
sceGuLightColor(i,GU_SPECULAR,lsettings[i].specular);
sceGuLightAtt(i,0.0f,1.0f,0.0f);
}
sceGuSpecular(12.0f);
sceGuAmbient(0x000000);
}
// setup matrices
sceGumMatrixMode(GU_PROJECTION);
sceGumLoadIdentity();
sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f);
sceGumMatrixMode(GU_VIEW);
{
ScePspFVector3 pos = { 0, 0, -5.0f };
sceGumLoadIdentity();
sceGumTranslate(&pos);
}
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
{
ScePspFVector3 rot = { val * 0.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f) };
sceGumRotateXYZ(&rot);
}
// setup texture
sceGuAmbientColor(0xffffffff);
// draw
renderSH(parametersSH);
sceGuFinish();
sceGuSync(0,0);
sceDisplayWaitVblankStart();
sceGuSwapBuffers();
val++;
if ((val%600) == 0)
{
unsigned int i;
for (i = 0; i < 8; ++i)
parametersSH[i] = (int)((rand() / ((float)RAND_MAX)) * 6.0f);
}
}
sceGuTerm();
sceKernelExitGame();
return 0;
}
//--------------------------------------------------------------------
// Función: CParticles::Update
// Creador: Nacho (AMD)
// Fecha: Wednesday 14/02/2007 19:48:41
//--------------------------------------------------------------------
void CParticles::Update(float dt, CLevel* pTheLevel, CSound* pSoundPlayer)
{
CVideo * pVideo = CVideo::GetSingleton();
m_fAngType3 += (240.0f * dt);
m_fAngType3 = MAT_NormalizarAngulo360(m_fAngType3);
CBall* pBall = pTheLevel->GetBall();
CSmoke* pSmoke = pTheLevel->GetSmoke();
VECTOR3 vecBallPos = pBall->GetPosition();
VECTOR2 vecBallVel = pBall->GetVelocity();
float fBallRadius = pBall->GetRadius();
sceGuEnable(GU_BLEND);
sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);
ENEMY* pEnemies = pTheLevel->GetEnemies();
int iNumEnemies = pTheLevel->GetNumEnemies();
///--- TIPO 0: Disparo amarillo
//////////////////////////////////////////////////////////////////////
pVideo->EnableTexture(m_pTexture[0]);
for (int i=0; i<MAX_PARTICLES; i++)
{
if (m_pParticleArray[0][i].enable)
{
m_pParticleArray[0][i].timeStamp += dt;
if (m_pParticleArray[0][i].timeStamp >= 5.0f)
{
m_pParticleArray[0][i].enable = false;
m_pParticleArray[0][i].next = m_iFreeSlot[0];
m_iFreeSlot[0] = i;
continue;
}
m_pParticleArray[0][i].pos.x += m_pParticleArray[0][i].vel.x * dt;
m_pParticleArray[0][i].pos.y += m_pParticleArray[0][i].vel.y * dt;
stCollisionData data;
data.radius = 1.0f;
data.x = m_pParticleArray[0][i].pos.x;
data.y = m_pParticleArray[0][i].pos.y;
data.velX = m_pParticleArray[0][i].vel.x;
data.velY = m_pParticleArray[0][i].vel.y;
if (pTheLevel->TestCollision(&data, false))
{
m_pParticleArray[0][i].pos.x = data.x;
m_pParticleArray[0][i].pos.y = data.y;
m_pParticleArray[0][i].vel.x = data.velX;
m_pParticleArray[0][i].vel.y = data.velY;
}
for (int a=0; a<iNumEnemies; a++)
{
if (pEnemies[a].active)
{
///--- sierra
///--- rebota
if ((pEnemies[a].type == 0) || (pEnemies[a].type == 3))
{
VECTOR3 vDis;
VECTOR3 vTemp = {m_pParticleArray[0][i].pos.x, m_pParticleArray[0][i].pos.y, 4.0f};
VECTOR3 vTemp2 = {pEnemies[a].posX + 4.0f, pEnemies[a].posY + 4.0f, 4.0f};
MAT_VectorSubtract(&vDis, &vTemp2, &vTemp);
float length = MAT_VectorQuadraticLength(&vDis);
if (length < 6.25f)
{
m_pParticleArray[0][i].enable = false;
m_pParticleArray[0][i].next = m_iFreeSlot[0];
m_iFreeSlot[0] = i;
pSmoke->AddExplosion(vTemp2, 20.0f, true);
pEnemies[a].active = false;
pSoundPlayer->Play(SOUND_ENE_EXPLO);
break;
}
}
///--- dirigidos
///--- rectos
else if ((pEnemies[a].type == 1) || (pEnemies[a].type == 2))
{
VECTOR3 vTemp = {0};
if (pEnemies[a].rot==0)
{
vTemp.x = pEnemies[a].posX+2.0f;
vTemp.y = pEnemies[a].posY+4.0f;
}
else if (pEnemies[a].rot==3)
{
vTemp.x = pEnemies[a].posX+4.0f;
vTemp.y = pEnemies[a].posY+2.0f;
}
else if (pEnemies[a].rot==2)
{
vTemp.x = pEnemies[a].posX+6.0f;
vTemp.y = pEnemies[a].posY+4.0f;
}
else if (pEnemies[a].rot==1)
{
vTemp.x = pEnemies[a].posX+4.0f;
vTemp.y = pEnemies[a].posY+6.0f;
}
vTemp.z = 4.0f;
VECTOR3 vDis;
VECTOR3 vTemp2 = {m_pParticleArray[0][i].pos.x, m_pParticleArray[0][i].pos.y, 4.0f};
MAT_VectorSubtract(&vDis, &vTemp, &vTemp2);
float disx = vecBallPos.x - m_pParticleArray[0][i].pos.x,;
float length = MAT_VectorQuadraticLength(&vDis);
if (length < 6.0f)
{
m_pParticleArray[0][i].enable = false;
m_pParticleArray[0][i].next = m_iFreeSlot[0];
m_iFreeSlot[0] = i;
pSmoke->AddExplosion(vTemp, 20.0f, true);
pEnemies[a].active = false;
pSoundPlayer->Play(SOUND_ENE_EXPLO);
int pan = 127;
if (disx < 0.0f)
{
if (disx < -32.0f)
{
pan = 255;
}
else
{
pan = MAT_Clamp(128 + (int)(((-disx) / 32.0f) * 127.0f), 128, 255);
}
}
else
{
if (disx > 32.0f)
{
pan = 0;
}
else
{
pan = MAT_Clamp((int)(127.0f - ((disx / 32.0f) * 127.0f)), 0, 127);
}
}
pSoundPlayer->Play(SOUND_ENE_EXPLO, pan);
break;
}
}
}
}
if (!m_pParticleArray[0][i].enable)
continue;
///--- render
sceGumMatrixMode(GU_MODEL);
sceGumLoadIdentity();
{
VECTOR3 pos = { m_pParticleArray[0][i].pos.x -1.0f,
-(m_pParticleArray[0][i].pos.y + 1.0f), 4.0f };
VECTOR3 scale = { 2.0f, 2.0f, 2.0f };
sceGumTranslate(&pos);
sceGumScale(&scale);
}
if (m_pParticleArray[0][i].timeStamp >= 4.0f)
{
int alpha = (int)MAT_Clampf((5.0f - m_pParticleArray[0][i].timeStamp) * 255.0f, 0.0f, 255.0f);
sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
sceGuAmbientColor(COLOR_ARGB(alpha, 255, 255, 255));
m_pQuad->Render();
sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, COLOR_ARGB(alpha, alpha, alpha, alpha), 0xffffffff);
m_pQuad->Render();
sceGuAmbientColor(0xffffffff);
}
else
{
sceGuAmbientColor(0xffffffff);
m_pQuad->Render();
sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0xffffffff, 0xffffffff);
m_pQuad->Render();
}
sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0);
}
void Drop::Render(Vector3 playerPos, float camAngle)
{
if(abs(position.x-playerPos.x) < 8.0f && abs(position.y-playerPos.y) < 5.0f && abs(position.z-playerPos.z) < 8.0f)
{
active = true;
}
else
{
active = false;
}
if(toDestroy == false && getMe == false && active == true)
{
if(abs(position.x-playerPos.x) < 0.8f && abs(position.y-playerPos.y) < 1.8f && abs(position.z-playerPos.z) < 0.8f && existingTime >= 0.5f && myCrft->InventoryIsFull(id,amount,stackable) == false && myCrft->HP > 0.0f)
{
getMe = true;
return;
}
float angle = atan2f(position.x-(playerPos.x+(cosf(camAngle+PI)*4)),position.z-(playerPos.z+(sinf(camAngle+PI)*4)))-PI*0.5f;
sceGuColor(GU_COLOR(myCrft->BlockFinalLight(position.x,position.y,position.z),myCrft->BlockFinalLight(position.x,position.y,position.z),myCrft->BlockFinalLight(position.x,position.y,position.z),1.0f));
sceGuEnable(GU_DEPTH_TEST);
sceGuEnable(GU_ALPHA_TEST);
sceGuEnable(GU_BLEND);
if(id < 250)
{
sceGumPushMatrix();
ScePspFVector3 loc = {position.x,position.y+sinf(levit)*0.09f,position.z};
sceGumTranslate(&loc);
ScePspFVector3 sca = {0.25f,0.25f,0.25f};
sceGumScale(&sca);
sceGumRotateX(0.0f);
sceGumRotateY(angleBlock);
sceGumRotateZ(0.0f);
myCrft->drawCubes(id,myCrft->BlockFinalLight(position.x,position.y,position.z));
sceGumPopMatrix();
if(amount >= 3 && stackable == true)
{
sceGumPushMatrix();
ScePspFVector3 loc = {position.x+0.09f,position.y+sinf(levit)*0.09f+0.09f,position.z};
sceGumTranslate(&loc);
ScePspFVector3 sca = {0.25f,0.25f,0.25f};
sceGumScale(&sca);
sceGumRotateX(0.0f);
sceGumRotateY(angleBlock);
sceGumRotateZ(0.0f);
myCrft->drawCubes(id,myCrft->BlockFinalLight(position.x,position.y,position.z));
sceGumPopMatrix();
}
}
else
{
sceGumPushMatrix();
ScePspFVector3 loc = {position.x,position.y+sinf(levit)*0.09f,position.z};
sceGumTranslate(&loc);
sceGumRotateX(0.0f);
sceGumRotateY(angle);
sceGumRotateZ(0.0f);
myCrft->drawDropItems(id);
sceGumPopMatrix();
}
sceGuDisable(GU_BLEND);
sceGuDisable(GU_ALPHA_TEST);
sceGuDisable(GU_DEPTH_TEST);
}
}
