Example #1
0
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);
}
Example #2
0
void sceGuStart(int cid, void* list)
{
	GuContext* context = &gu_contexts[cid];
	unsigned int* local_list = (unsigned int*)(((unsigned int)list) | 0x40000000);

	// setup display list

	context->list.start = local_list;
	context->list.current = local_list;
	context->list.parent_context = gu_curr_context;
	gu_list = &context->list;

	// store current context

	gu_curr_context = cid;

	if (!cid)
	{
		ge_list_executed[0] = sceGeListEnQueue(local_list,local_list,gu_settings.ge_callback_id,0);
		gu_settings.signal_offset = 0;
	}

	if (!gu_init)
	{
		static int dither_matrix[16] =
		{
			-4, 0,-3, 1,
			 2,-2, 3,-1,
			-3, 1,-4, 0,
			 3,-1, 2,-2
		};

		sceGuSetDither((ScePspIMatrix4*)dither_matrix);
		sceGuPatchDivide(16,16);
		sceGuColorMaterial(GU_AMBIENT|GU_DIFFUSE|GU_SPECULAR);

		sceGuSpecular(1.0f);
		sceGuTexScale(1.0f,1.0f);
		
		gu_init = 1;
	}

	if (!gu_curr_context)
	{
		if (gu_draw_buffer.frame_width)
		{
			sendCommandi(156, ((unsigned int)gu_draw_buffer.frame_buffer) & 0xffffff);
			sendCommandi(157, ((((unsigned int)gu_draw_buffer.frame_buffer) & 0xff000000) >> 8) | gu_draw_buffer.frame_width);
		}
	}
Example #3
0
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
};
Example #4
0
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);
}
Example #5
0
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);
}
Example #6
0
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
}
Example #7
0
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;//試したら見事に駄目だったw
		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;
}
Example #8
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 ();
}
Example #9
0
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
}
Example #10
0
	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);
	}
Example #11
0
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;
}
Example #12
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;
}
Example #13
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;
}