void vidgu_render_nostretch(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh) { int start, end; sceGuStart(GU_DIRECT,list); sceGuTexMode(GU_PSM_5650,0,0,0); // 16-bit RGBA sceGuTexImage(0,512,512,512,g_pBlitBuff); // setup texture as a 256x256 texture //sceKernelDcacheWritebackAll(); sceGuTexFunc(GU_TFX_REPLACE,GU_TCC_RGBA); // don't get influenced by any vertex colors sceGuTexFilter(GU_NEAREST,GU_NEAREST); // point-filtered sampling for (start = sx, end = sx+sw; start < end; start += SLICE_SIZE, dx += SLICE_SIZE) { struct Vertex* vertices = (struct Vertex*)sceGuGetMemory(2 * sizeof(struct Vertex)); int width = (start + SLICE_SIZE) < end ? SLICE_SIZE : end-start; vertices[0].u = start; vertices[0].v = sy; vertices[0].color = 0; vertices[0].x = dx; vertices[0].y = dy; vertices[0].z = 0; vertices[1].u = start + width; vertices[1].v = sy + sh; vertices[1].color = 0; vertices[1].x = dx + width; vertices[1].y = dy + sh; vertices[1].z = 0; sceGuDrawArray(GU_SPRITES,GU_TEXTURE_16BIT|GU_COLOR_5650|GU_VERTEX_16BIT|GU_TRANSFORM_2D,2,0,vertices); } sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuSwapBuffers(); //sceGuSwapBuffers(); }
void nextBoxHasColor(int *x, int *y, HasColorMode mode) { VertexColor *sendVertices = mode & HASCOLOR_RGBA_TRANSPARENT ? transparentColorVertices : colorVertices; sendVertices[0].x = *x; sendVertices[0].y = *y; sendVertices[1].x = *x + 40; sendVertices[1].y = *y + 20; *x += 47; if (*x >= 470) { *x = 10; *y += 26; } sceKernelDcacheWritebackRange(sendVertices, sizeof(colorVertices)); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_DECAL, mode & HASCOLOR_RGB ? GU_TCC_RGB : GU_TCC_RGBA); sceGuTexImage(0, 4, 4, 16, imageData); sceGuDrawArray(GU_SPRITES, GU_COLOR_8888 | GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, sendVertices); sceGuFinish(); sceGuSync(GU_SYNC_LIST, GU_SYNC_WHAT_DONE); sceGuSync(0, 0); sceGuStart(GU_DIRECT, list); }
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); }
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(); }
static void gba_upload_vram (void) { sceGuDisable(GU_SCISSOR_TEST); sceGuDisable(GU_DEPTH_TEST); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE); sceGuClutMode(GU_PSM_5551,0,0xFF,0); sceGuClutLoad(32, index_copy_clut); sceGuDrawBufferList(GU_PSM_5551, GBA_VRAMTEXTURE_8bit_GU, 128); sceGuTexImage(0, 128, 256, 128, vram); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_8bit)); sceGuDrawBufferList(GU_PSM_5551, (u16*)GBA_VRAMTEXTURE_8bit_GU + (128*256), 128); sceGuTexImage(0, 128, 256, 128, vram + (128*256)); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_8bit)); sceGuDrawBufferList(GU_PSM_5551, (u16*)GBA_VRAMTEXTURE_8bit_GU + (128*256*2), 128); sceGuTexImage(0, 128, 256, 128, vram + (128*256) * 2); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_8bit)); sceGuTexMode(GU_PSM_T4, 0, 0, GU_FALSE); sceGuClutMode(GU_PSM_5551,0,0xFF,0); sceGuClutLoad(32, index_copy_clut); sceGuDrawBufferList(GU_PSM_5551, GBA_VRAMTEXTURE_4bit_GU, 256); sceGuTexImage(0, 256, 256, 256, vram); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_4bit)); sceGuDrawBufferList(GU_PSM_5551, (u16*)GBA_VRAMTEXTURE_4bit_GU + (256*256) , 256); sceGuTexImage(0, 256, 256, 256, vram + (256 * 256 / 2)); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_4bit)); sceGuDrawBufferList(GU_PSM_5551, (u16*)GBA_VRAMTEXTURE_4bit_GU + (256*256) * 2, 256); sceGuTexImage(0, 256, 256, 256, vram + (256 * 256 / 2)*2); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL,(void*)(vram_cache_coords_4bit)); }
void drawBG() { sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF); sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0x550055); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_DECAL, GU_TCC_RGBA); sceGuTexImage(0, 4, 4, 16, bgData); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, bg); }
void vidgu_render(int sx, int sy, int sw,int sh,int dx, int dy, int dw,int dh) { unsigned int j,cx,cy; struct Vertex* vertices; cx=(480-dw)/2; cy=(272-dh)/2; sceGuStart(GU_DIRECT,list); sceGuTexMode(GU_PSM_5650,0,0,0); // 16-bit RGBA sceGuTexImage(0,512,512,512,g_pBlitBuff); // setup texture as a 256x256 texture //sceKernelDcacheWritebackAll(); sceGuTexFunc(GU_TFX_REPLACE,GU_TCC_RGBA); // don't get influenced by any vertex colors sceGuTexFilter(GU_LINEAR,GU_LINEAR); // point-filtered sampling int start, end; float ustart = (float)sx; float ustep = (float)sw / (float)(dw / SLICE_SIZE); // blit maximizing the use of the texture-cache for (start = sx, end = sx+dw; start < end; start += SLICE_SIZE, dx += SLICE_SIZE) { struct Vertex* vertices = (struct Vertex*)sceGuGetMemory(2 * sizeof(struct Vertex)); int width = (start + SLICE_SIZE) < end ? SLICE_SIZE : end-start; vertices[0].u = ustart; vertices[0].v = (float)sy; vertices[0].color = 0; vertices[0].x = dx; vertices[0].y = dy; vertices[0].z = 0; vertices[1].u = ustart + ustep; vertices[1].v = (float)(sy + sh); vertices[1].color = 0; vertices[1].x = dx + width; vertices[1].y = dy + dh; vertices[1].z = 0; sceGuDrawArray(GU_SPRITES,GU_TEXTURE_16BIT|GU_COLOR_5650|GU_VERTEX_16BIT|GU_TRANSFORM_2D,2,0,vertices); ustart += ustep; } sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuSwapBuffers(); }
void drawTexFlush(int width, int height, int stride, int texfmt, const void *tex, const void *clut, int clutfmt, int blocks, const void *verts, int indexMask) { sceGuStart(GU_DIRECT, list); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(texfmt, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_DECAL, GU_TCC_RGB); sceGuTexImage(0, width, height, stride, tex); sceGuClutLoad(blocks, clut); sceGuClutMode(clutfmt, 0, indexMask, 0); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, verts); sceGuFinish(); sceGuSync(0, 0); }
void psp_sdl_gu_init(void) { sceGuStart(GU_DIRECT,list); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_5650, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuTexFilter(GU_LINEAR, GU_LINEAR); sceGuDisable(GU_BLEND); sceGuDisable(GU_DEPTH_TEST); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); }
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 ya2d_drawTexture(ya2d_Texture *texp, int x, int y) { 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); if(texp->textureWidth <= YA2D_TEXTURE_SLICE) { ya2d_TextureVertex *vertices = (ya2d_TextureVertex *)sceGuGetMemory(4 * sizeof(ya2d_TextureVertex)); vertices[0] = (ya2d_TextureVertex){0, 0, x, y, 0}; vertices[1] = (ya2d_TextureVertex){0, texp->textureHeight, x, y+texp->textureHeight, 0}; vertices[2] = (ya2d_TextureVertex){texp->textureWidth, 0, x+texp->textureWidth, y, 0}; vertices[3] = (ya2d_TextureVertex){texp->textureWidth, texp->textureHeight, x+texp->textureWidth, y+texp->textureHeight, 0}; sceGumDrawArray(GU_TRIANGLE_STRIP, GU_TEXTURE_16BIT|GU_VERTEX_16BIT|GU_TRANSFORM_2D, 4, 0, vertices); sceKernelDcacheWritebackRange(vertices, 4 * sizeof(ya2d_TextureVertex)); } else //Fast draw for big textures { int i; for(i = 0; i < texp->textureWidth; i+= YA2D_TEXTURE_SLICE) { /* ya2d_TextureVertex *vertices = (ya2d_TextureVertex *)sceGuGetMemory(4 * sizeof(ya2d_TextureVertex)); vertices[0] = (ya2d_TextureVertex){i, 0, x+i, y, 0}; vertices[1] = (ya2d_TextureVertex){i+YA2D_TEXTURE_SLICE, 0, x+i+YA2D_TEXTURE_SLICE, y, 0}; vertices[2] = (ya2d_TextureVertex){i, texp->textureHeight, x+i, y+texp->textureHeight, 0}; vertices[3] = (ya2d_TextureVertex){i+YA2D_TEXTURE_SLICE, texp->textureHeight, x+i+YA2D_TEXTURE_SLICE, y+texp->textureHeight, 0}; sceGumDrawArray(GU_TRIANGLE_STRIP, GU_TEXTURE_16BIT|GU_VERTEX_16BIT|GU_TRANSFORM_2D, 4, 0, vertices); sceKernelDcacheWritebackRange(vertices, 4 * sizeof(ya2d_TextureVertex)); */ ya2d_TextureVertex *vertices = (ya2d_TextureVertex *)sceGuGetMemory(2 * sizeof(ya2d_TextureVertex)); vertices[0] = (ya2d_TextureVertex){i, 0, x+i, y, 0}; vertices[1] = (ya2d_TextureVertex){i+YA2D_TEXTURE_SLICE, texp->textureHeight, x+i+YA2D_TEXTURE_SLICE, y+texp->textureHeight, 0}; sceGumDrawArray(GU_SPRITES, GU_TEXTURE_16BIT|GU_VERTEX_16BIT|GU_TRANSFORM_2D, 2, 0, vertices); sceKernelDcacheWritebackRange(vertices, 2 * sizeof(ya2d_TextureVertex)); } } }
static void psp_set_texture_frame(void *data, const void *frame, bool rgb32, unsigned width, unsigned height, float alpha) { psp1_video_t *psp = (psp1_video_t*)data; (void) rgb32; (void) alpha; #ifdef DEBUG /* psp->menu.frame buffer size is (480 * 272)*2 Bytes */ rarch_assert((width*height) < (480 * 272)); #endif psp_set_screen_coords(psp->menu.frame_coords, 0, 0, SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT, 0); psp_set_tex_coords(psp->menu.frame_coords, width, height); sceKernelDcacheWritebackRange(frame, width * height * 2); sceGuStart(GU_DIRECT, psp->main_dList); sceGuCopyImage(GU_PSM_4444, 0, 0, width, height, width, (void*)frame, 0, 0, width, psp->menu.frame); sceGuFinish(); sceGuStart(GU_SEND, psp->menu.dList); sceGuTexMode(GU_PSM_4444, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuTexFilter(GU_LINEAR, GU_LINEAR); sceGuTexImage(0, next_pow2(width), next_pow2(height), width, psp->menu.frame); sceGuEnable(GU_BLEND); #if 0 /* default blending */ sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); #endif sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0xF0F0F0F0, 0x0F0F0F0F); ; sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, psp->menu.frame_coords); sceGuFinish(); }
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 }
void gEnd() { if (!obj_begin || obj_list_size <= 0) { obj_begin = G_FALSE; return; } // Manage pspgu extensions if (obj_use_z) sceGuEnable(GU_DEPTH_TEST); else sceGuDisable(GU_DEPTH_TEST); if (obj_use_blend) sceGuEnable(GU_BLEND); else sceGuDisable(GU_BLEND); if (obj_use_vert_color) sceGuColor(WHITE); else sceGuColor(obj_list[0].color); if (!obj_use_tex) sceGuDisable(GU_TEXTURE_2D); else { sceGuEnable(GU_TEXTURE_2D); if (obj_use_tex_linear) sceGuTexFilter(GU_LINEAR,GU_LINEAR); else sceGuTexFilter(GU_NEAREST,GU_NEAREST); if (obj_use_tex_repeat) sceGuTexWrap(GU_REPEAT,GU_REPEAT); else sceGuTexWrap(GU_CLAMP,GU_CLAMP); // Load texture sceGuTexMode(GU_PSM_8888,0,0,obj_tex->swizzled); sceGuTexImage(0,obj_tex->tw,obj_tex->th,obj_tex->tw,obj_tex->data); } switch (obj_type) { case RECTS: _gEndRects(); break; case LINES: _gEndLines(); break; case QUADS: _gEndQuads(); break; } sceGuColor(WHITE); sceGuEnable(GU_BLEND); obj_begin = G_FALSE; if (obj_use_z) zclear = G_TRUE; }
void blit_start(int start, int end) { clip_min_y = start; clip_max_y = end + 1; spr_num = 0; spr_index = 0; if (start == FIRST_VISIBLE_LINE) { clut = (UINT16 *)PSP_UNCACHE_PTR(&video_palettebank[palette_bank]); fix_num = 0; spr_disable = 0; if (clear_spr_texture) blit_clear_spr_sprite(); if (clear_fix_texture) blit_clear_fix_sprite(); sceGuStart(GU_DIRECT, gulist); sceGuDrawBufferList(GU_PSM_5551, draw_frame, BUF_WIDTH); sceGuScissor(0, 0, BUF_WIDTH, SCR_WIDTH); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuDrawBufferList(GU_PSM_5551, work_frame, BUF_WIDTH); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuScissor(24, 16, 336, 240); sceGuClearColor(CNVCOL15TO32(video_palette[4095])); sceGuClear(GU_COLOR_BUFFER_BIT | GU_FAST_CLEAR_BIT); sceGuClearColor(0); sceGuEnable(GU_ALPHA_TEST); sceGuTexMode(GU_PSM_T8, 0, 0, GU_TRUE); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuFinish(); sceGuSync(0, GU_SYNC_FINISH); } }
void initGraphics() { dispBufferNumber = 0; sceGuInit(); guStart(); sceGuDrawBuffer(GU_PSM_8888, (void*)FRAMEBUFFER_SIZE, PSP_LINE_SIZE); sceGuDispBuffer(SCREEN_WIDTH, SCREEN_HEIGHT, (void*)0, PSP_LINE_SIZE); sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); sceGuDepthBuffer((void*) (FRAMEBUFFER_SIZE*2), PSP_LINE_SIZE); sceGuOffset(2048 - (SCREEN_WIDTH / 2), 2048 - (SCREEN_HEIGHT / 2)); sceGuViewport(2048, 2048, SCREEN_WIDTH, SCREEN_HEIGHT); sceGuDepthRange(0xc350, 0x2710); sceGuScissor(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuAlphaFunc(GU_GREATER, 0, 0xff); sceGuEnable(GU_ALPHA_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuEnable(GU_CLIP_PLANES); sceGuTexMode(GU_PSM_8888, 0, 0, 0); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuAmbient(0xffffffff); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); initialized = 1; }
virtual void draw() { sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_8888, 0, 0, GU_FALSE); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuTexImage(0, 256, 256, 256, data_.get().data()); sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA); sceGuTexFilter(GU_LINEAR, GU_LINEAR); bright_texture_vertex * const vertex = static_cast<bright_texture_vertex *>(sceGuGetMemory(2 * sizeof(*vertex))); vertex[0].u = u_; vertex[0].v = v_; vertex[0].color = color_ | static_cast<boost::uint32_t>(alpha_) << 24; vertex[0].x = x_; vertex[0].y = y_; vertex[0].z = 0.f; vertex[1].u = u_ + u_size_; vertex[1].v = v_ + v_size_; vertex[1].color = color_ | static_cast<boost::uint32_t>(alpha_) << 24; vertex[1].x = x_ + width_; vertex[1].y = y_ + height_; vertex[1].z = 0.f; sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2, 0, vertex); }
void nextBox(int *x, int *y) { vertices[0].x = *x; vertices[0].y = *y; vertices[1].x = *x + 40; vertices[1].y = *y + 20; *x += 47; if (*x >= 470) { *x = 10; *y += 26; } sceKernelDcacheWritebackRange(vertices, sizeof(vertices)); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_DECAL, GU_TCC_RGBA); sceGuTexImage(0, 4, 4, 16, imageData); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, vertices); sceGuFinish(); sceGuSync(GU_SYNC_LIST, GU_SYNC_WHAT_DONE); sceGuSync(0, 0); sceGuStart(GU_DIRECT, list); }
static void *psp_init(const video_info_t *video, const input_driver_t **input, void **input_data) { // to-do : add ASSERT() checks or use main RAM if VRAM is too low for desired video->input_scale void *pspinput; int pixel_format, lut_pixel_format, lut_block_count; unsigned int red_shift, color_mask; void *displayBuffer, *LUT_r, *LUT_b; psp1_video_t *psp = (psp1_video_t*)calloc(1, sizeof(psp1_video_t)); if (!psp) return NULL; sceGuInit(); psp->main_dList = memalign(16, 256); // make sure to allocate more space if bigger display lists are needed. psp->frame_dList = memalign(16, 256); psp->rgui.dList = memalign(16, 256); psp->rgui.frame = memalign(16, 2 * 480 * 272); psp->frame_coords = memalign(64, 1 * sizeof(psp1_sprite_t)); psp->rgui.frame_coords = memalign(64, 16 * sizeof(psp1_sprite_t)); memset(psp->frame_coords , 0, 1 * sizeof(psp1_sprite_t)); memset(psp->rgui.frame_coords , 0, 16 * sizeof(psp1_sprite_t)); sceKernelDcacheWritebackInvalidateAll(); psp->frame_coords = TO_UNCACHED_PTR(psp->frame_coords); psp->rgui.frame_coords = TO_UNCACHED_PTR(psp->rgui.frame_coords);; psp->frame_coords->v0.x = 60; psp->frame_coords->v0.y = 0; psp->frame_coords->v0.u = 0; psp->frame_coords->v0.v = 0; psp->frame_coords->v1.x = 420; psp->frame_coords->v1.y = SCEGU_SCR_HEIGHT; psp->frame_coords->v1.u = 256; psp->frame_coords->v1.v = 240; psp->vsync = video->vsync; psp->rgb32 = video->rgb32; if(psp->rgb32) { uint32_t* LUT_r_local = (uint32_t*)(SCEGU_VRAM_BP32_2); uint32_t* LUT_b_local = (uint32_t*)(SCEGU_VRAM_BP32_2) + (1 << 8); red_shift = 8 + 8; color_mask = 0xFF; lut_block_count = (1 << 8) / 8; psp->texture = (void*)(LUT_b_local + (1 << 8)); psp->draw_buffer = SCEGU_VRAM_BP32_0; psp->bpp_log2 = 2; pixel_format = GU_PSM_8888; lut_pixel_format = GU_PSM_T32; displayBuffer = SCEGU_VRAM_BP32_1; for (u32 i=0; i < (1 << 8); i++) { LUT_r_local[i]= i; LUT_b_local[i]= i << (8 + 8); } LUT_r = (void*)LUT_r_local; LUT_b = (void*)LUT_b_local; } else { uint16_t* LUT_r_local = (uint16_t*)(SCEGU_VRAM_BP_2); uint16_t* LUT_b_local = (uint16_t*)(SCEGU_VRAM_BP_2) + (1 << 5); red_shift = 6 + 5; color_mask = 0x1F; lut_block_count = (1 << 5) / 8; psp->texture = (void*)(LUT_b_local + (1 << 5)); psp->draw_buffer = SCEGU_VRAM_BP_0; psp->bpp_log2 = 1; pixel_format = GU_PSM_5650; lut_pixel_format = GU_PSM_T16; displayBuffer = SCEGU_VRAM_BP_1; for (u16 i = 0; i < (1 << 5); i++) { LUT_r_local[i]= i; LUT_b_local[i]= i << (5 + 6); } LUT_r = (void*)LUT_r_local; LUT_b = (void*)LUT_b_local; } sceDisplayWaitVblankStart(); // TODO : check if necessary sceGuDisplay(GU_FALSE); sceGuStart(GU_DIRECT, psp->main_dList); sceGuDrawBuffer(pixel_format, TO_GU_POINTER(psp->draw_buffer), SCEGU_VRAM_WIDTH); sceGuDispBuffer(SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT, TO_GU_POINTER(displayBuffer), SCEGU_VRAM_WIDTH); sceGuClearColor(0); sceGuScissor(0, 0, SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuTexFilter(GU_LINEAR, GU_LINEAR); // TODO , move this to display list sceGuTexWrap (GU_CLAMP, GU_CLAMP); sceGuEnable(GU_TEXTURE_2D); sceGuDisable(GU_DEPTH_TEST); sceGuCallMode(GU_FALSE); sceGuFinish(); sceGuSync(0, 0); sceDisplayWaitVblankStart(); // TODO : check if necessary sceGuDisplay(GU_TRUE); pspDebugScreenSetColorMode(pixel_format); pspDebugScreenSetBase(psp->draw_buffer); // fill frame_dList : sceGuStart(GU_CALL, psp->frame_dList); sceGuTexMode(pixel_format, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0x0000FF00, 0xFFFFFFFF); // green only sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_COLOR_4444 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, (void*)(psp->frame_coords)); sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0xFFFFFFFF, 0xFFFFFFFF); // restore sceGuTexMode(lut_pixel_format, 0, 0, GU_FALSE); sceGuClutMode(pixel_format, red_shift, color_mask, 0); sceGuClutLoad(lut_block_count, LUT_r); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_COLOR_4444 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, (void*)(psp->frame_coords)); sceGuClutMode(pixel_format, 0, color_mask, 0); sceGuClutLoad(lut_block_count, LUT_b); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_COLOR_4444 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, (void*)(psp->frame_coords)); sceGuFinish(); if (input && input_data) { pspinput = input_psp.init(); *input = pspinput ? &input_psp : NULL; *input_data = pspinput; } return psp; error: RARCH_ERR("PSP1 video could not be initialized.\n"); return (void*)-1; }
static void *psp_init(const video_info_t *video, const input_driver_t **input, void **input_data) { /* to-do : add ASSERT() checks or use main RAM if * VRAM is too low for desired video->input_scale. */ void *pspinput; int pixel_format, lut_pixel_format, lut_block_count; unsigned int red_shift, color_mask; void *displayBuffer, *LUT_r, *LUT_b; psp1_video_t *psp = (psp1_video_t*)calloc(1, sizeof(psp1_video_t)); if (!psp) return NULL; sceGuInit(); psp->vp.x = 0; psp->vp.y = 0; psp->vp.width = SCEGU_SCR_WIDTH; psp->vp.height = SCEGU_SCR_HEIGHT; psp->vp.full_width = SCEGU_SCR_WIDTH; psp->vp.full_height = SCEGU_SCR_HEIGHT; /* Make sure anything using uncached pointers reserves * whole cachelines (memory address and size need to be a multiple of 64) * so it isn't overwritten by an unlucky cache writeback. * * This includes display lists since the Gu library uses * uncached pointers to write to them. */ /* Allocate more space if bigger display lists are needed. */ psp->main_dList = memalign(64, 256); psp->frame_dList = memalign(64, 256); psp->menu.dList = memalign(64, 256); psp->menu.frame = memalign(16, 2 * 480 * 272); psp->frame_coords = memalign(64, (((PSP_FRAME_SLICE_COUNT * sizeof(psp1_sprite_t)) + 63) & ~63)); psp->menu.frame_coords = memalign(64, (((PSP_FRAME_SLICE_COUNT * sizeof(psp1_sprite_t)) + 63) & ~63)); memset(psp->frame_coords, 0, PSP_FRAME_SLICE_COUNT * sizeof(psp1_sprite_t)); memset(psp->menu.frame_coords, 0, PSP_FRAME_SLICE_COUNT * sizeof(psp1_sprite_t)); sceKernelDcacheWritebackInvalidateAll(); psp->frame_coords = TO_UNCACHED_PTR(psp->frame_coords); psp->menu.frame_coords = TO_UNCACHED_PTR(psp->menu.frame_coords); psp->frame_coords->v0.x = 60; psp->frame_coords->v0.y = 0; psp->frame_coords->v0.u = 0; psp->frame_coords->v0.v = 0; psp->frame_coords->v1.x = 420; psp->frame_coords->v1.y = SCEGU_SCR_HEIGHT; psp->frame_coords->v1.u = 256; psp->frame_coords->v1.v = 240; psp->vsync = video->vsync; psp->rgb32 = video->rgb32; if(psp->rgb32) { uint32_t* LUT_r_local = (uint32_t*)(SCEGU_VRAM_BP32_2); uint32_t* LUT_b_local = (uint32_t*)(SCEGU_VRAM_BP32_2) + (1 << 8); red_shift = 8 + 8; color_mask = 0xFF; lut_block_count = (1 << 8) / 8; psp->texture = (void*)(LUT_b_local + (1 << 8)); psp->draw_buffer = SCEGU_VRAM_BP32_0; psp->bpp_log2 = 2; pixel_format = GU_PSM_8888; lut_pixel_format = GU_PSM_T32; displayBuffer = SCEGU_VRAM_BP32_1; for (u32 i=0; i < (1 << 8); i++){ LUT_r_local[i]= i; LUT_b_local[i]= i << (8 + 8); } LUT_r = (void*)LUT_r_local; LUT_b = (void*)LUT_b_local; } else { uint16_t* LUT_r_local = (uint16_t*)(SCEGU_VRAM_BP_2); uint16_t* LUT_b_local = (uint16_t*)(SCEGU_VRAM_BP_2) + (1 << 5); red_shift = 6 + 5; color_mask = 0x1F; lut_block_count = (1 << 5) / 8; psp->texture = (void*)(LUT_b_local + (1 << 5)); psp->draw_buffer = SCEGU_VRAM_BP_0; psp->bpp_log2 = 1; pixel_format = (g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_0RGB1555) ? GU_PSM_5551 : GU_PSM_5650 ; lut_pixel_format = GU_PSM_T16; displayBuffer = SCEGU_VRAM_BP_1; for (u16 i = 0; i < (1 << 5); i++) { LUT_r_local[i]= i; LUT_b_local[i]= i << (5 + 6); } LUT_r = (void*)LUT_r_local; LUT_b = (void*)LUT_b_local; } psp->tex_filter = video->smooth? GU_LINEAR : GU_NEAREST; /* TODO: check if necessary. */ sceDisplayWaitVblankStart(); sceGuDisplay(GU_FALSE); sceGuStart(GU_DIRECT, psp->main_dList); sceGuDrawBuffer(pixel_format, TO_GU_POINTER(psp->draw_buffer), SCEGU_VRAM_WIDTH); sceGuDispBuffer(SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT, TO_GU_POINTER(displayBuffer), SCEGU_VRAM_WIDTH); sceGuClearColor(0); sceGuScissor(0, 0, SCEGU_SCR_WIDTH, SCEGU_SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuTexFilter(psp->tex_filter, psp->tex_filter); sceGuTexWrap (GU_CLAMP, GU_CLAMP); sceGuEnable(GU_TEXTURE_2D); sceGuDisable(GU_DEPTH_TEST); sceGuCallMode(GU_FALSE); sceGuFinish(); sceGuSync(0, 0); /* TODO : check if necessary */ sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); pspDebugScreenSetColorMode(pixel_format); pspDebugScreenSetBase(psp->draw_buffer); /* fill frame_dList : */ sceGuStart(GU_CALL, psp->frame_dList); sceGuTexMode(pixel_format, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuEnable(GU_BLEND); /* green only */ sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0x0000FF00, 0xFFFFFFFF); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, (void*)(psp->frame_coords)); /* restore */ sceGuBlendFunc(GU_ADD, GU_FIX, GU_FIX, 0xFFFFFFFF, 0xFFFFFFFF); sceGuTexMode(lut_pixel_format, 0, 0, GU_FALSE); sceGuClutMode(pixel_format, red_shift, color_mask, 0); sceGuClutLoad(lut_block_count, LUT_r); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, (void*)(psp->frame_coords)); sceGuClutMode(pixel_format, 0, color_mask, 0); sceGuClutLoad(lut_block_count, LUT_b); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF | GU_VERTEX_32BITF | GU_TRANSFORM_2D, PSP_FRAME_VERTEX_COUNT, NULL, (void*)(psp->frame_coords)); sceGuFinish(); if (input && input_data) { pspinput = input_psp.init(); *input = pspinput ? &input_psp : NULL; *input_data = pspinput; } psp->vblank_not_reached = true; sceKernelRegisterSubIntrHandler(PSP_VBLANK_INT, 0, psp_on_vblank, psp); sceKernelEnableSubIntr(PSP_VBLANK_INT, 0); psp->keep_aspect = true; psp->should_resize = true; psp->hw_render = false; return psp; error: RARCH_ERR("PSP1 video could not be initialized.\n"); return (void*)-1; }
void retro_run(void) { int i; bool updated = false; if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated) check_variables(); input_poll_cb(); for (i=0; i < 130; i++) KBD_RES(i); for (i=0; i < sizeof(keymap)/sizeof(keymap_t); i++) if (input_state_cb(0, RETRO_DEVICE_KEYBOARD, 0, keymap[i].retro)) KBD_SET(keymap[i].fmsx); joystate = 0; for (i = 0; i < sizeof(joymap) / sizeof(keymap_t); i++) { if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, joymap[i].retro)) { if (i < joy_keyboard_begin) JOY_SET(joymap[i].fmsx); else KBD_SET(joymap[i].fmsx); } } RETRO_PERFORMANCE_INIT(core_retro_run); RETRO_PERFORMANCE_START(core_retro_run); RunZ80(&CPU); RenderAndPlayAudio(SND_RATE / 60); RETRO_PERFORMANCE_STOP(core_retro_run); fflush(stdout); #ifdef PSP static unsigned int __attribute__((aligned(16))) d_list[32]; void* const texture_vram_p = (void*) (0x44200000 - (640 * 480)); // max VRAM address - frame size sceKernelDcacheWritebackRange(XBuf, 256*240 ); sceGuStart(GU_DIRECT, d_list); sceGuCopyImage(GU_PSM_5650, 0, 0, image_buffer_width, image_buffer_height, image_buffer_width, image_buffer, 0, 0, image_buffer_width, texture_vram_p); sceGuTexSync(); sceGuTexImage(0, 512, 256, image_buffer_width, texture_vram_p); sceGuTexMode(GU_PSM_5650, 0, 0, GU_FALSE); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuDisable(GU_BLEND); sceGuFinish(); video_cb(texture_vram_p, image_buffer_width, image_buffer_height, image_buffer_width * sizeof(uint16_t)); #else video_cb(image_buffer, image_buffer_width, image_buffer_height, image_buffer_width * sizeof(uint16_t)); #endif }
int dxpGraphicsSetup2DTex(DXPTEXTURE3 *texptr,int flag) { if(!texptr)return -1; //設定が同じなら変更処理をしない if(dxpGraphicsData.drawstate == DXP_DRAWSTATE_TEX2D && flag == dxpGraphicsData.flag && texptr == dxpGraphicsData.texture && !texptr->reloadflag && !dxpGraphicsData.forceupdate )return 0; GUSTART; if(dxpGraphicsData.drawstate != DXP_DRAWSTATE_TEX2D) {//2Dテクスチャ用の描画設定を行う。 dxpGraphicsData.drawstate = DXP_DRAWSTATE_TEX2D; dxpGraphicsData.forceupdate = 1; GUENABLE(GU_TEXTURE_2D); if(dxpGraphicsData.bilinear_enable) sceGuTexFilter(GU_LINEAR,GU_LINEAR); else sceGuTexFilter(GU_NEAREST,GU_NEAREST); if(dxpGraphicsData.usedepth) { GUENABLE(GU_DEPTH_TEST); sceGuDepthFunc(dxpGraphicsData.depthfunc); sceGuDepthBuffer(dxpGraphicsData.depthbuffer.texvram,512); //深度バッファを有効にするときでいい if(dxpGraphicsData.writedepth)sceGuDepthMask(0); else sceGuDepthMask(1); } else GUDISABLE(GU_DEPTH_TEST); } //テクスチャの設定開始 if(texptr != dxpGraphicsData.texture || texptr->reloadflag) {//GUにテクスチャの指定をする if(texptr->ppalette && (texptr->psm == GU_PSM_T8 || texptr->psm == GU_PSM_T4)) {//パレットの設定 sceGuClutMode(GU_PSM_8888,0,0xff,0); sceGuClutLoad(texptr->psm == GU_PSM_T4 ? 2 : 32,texptr->ppalette); } sceGuTexMode(texptr->psm,0,0,texptr->swizzledflag); sceGuTexImage(0,texptr->width,texptr->height,texptr->pitch,texptr->texvram ? texptr->texvram : texptr->texdata); dxpGraphicsData.texture = texptr; if(texptr != &dxpGraphicsData.displaybuffer[0] && texptr != &dxpGraphicsData.displaybuffer[1])texptr->reloadflag = 0; } u8 colorKey = 0,alphaEnable = 0; if(flag) { if(texptr->alphabit) alphaEnable = 1; else colorKey = 1; } if(colorKey) { GUENABLE(GU_COLOR_TEST); sceGuColorFunc(GU_NOTEQUAL,texptr->colorkey,0x00fefefe); } else { GUDISABLE(GU_COLOR_TEST); } int op; int src,dest; unsigned int srcfix; unsigned int destfix; switch(dxpGraphicsData.blendmode) { case DX_BLENDMODE_NOBLEND: op = GU_ADD; src = GU_FIX; dest = GU_FIX; srcfix = 0xffffffff; destfix = 0; if(!alphaEnable)break; case DX_BLENDMODE_ALPHA: op = GU_ADD; src = GU_SRC_ALPHA; dest = GU_ONE_MINUS_SRC_ALPHA; srcfix = 0; destfix = 0; break; case DX_BLENDMODE_ADD: op = GU_ADD; src = GU_SRC_ALPHA; dest = GU_FIX; srcfix = 0xffffffff; destfix = 0xffffffff; break; case DX_BLENDMODE_SUB: op = GU_REVERSE_SUBTRACT; src = GU_SRC_ALPHA; dest = GU_FIX; srcfix = 0xffffffff; destfix = 0xffffffff; break; case DX_BLENDMODE_MUL: op = GU_ADD; src = GU_DST_COLOR; dest = GU_FIX; srcfix = 0xffffffff; destfix = 0; break; case DX_BLENDMODE_DESTCOLOR: op = GU_ADD; src = GU_FIX; dest = GU_FIX; srcfix = 0; destfix = 0xffffffff; break; case DX_BLENDMODE_INVDESTCOLOR: op = GU_ADD; src = GU_ONE_MINUS_DST_COLOR; dest = GU_FIX; srcfix = 0; destfix = 0; break; case DX_BLENDMODE_INVSRC: op = GU_ADD; src = GU_SRC_ALPHA; dest = GU_ONE_MINUS_SRC_ALPHA; srcfix = 0; destfix = 0; break; default: return -1; } if(dxpGraphicsData.blendmode == DX_BLENDMODE_NOBLEND && !alphaEnable) { GUDISABLE(GU_BLEND); } else { GUENABLE(GU_BLEND); if(dxpGraphicsData.forceupdate || dxpGraphicsData.op != op || dxpGraphicsData.src != src || dxpGraphicsData.dest != dest || dxpGraphicsData.srcfix != srcfix || dxpGraphicsData.destfix != destfix ){ sceGuBlendFunc(op,src,dest,srcfix,destfix); dxpGraphicsData.op = op; dxpGraphicsData.src = src; dxpGraphicsData.dest = dest; dxpGraphicsData.srcfix = srcfix; dxpGraphicsData.destfix = destfix; } } if(dxpGraphicsData.forceupdate || dxpGraphicsData.color != dxpGraphicsData.gucolor) {//色を設定 sceGuColor(dxpGraphicsData.color); dxpGraphicsData.gucolor = dxpGraphicsData.color; } int tfx,tcc; switch(dxpGraphicsData.blendmode) { case DX_BLENDMODE_NOBLEND: case DX_BLENDMODE_MUL: case DX_BLENDMODE_DESTCOLOR: tcc = GU_TCC_RGB; tfx = GU_TFX_MODULATE; if(!alphaEnable) { GUDISABLE(GU_ALPHA_TEST); break; } case DX_BLENDMODE_ALPHA: case DX_BLENDMODE_ADD: case DX_BLENDMODE_SUB: case DX_BLENDMODE_INVDESTCOLOR: tcc = GU_TCC_RGBA; tfx = GU_TFX_MODULATE; GUENABLE(GU_ALPHA_TEST); sceGuAlphaFunc(GU_NOTEQUAL,0x00,0xff); break; case DX_BLENDMODE_INVSRC: sceGuTexEnvColor(0x00000000); tcc = GU_TCC_RGBA; tfx = GU_TFX_BLEND; GUDISABLE(GU_ALPHA_TEST); break; default: return -1; } if(dxpGraphicsData.forceupdate || dxpGraphicsData.tfx != tfx || dxpGraphicsData.tcc != tcc) { sceGuTexFunc(tfx,tcc); dxpGraphicsData.tfx = tfx; dxpGraphicsData.tcc = tcc; } dxpGraphicsData.forceupdate = 0; dxpGraphicsData.flag = flag; 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 }
int main(int argc, char* argv[]) { unsigned int i,j; pspDebugScreenInit(); SetupCallbacks(); #ifdef ENABLE_PROFILER // Enable profiling pspDebugProfilerClear(); pspDebugProfilerEnable(); #endif // initialize global context g_context.iterationCount = NUM_VERTEX_BUFFERS * NUM_ITERATIONS; g_context.t = 0; g_context.sint = 0; // initialize torus for (i = 0; i < NUM_SLICES; ++i) { for (j = 0; j < NUM_ROWS; ++j) { float s = i + 0.5f, t = j; float x,y,z; x = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * cosf(t * ((GU_PI*2)/NUM_ROWS)); y = (RING_SIZE + RING_RADIUS * cosf(s * ((GU_PI*2)/NUM_SLICES))) * sinf(t * ((GU_PI*2)/NUM_ROWS)); z = RING_RADIUS * sinf(s * ((GU_PI*2)/NUM_SLICES)); torus_vertices[j + i * NUM_ROWS].x = x; torus_vertices[j + i * NUM_ROWS].y = y; torus_vertices[j + i * NUM_ROWS].z = z; } } // initialize torus modifiers for (j = 0; j < NUM_ROWS; ++j) { float t = j; torus_modifiers[j].x = 0; torus_modifiers[j].y = 0; torus_modifiers[j].z = 0.3*cosf( t * 8.0f *((GU_PI*2)/NUM_ROWS) ); } // init GU and set callbacks sceGuInit(); // 0x01 - user callback // 0x04 - 'rendering finished' callback sceGuSetCallback(1, &mySignalHandler); sceGuSetCallback(4, &myFinishHandler); // setup GU sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_8888,(void*)0,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)0x88000,BUF_WIDTH); sceGuDepthBuffer((void*)0x110000,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuAlphaFunc(GU_GREATER,0,0xff); sceGuEnable(GU_ALPHA_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // run sample #ifdef USING_SIGNALS sceGuCallMode(1); #endif // generate callable command-list with texture setup { sceGuStart(GU_CALL, smallList1); // setup texture sceGuTexMode(GU_PSM_5551,0,0,0); sceGuTexImage(0,32,32,32,ball_start); // width, height, buffer width, tbp sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA); // NOTE: this enables reads of the alpha-component from the texture, otherwise blend/test won't work sceGuTexFilter(GU_NEAREST,GU_NEAREST); sceGuTexWrap(GU_CLAMP,GU_CLAMP); sceGuTexScale(1,1); sceGuTexOffset(0,0); sceGuAmbientColor(0xffffffff); sceGuFinish(); sceGuSync(0,0); } // generate callable command-list for cube rendering { sceGuStart(GU_CALL, smallList2); // draw cube sceGuDrawArray(GU_TRIANGLES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_3D,12*3,0,cubeVertices); sceGuFinish(); sceGuSync(0,0); } for(;;) { sceGuStart(GU_DIRECT,list); unsigned int i = 0; for( ; i < NUM_VERTEX_BUFFERS; i++ ) g_context.vbuffer[i] = sceGuGetMemory((NUM_SLICES/g_context.iterationCount) * 2 * NUM_ROWS * sizeof(Vertex)); g_context.vertsRendered = 0; // clear screen sceGuClearColor(0x00334455); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup matrices sceGumMatrixMode(GU_PROJECTION); sceGumLoadIdentity(); sceGumPerspective(75.0f,16.0f/9.0f,0.5f,1000.0f); sceGumMatrixMode(GU_VIEW); sceGumLoadIdentity(); sceGumMatrixMode(GU_MODEL); { ScePspFVector3 pos = {0.0f,0.0f,-3.5f}; ScePspFVector3 rot = {g_context.t * 0.3f * (GU_PI/180.0f), g_context.t * 0.7f * (GU_PI/180.0f), g_context.t * 1.3f * (GU_PI/180.0f)}; sceGumLoadIdentity(); sceGumTranslate(&pos); sceGumRotateXYZ(&rot); } sceGumStoreMatrix(&g_context.world); // call pregenerated command-list to setup texture sceGuCallList(smallList1); // start billboard rendering render_billboards(0); // call pregenerated command-list to render cube { ScePspFVector3 scale = {0.3f, 0.3f, 0.3f}; sceGumScale(&scale); } sceGumUpdateMatrix(); sceGuCallList(smallList2); #ifndef USING_SIGNALS // HACK: sceGuFinish() is called inside the signal interupt handler when all rendering job is done // this is done in order to stall GPU if it is ahead of CPU sceGuFinish(); #endif sceGuSync(0,0); #ifndef ENABLE_FRAMERATE // wait for next frame sceDisplayWaitVblankStart(); #endif sceGuSwapBuffers(); pspDebugScreenSetXY(0,0); #ifdef ENABLE_PROFILER // Print profile information to the screen pspDebugProfilerPrint(); #endif #ifdef ENABLE_FRAMERATE // simple frame rate counter static float curr_ms = 1.0f; static struct timeval time_slices[16]; static int t = 0; float curr_fps = 1.0f / curr_ms; t++; float vertsPerSec = g_context.vertsRendered*curr_fps; float kbPerSec = vertsPerSec * sizeof(Vertex) / 1024.0f; gettimeofday(&time_slices[t & 15],0); pspDebugScreenPrintf("fps: %d.%03d ms: %d vert/s: %dK MB/s: %d.%03d",(int)curr_fps, ((int)(curr_fps*1000.0f)%1000), (int)(curr_ms*1000.0f), (int)(vertsPerSec/1000.0f), (int)(kbPerSec/1024.0f), (int)((1000.0f/1024.0f)*((int)kbPerSec%1024)) ); if (!(t & 15)) { struct timeval last_time = time_slices[0]; unsigned int i; curr_ms = 0; for (i = 1; i < 16; ++i) { struct timeval curr_time = time_slices[i]; int curr_time_usec = curr_time.tv_usec + curr_time.tv_sec * 1000000; int last_time_usec = last_time.tv_usec + last_time.tv_sec * 1000000; if( last_time_usec < curr_time_usec ) curr_ms += (( curr_time_usec - last_time_usec ) * (1.0f/1000000.0f)); last_time = time_slices[i]; } curr_ms /= 15.0f; } #endif } sceGuTerm(); sceKernelExitGame(); return 0; }
int main(int argc, char* argv[]) { SetupCallbacks(); // generate geometry genGrid( GRID_ROWS, GRID_COLUMNS, GRID_SIZE, grid_vertices, grid_indices ); genTorus( TORUS_ROWS, TORUS_SLICES, TORUS_RADIUS, TORUS_THICKNESS, torus_vertices, torus_indices ); // flush cache so that no stray data remains sceKernelDcacheWritebackAll(); // setup VRAM buffers void* frameBuffer = (void*)0; const void* doubleBuffer = (void*)0x44000; const void* renderTarget = (void*)0x88000; const void* depthBuffer = (void*)0x110000; // setup GU sceGuInit(); sceGuStart(GU_DIRECT,list); sceGuDrawBuffer(GU_PSM_4444,frameBuffer,BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH,SCR_HEIGHT,(void*)doubleBuffer,BUF_WIDTH); sceGuDepthBuffer((void*)depthBuffer,BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); sceGuDepthRange(0xc350,0x2710); sceGuScissor(0,0,SCR_WIDTH,SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDepthFunc(GU_GEQUAL); sceGuEnable(GU_DEPTH_TEST); sceGuFrontFace(GU_CW); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_CULL_FACE); sceGuEnable(GU_TEXTURE_2D); sceGuEnable(GU_DITHER); sceGuFinish(); sceGuSync(0,0); sceDisplayWaitVblankStart(); sceGuDisplay(GU_TRUE); // setup matrices ScePspFMatrix4 identity; ScePspFMatrix4 projection; ScePspFMatrix4 view; gumLoadIdentity(&identity); gumLoadIdentity(&projection); gumPerspective(&projection,75.0f,16.0f/9.0f,0.5f,1000.0f); { ScePspFVector3 pos = {0,0,-5.0f}; gumLoadIdentity(&view); gumTranslate(&view,&pos); } ScePspFMatrix4 textureProjScaleTrans; gumLoadIdentity(&textureProjScaleTrans); textureProjScaleTrans.x.x = 0.5; textureProjScaleTrans.y.y = -0.5; textureProjScaleTrans.w.x = 0.5; textureProjScaleTrans.w.y = 0.5; ScePspFMatrix4 lightProjection; ScePspFMatrix4 lightProjectionInf; ScePspFMatrix4 lightView; ScePspFMatrix4 lightMatrix; gumLoadIdentity(&lightProjection); gumPerspective(&lightProjection,75.0f,1.0f,0.1f,1000.0f); gumLoadIdentity(&lightProjectionInf); gumPerspective(&lightProjectionInf,75.0f,1.0f,0.0f,1000.0f); gumLoadIdentity(&lightView); gumLoadIdentity(&lightMatrix); // define shadowmap Texture shadowmap = { GU_PSM_4444, 0, 128, 128, 128, sceGeEdramGetAddr() + (int)renderTarget }; // define geometry Geometry torus = { identity, sizeof(torus_indices)/sizeof(unsigned short), torus_indices, torus_vertices, 0xffffff }; Geometry grid = { identity, sizeof(grid_indices)/sizeof(unsigned short), grid_indices, grid_vertices, 0xff7777 }; // run sample int val = 0; for(;;) { // update matrices // grid { ScePspFVector3 pos = {0,-1.5f,0}; gumLoadIdentity(&grid.world); gumTranslate(&grid.world,&pos); } // torus { ScePspFVector3 pos = {0,0.5f,0.0f}; ScePspFVector3 rot = {val * 0.79f * (GU_PI/180.0f), val * 0.98f * (GU_PI/180.0f), val * 1.32f * (GU_PI/180.0f)}; gumLoadIdentity(&torus.world); gumTranslate(&torus.world,&pos); gumRotateXYZ(&torus.world,&rot); } // orbiting light { ScePspFVector3 lightLookAt = { torus.world.w.x, torus.world.w.y, torus.world.w.z }; ScePspFVector3 rot1 = {0,val * 0.79f * (GU_PI/180.0f),0}; ScePspFVector3 rot2 = {-(GU_PI/180.0f)*60.0f,0,0}; ScePspFVector3 pos = {0,0,LIGHT_DISTANCE}; gumLoadIdentity(&lightMatrix); gumTranslate(&lightMatrix,&lightLookAt); gumRotateXYZ(&lightMatrix,&rot1); gumRotateXYZ(&lightMatrix,&rot2); gumTranslate(&lightMatrix,&pos); } gumFastInverse(&lightView,&lightMatrix); // render to shadow map { sceGuStart(GU_DIRECT,list); // set offscreen texture as a render target sceGuDrawBufferList(GU_PSM_4444,(void*)renderTarget,shadowmap.stride); // setup viewport sceGuOffset(2048 - (shadowmap.width/2),2048 - (shadowmap.height/2)); sceGuViewport(2048,2048,shadowmap.width,shadowmap.height); // clear screen sceGuClearColor(0xffffffff); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup view/projection from light sceGuSetMatrix(GU_PROJECTION,&lightProjection); sceGuSetMatrix(GU_VIEW,&lightView); // shadow casters are drawn in black // disable lighting and texturing sceGuDisable(GU_LIGHTING); sceGuDisable(GU_TEXTURE_2D); // draw torus to shadow map drawShadowCaster( &torus ); sceGuFinish(); sceGuSync(0,0); } // render to frame buffer { sceGuStart(GU_DIRECT,list); // set frame buffer sceGuDrawBufferList(GU_PSM_4444,(void*)frameBuffer,BUF_WIDTH); // setup viewport sceGuOffset(2048 - (SCR_WIDTH/2),2048 - (SCR_HEIGHT/2)); sceGuViewport(2048,2048,SCR_WIDTH,SCR_HEIGHT); // clear screen sceGuClearColor(0xff554433); sceGuClearDepth(0); sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); // setup view/projection from camera sceGuSetMatrix(GU_PROJECTION,&projection); sceGuSetMatrix(GU_VIEW,&view); sceGuSetMatrix(GU_MODEL,&identity); // setup a light ScePspFVector3 lightPos = { lightMatrix.w.x, lightMatrix.w.y, lightMatrix.w.z }; ScePspFVector3 lightDir = { lightMatrix.z.x, lightMatrix.z.y, lightMatrix.z.z }; sceGuLight(0,GU_SPOTLIGHT,GU_DIFFUSE,&lightPos); sceGuLightSpot(0,&lightDir, 5.0, 0.6); sceGuLightColor(0,GU_DIFFUSE,0x00ff4040); sceGuLightAtt(0,1.0f,0.0f,0.0f); sceGuAmbient(0x00202020); sceGuEnable(GU_LIGHTING); sceGuEnable(GU_LIGHT0); // draw torus drawGeometry( &torus ); // setup texture projection sceGuTexMapMode( GU_TEXTURE_MATRIX, 0, 0 ); sceGuTexProjMapMode( GU_POSITION ); // set shadowmap as a texture sceGuTexMode(shadowmap.format,0,0,0); sceGuTexImage(shadowmap.mipmap,shadowmap.width,shadowmap.height,shadowmap.stride,shadowmap.data); sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGB); sceGuTexFilter(GU_LINEAR,GU_LINEAR); sceGuTexWrap(GU_CLAMP,GU_CLAMP); sceGuEnable(GU_TEXTURE_2D); // calculate texture projection matrix for shadowmap ScePspFMatrix4 shadowProj; gumMultMatrix(&shadowProj, &lightProjectionInf, &lightView); gumMultMatrix(&shadowProj, &textureProjScaleTrans, &shadowProj); // draw grid receiving shadow drawShadowReceiver( &grid, shadowProj ); sceGuFinish(); sceGuSync(0,0); } sceDisplayWaitVblankStart(); frameBuffer = sceGuSwapBuffers(); val++; } sceGuTerm(); sceKernelExitGame(); return 0; }
int main() { SceCtrlData pad; int cancel = 0, uninstall = 0, reinstall = 0, lftv = 0, ok = 0, installed = 0, uninstalled = 0, autoExit = 0; SetupCallbacks(); sceCtrlSetSamplingCycle(0); sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons & PSP_CTRL_LTRIGGER) { quickinstall = 1; lftv = 1; } else if (pad.Buttons & PSP_CTRL_RTRIGGER) { quickinstall = 1; } if (fileExist(PRX_LFTVBACKUP) | fileExist(PRX_RPLYBACKUP)) uninstall = 1; sceGuInit(); sceGuStart(GU_DIRECT, list); sceGuClearColor(0xFFFFFFFF); sceGuDrawBuffer(GU_PSM_8888, (void*)0, BUF_WIDTH); sceGuDispBuffer(SCR_WIDTH, SCR_HEIGHT, (void*)0x88000, BUF_WIDTH); sceGuDepthBuffer((void*)0x110000, BUF_WIDTH); sceGuOffset(2048 - (SCR_WIDTH / 2), 2048 - (SCR_HEIGHT / 2)); sceGuViewport(2048, 2048, SCR_WIDTH, SCR_HEIGHT); sceGuDepthRange(0xc350, 0x2710); sceGuScissor(0, 0, SCR_WIDTH, SCR_HEIGHT); sceGuEnable(GU_SCISSOR_TEST); sceGuDisable(GU_DEPTH_TEST); sceGuShadeModel(GU_SMOOTH); sceGuEnable(GU_BLEND); sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_8888, 0, 0, 0); sceGuTexImage(0, 256, 128, 256, font); sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA); sceGuTexEnvColor(0x0); sceGuTexOffset(0.0f, 0.0f); sceGuTexScale(1.0f / 256.0f, 1.0f / 128.0f); sceGuTexWrap(GU_REPEAT, GU_REPEAT); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuFinish(); sceGuSync(0,0); sceGuDisplay(GU_TRUE); // Check for low battery. if ((scePowerGetBatteryLifePercent() < 25) & !scePowerIsPowerOnline()) { sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); drawStringCenter("Battery charge should be at least 25% when modifying flash!", 40 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("Connect the AC adapter to ignore this warning and continue!", 40 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter(uninstall ? "Press any button to cancel uninstallation of warPSP." : "Press any button to cancel installation of warPSP.", 50 + (10 * i), 0xFF0000FF, 8); i += 2; drawObjects(); while (!scePowerIsPowerOnline()) { sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons) { cancel = 1; break; } } } if (!cancel) { float c = 0.0; for (c = 10.0; c <= 100.0; c++) { unsigned int col = 0xFF000000 | (unsigned int)((c / 100.0) * 255.0f) << 16 | (unsigned int)((c / 100.0) * 255.0f) << 8 | (unsigned int)((c / 100.0) * 255.0f) << 0; sceGuClearColor(col); clearScreenPrintHeader(90); if (quickinstall & (c > 50)) drawStringCenter("Quick Install Activated!", 250, 0xFF006600, 8); drawObjects(); } sceKernelDelayThread(3000000); for (c = 100.0; c >= 10.0; c--) { unsigned int col = 0xFF000000 | (unsigned int)((c / 100.0) * 255.0f) << 16 | (unsigned int)((c / 100.0) * 255.0f) << 8 | (unsigned int)((c / 100.0) * 255.0f) << 0; sceGuClearColor(col); clearScreenPrintHeader(90); drawObjects(); } } sceGuClearColor(0xFFFFFFFF); // Show disclaimer and options. if (!cancel & !quickinstall) { sceGuStart(GU_DIRECT, list); sceGuClear(GU_COLOR_BUFFER_BIT); drawStringCenter("!!! DISCLAIMER !!!", 40 + (10 * i), 0xFF0000FF, 10); i += 2; drawStringCenter("This program modifies the flash drive of your Sony PSP.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("You accept the risk when running this installation app.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("DO NOT REMOVE THE MEMORY STICK WHEN ORANGE LED FLASHES.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("DO NOT TURN OFF THE PSP SYSTEM WHEN ORANGE LED FLASHES.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("Press START to acknowledge and to continue to briefing.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("Press SELECT to decline and to abort installing warPSP.", 60 + (10 * i), 0xFF0000FF, 8); i += 2; drawStringCenter("THE AUTHOR DOES NOT HOLD RESPONSIBILITY FOR ANY DAMAGE.", 60 + (10 * i), 0xFF0000FF, 8); i++; drawStringCenter("THIS SOFTWARE IS PRESENTED WITHOUT WARRANTY/GUARANTEES.", 60 + (10 * i), 0xFF0000FF, 8); i += 4; drawObjects(); while (1) { sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons & PSP_CTRL_START) { break; } if (pad.Buttons & PSP_CTRL_SELECT) { cancel = 1; break; } } } // Check if backup file exists. if (!cancel & !quickinstall) { swapBuffers(); clearScreenPrintHeader(0); drawObjects(); clearScreenPrintHeader(0); drawStringCenter("Briefing", 50 + (10 * i), 0xFF000000, 0); i+= 2; drawStringCenter("Thanks for your interest in the warPSP Software Suite!", 50 + (10 * i), 0xFF006600, 0); i += 2; drawStringCenter("warPSP is an advanced warXing utility for the Sony PSP.", 50 + (10 * i), 0xFF000000, 8); i += 2; drawStringCenter("Please see the README.TXT file for more information.", 50 + (10 * i), 0xFF660000, 8); i += 3; drawStringCenter("Options", 50 + (10 * i), 0xFF000000, 0); i += 2; if (uninstall) { drawStringCenter("Press SQUARE to uninstall warPSP and restore backup files.", 50 + (10 * i), 0xFF000000, 8); i++; drawStringCenter("Press CIRCLE to reinstall warPSP to the last slot selected.", 50 + (10 * i), 0xFF000000, 8); i++; } else { drawStringCenter("Press SQUARE to install warPSP to the LFTV Player slot.", 50 + (10 * i), 0xFF000000, 8); i++; drawStringCenter("Press CIRCLE to install warPSP to the Remote Play slot.", 50 + (10 * i), 0xFF000000, 8); i++; } drawStringCenter(uninstall ? "Press SELECT to cancel uninstallation of warPSP and exit." : "Press SELECT to cancel installation of warPSP and exit.", 50 + (10 * i), 0xFF000099, 8); i += 2; drawObjects(); while (1) { sceCtrlReadBufferPositive(&pad, 1); if (uninstall) { if (pad.Buttons & PSP_CTRL_SQUARE) { break; } if (pad.Buttons & PSP_CTRL_CIRCLE) { uninstall = 0; reinstall = 1; if (fileExist(PRX_LFTVBACKUP)) lftv = 1; else lftv = 0; break; } } else { if (pad.Buttons & PSP_CTRL_SQUARE) { lftv = 1; break; } if (pad.Buttons & PSP_CTRL_CIRCLE) { lftv = 0; break; } } if (pad.Buttons & PSP_CTRL_SELECT) { cancel = 1; break; } } } if (!cancel) { if ((scePowerGetBatteryLifePercent() < 25) & !scePowerIsPowerOnline()) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter(" Battery is below 25%% and AC adapter is not connected!", 50 + (10 * i), 0xFF000099, 0); i += 2; cancel = 1; drawObjects(); } } if (cancel) { swapBuffers(); sceGuStart(GU_DIRECT, list); sprintf(buffer, "%sstallation cancelled!", uninstall ? "Unin" : "In"); drawStringCenter(buffer, 50 + (10 * i), 0xFF0000FF, 0); i += 2; drawObjects(); sceKernelDelayThread(1000000); } // Perform installation, uninstallation or reinstallation. if (!cancel) { scePowerLock(0); swapBuffers(); clearScreenPrintHeader(0); drawObjects(); clearScreenPrintHeader(0); drawObjects(); swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter(uninstall ? "Uninstallation" : "Installation", 50 + (10 * i), 0xFF990000, 0); i += 2; if (quickinstall) { drawStringCenter("Quick installing warPSP to the location free player slot.", 50 + (10 * i), 0xFF990000, 0); i += 2; } drawObjects(); swapBuffers(); sceGuStart(GU_DIRECT, list); if (uninstall) { if (fileExist(PRX_LFTVBACKUP)) { lftv = 1; ok = 1; } else if (fileExist(PRX_RPLYBACKUP)) { lftv = 0; ok = 1; } if (ok) { drawStringCenter("Backup prx found. Ok to uninstall!", 50 + (10 * i), 0xFF990000, 8); i++; drawStringCenter("The backup prx will be copied to the flash drive of your PSP!", 50 + (10 * i), 0xFF000000, 8); i += 2; drawObjects(); if (fileCopy(lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP, lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Backup file reinstalled successfully!", 50 + (10 * i), 0xFF006600, 8); sceIoRemove(lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP); uninstalled = 1; } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Backup file reinstallation failed!", 50 + (10 * i), 0xFF000099, 8); } i += 2; drawObjects(); if (uninstalled) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("To reinstall warPSP, rerun the Easy Installation Program.", 50 + (10 * i), 0xFF990000, 8); i += 2; drawObjects(); } } } else { if (fileExist(PRX_WARPSP_XMB)) { sceIoRemove(PRX_WARPSP_XMB); sceKernelDelayThread(1000000); } drawStringCenter("Extracting warPSP.prx to the root of the memory stick.", 50 + (10 * i), 0xFF000000, 8); i += 2; drawObjects(); sceKernelDelayThread(2000000); // Open PBP file and read contents into the buffer. int pbpFile, prxFile, pkgSize = 0, prxSize = 0; char buf[1024*1024]; pbpFile = sceIoOpen(PBP_WARPSP_EIP, PSP_O_RDONLY, 0); sceKernelDelayThread(1000000); if (pbpFile) { // Get size of entire package. pkgSize = sceIoRead(pbpFile, buf, sizeof(buf)); sceKernelDelayThread(1000000); if (pkgSize > 0) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("EBOOT.PBP loaded into memory successfully!", 50 + (10 * i), 0xFF006600, 8); i += 2; drawObjects(); // Calculate size of prx to extract (size of entire package - size of eboot.pbp). prxSize = pkgSize - pbpSize; // Open PRX file and write buffer into the contents. prxFile = sceIoOpen(PRX_WARPSP_XMB, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777); sceKernelDelayThread(100000); if (prxFile) { // Write prx file from end of eboot.pbp. sceIoWrite(prxFile, buf + pbpSize, prxSize); sceKernelDelayThread(1000000); sceIoClose(prxFile); sceKernelDelayThread(1000000); swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP.prx extracted from memory successfully!", 50 + (10 * i), 0xFF006600, 8); drawObjects(); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP.prx extraction from memory failed!", 50 + (10 * i), 0xFF000099, 8); drawObjects(); } i += 2; } sceIoClose(pbpFile); sceKernelDelayThread(1000000); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("EBOOT.PBP load into memory failed!", 50 + (10 * i), 0xFF000099, 8); i += 2; drawObjects(); } buf[0] = (char)"\0"; swapBuffers(); sceGuStart(GU_DIRECT, list); if (!fileExist(PRX_WARPSP_XMB)) { drawStringCenter("warPSP.prx not found! Install cancelled!", 50 + (10 * i), 0xFF000099, 8); } else { drawStringCenter("warPSP.prx found. Ok to install!", 50 + (10 * i), 0xFF006600, 8); ok = 1; } i += 2; drawObjects(); // Create backup of original file and install warPSP. if (ok) { if (!reinstall) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("The backup file will be copied to the memory stick!", 50 + (10 * i), 0xFF990000, 8); i++; drawObjects(); if (fileCopy(lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY, lftv ? PRX_LFTVBACKUP : PRX_RPLYBACKUP)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Original prx file backed up successfully!", 50 + (10 * i), 0xFF006600, 8); } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Original prx file back up failed!", 50 + (10 * i), 0xFF000099, 8); } i += 2; drawObjects(); } if (fileCopy(PRX_WARPSP_XMB, lftv ? PRX_LFTVPLAYER : PRX_REMOTEPLAY)) { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP^xmb installed successfully!", 50 + (10 * i), 0xFF006600, 8); sceIoRemove(PRX_WARPSP_XMB); installed = 1; } else { swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("warPSP^xmb installation failed!", 50 + (10 * i), 0xFF000099, 8); installed = 0; } i += 2; drawObjects(); } } scePowerUnlock(0); } if (installed | uninstalled) { sceKernelDelayThread(1000000); } if (!quickinstall) { swapBuffers(); sceGuStart(GU_DIRECT, list); sprintf(buffer, "Press any button to %s! (Auto-Exit in 10s).", (installed | uninstalled) ? "restart the PSP" : "return to the xmb"); drawStringCenter(buffer, 50 + (10 * i), 0xFF000000, 8); i++; if (installed) { drawStringCenter("Happy warXing!", 50 + (10 * i), 0xFF006600, 8); i++; } else if (uninstalled) { drawStringCenter("Thank you for using warPSP", 50 + (10 * i), 0xFF990000, 8); i++; } drawObjects(); // Wait for exit. while (1) { if (autoExit >= 1000) break; sceCtrlReadBufferPositive(&pad, 1); if (pad.Buttons) break; sceKernelDelayThread(10000); autoExit++; } } if (quickinstall) { sceKernelDelayThread(1000000); } swapBuffers(); sceGuStart(GU_DIRECT, list); drawStringCenter("Exiting!", 50 + (10 * i), (installed | uninstalled) ? 0xFF990000 : 0xFF0000FF, 8); drawObjects(); if (installed | uninstalled) { sceKernelExitGame(); scePower_0442D852(50000); } else { sceKernelExitGame(); } return 0; }
void psp_sdl_gu_stretch(SDL_Rect* srcrect, SDL_Rect* dstrect) { SDL_Surface* src = blit_surface; unsigned short old_slice = 0; /* set when we load 2nd tex */ unsigned int slice, num_slices, width, height, tbw, off_x, off_bytes; struct texVertex *vertices; char *pixels; sceKernelDcacheWritebackAll(); off_bytes = (long)(((char*)src->pixels) + srcrect->x * src->format->BytesPerPixel) & 0xf; off_x = off_bytes / src->format->BytesPerPixel; width = roundUpToPowerOfTwo(srcrect->w + off_bytes); height = roundUpToPowerOfTwo(srcrect->h); tbw = src->pitch / src->format->BytesPerPixel; /* Align the texture prior to srcrect->x */ pixels = ((char*)src->pixels) + (srcrect->x - off_x) * src->format->BytesPerPixel + src->pitch * srcrect->y; num_slices = (srcrect->w + (PSP_SLICE_SIZE - 1)) / PSP_SLICE_SIZE; /* GE doesn't appreciate textures wider than 512 */ if (width > 512) width = 512; sceGuStart(GU_DIRECT,list); sceGuEnable(GU_TEXTURE_2D); sceGuTexMode(GU_PSM_5650, 0, 0, GU_FALSE); sceGuTexImage(0, width, height, tbw, pixels); sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); sceGuTexFilter(GU_LINEAR, GU_LINEAR); for (slice = 0; slice < num_slices; slice++) { vertices = (struct texVertex*)sceGuGetMemory(2 * sizeof(struct texVertex)); if ((slice * PSP_SLICE_SIZE) < width) { vertices[0].u = slice * PSP_SLICE_SIZE + off_x; } else { if (!old_slice) { /* load another texture (src width > 512) */ pixels += width * src->format->BytesPerPixel; sceGuTexImage(0, roundUpToPowerOfTwo(srcrect->w - width), height, tbw, pixels); sceGuTexSync(); old_slice = slice; } vertices[0].u = (slice - old_slice) * PSP_SLICE_SIZE + off_x; } vertices[1].u = vertices[0].u + PSP_SLICE_SIZE; if (vertices[1].u > (off_x + srcrect->w)) vertices[1].u = off_x + srcrect->w; vertices[0].v = 0; vertices[1].v = vertices[0].v + srcrect->h; vertices[0].x = dstrect->x + (slice * PSP_SLICE_SIZE * dstrect->w + (srcrect->w - 1)) / srcrect->w; vertices[1].x = vertices[0].x + (PSP_SLICE_SIZE * dstrect->w + (srcrect->w - 1)) / srcrect->w; if (vertices[1].x > (dstrect->x + dstrect->w)) vertices[1].x = dstrect->x + dstrect->w; vertices[0].y = dstrect->y; vertices[1].y = vertices[0].y + dstrect->h; vertices[0].z = 0; vertices[1].z = 0; sceGuDrawArray(GU_SPRITES,GU_TEXTURE_16BIT|GU_VERTEX_16BIT|GU_TRANSFORM_2D, 2,0,vertices); } sceGuFinish(); sceGuSync(0, 0); }