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);
}
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 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);
}
static void draw_bg_map_256(BGMAP_TEXT_t* map_data, unsigned character_base_block, unsigned offsetX, unsigned offsetY)
{
return;
psp1_sprite_t* tile_coords = sceGuGetMemory(32*32*sizeof(psp1_sprite_t));
unsigned int i;
sceGuClutLoad(32, palette_ram_8bit);
sceGuClutMode(GU_PSM_5551,0,0xFF,0);
sceGuTexImage(0, 128, 256, 128, GBA_VRAMTEXTURE_8bit + character_base_block * 16 * 1024);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT |
GU_TRANSFORM_2D, 32 * 32 * 2, NULL,(void*)tile_coords);
}
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);
}
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;
}
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;
}
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;
}
void draw()
{
int x = 10, y = 10;
sceDisplaySetMode(0, SCR_WIDTH, SCR_HEIGHT);
sceGuStart(GU_DIRECT, list);
sceGuClear(GU_COLOR_BUFFER_BIT);
sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0);
sceGuClutLoad(1, clut);
drawBG();
// Reset things.
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 0);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x00);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x000000);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x00);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBox(&x, &y);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000);
nextBox(&x, &y);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0x00FF00);
nextBox(&x, &y);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0x0000FF);
nextBox(&x, &y);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x00);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x00);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x80);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x80);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGBA_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBoxHasColor(&x, &y, HASCOLOR_RGB);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGB);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGB);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, GU_AMBIENT);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFF0000);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0x0000FF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x0);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0xFF);
sceGuSendCommandi(GE_CMD_MATERIALALPHA, 0x10);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTCOLOR, 0xFFFFFF);
sceGuSendCommandi(GE_CMD_AMBIENTALPHA, 0x10);
sceGuSendCommandi(GE_CMD_LIGHTINGENABLE, 1);
nextBoxHasColor(&x, &y, HASCOLOR_RGB_TRANSPARENT);
sceGuSendCommandi(GE_CMD_MATERIALUPDATE, 0);
sceGuSendCommandi(GE_CMD_MATERIALAMBIENT, 0);
nextBox(&x, &y);
/*ScePspFVector3 pos = {x, y, 0};
sceGuLight(0, GU_DIRECTIONAL, GU_AMBIENT_AND_DIFFUSE, &pos);
nextBox(&x, &y);
pos.x = x; pos.y = y;
sceGuLight(0, GU_DIRECTIONAL, GU_AMBIENT_AND_DIFFUSE, &pos);
sceGuLightMode(GU_SINGLE_COLOR);
sceGuLightColor(0, GU_AMBIENT, 0x00FF00);
sceGuLightAtt(0, 1.0, 1.0, 1.0);
nextBox(&x, &y);*/
sceGuFinish();
sceGuSync(GU_SYNC_LIST, GU_SYNC_WHAT_DONE);
sceGuSync(0, 0);
sceDisplayWaitVblankStart();
}
void draw() {
startFrame();
sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE);
sceGuTexFilter(GU_NEAREST, GU_NEAREST);
sceGuTexFunc(GU_TFX_DECAL, GU_TCC_RGB);
sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0);
sceGuTexImage(0, 2, 2, 16, imageDataPatch);
sceGuClutLoad(1, clutRGBY);
sceGuPatchPrim(GU_TRIANGLE_STRIP);
sceGuPatchDivide(16, 16);
sceGuPatchFrontFace(GU_CW);
sceGuDisable(GU_TEXTURE_2D);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices1_simple);
// Let's see how UVs are interpolated. Simple bilinear will fail here.
sceGuEnable(GU_TEXTURE_2D);
sceGuDrawBezier(GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices2_uvs);
sceGuDisable(GU_TEXTURE_2D);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices3_colors);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices4_pos);
// Other primitive types.
sceGuSendCommandi(55, 1);
sceGuPatchDivide(4, 4);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices5_lines);
sceGuSendCommandi(55, 2);
sceGuPatchDivide(4, 4);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices6_points);
sceGuSendCommandi(55, 3);
sceGuPatchDivide(4, 4);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices7_prim3);
sceGuSendCommandi(55, 4);
sceGuPatchDivide(4, 4);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices8_prim4);
sceGuPatchPrim(GU_TRIANGLE_STRIP);
sceGuShadeModel(GU_FLAT);
sceGuPatchDivide(1, 1);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices9_div1);
sceGuPatchDivide(1, 2);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices10_div1_2);
sceGuPatchDivide(2, 2);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices11_div2);
sceGuPatchDivide(4, 4);
sceGuShadeModel(GU_SMOOTH);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 2, NULL, vertices12_4x2);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 5, NULL, vertices13_4x5);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 8, NULL, vertices14_4x8);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, indices15_inds8, vertices15_inds8);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_16BIT, 4, 4, indices16_inds16, vertices16_inds16);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_BITS, 4, 4, indices17_inds32, vertices17_inds32);
// Does the vertex pointer increment?
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices18_19_inc);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, NULL);
// And indices?
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, indices20_21_ind_inc, vertices20_21_ind_inc);
sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, NULL, NULL);
endFrame();
}
static void gba_draw_bg_mode0 (void)
{
// goto show_tiles;
RETRO_PERFORMANCE_INIT(draw_bgs_procs);
RETRO_PERFORMANCE_START(draw_bgs_procs);
sceGuEnable(GU_BLEND);
sceGuBlendFunc(GU_ADD,GU_SRC_ALPHA,GU_ONE_MINUS_SRC_ALPHA,0xFFFFFFFF,0xFFFFFFFF);
// sceGuEnable(GU_DEPTH_TEST);
sceGuDepthMask(GU_FALSE);
sceGuDepthFunc(GU_GEQUAL);
// sceGuDisable(GU_BLEND);
//BG0
if (gba_video_registers->lcd_control.screen_display_BG3)
draw_bg(&gba_video_registers->BG3_control, &gba_video_registers->BG3_scroll);
if (gba_video_registers->lcd_control.screen_display_BG2)
draw_bg(&gba_video_registers->BG2_control, &gba_video_registers->BG2_scroll);
if (gba_video_registers->lcd_control.screen_display_BG1)
draw_bg(&gba_video_registers->BG1_control, &gba_video_registers->BG1_scroll);
if (gba_video_registers->lcd_control.screen_display_BG0)
draw_bg(&gba_video_registers->BG0_control, &gba_video_registers->BG0_scroll);
RETRO_PERFORMANCE_STOP(draw_bgs_procs);
RETRO_PERFORMANCE_INIT(draw_sprites_proc);
RETRO_PERFORMANCE_START(draw_sprites_proc);
// draw_sprites_old();
// sceGuClutMode(GU_PSM_5551,0,0xFF,32);
draw_sprites();
RETRO_PERFORMANCE_STOP(draw_sprites_proc);
return;
show_tiles:
sceGuTexMode(GU_PSM_T16, 0, 0, GU_TRUE);
sceGuClutMode(GU_PSM_5551,0,0xFF,0);
sceGuClutLoad(32, palette_ram);
sceGuDisable(GU_BLEND);
sceGuEnable(GU_TEXTURE_2D);
sceGuTexFunc(GU_TFX_REPLACE,GU_TCC_RGB);
// sceGuClutMode(GU_PSM_4444,0,0xFF,0);
// sceGuClutLoad(32, index_copy_clut);
if (show_4bit_tilemap)
{
sceGuTexImage(0, 256, 256, 256, ((u16*)GBA_VRAMTEXTURE_4bit)
+ 256 * 256 * tilemap_offset);
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT |
GU_TRANSFORM_2D, 2, NULL,(void*)frame_256_256);
}
else
{
sceGuTexImage(0, 128, 256, 128, ((u16*)GBA_VRAMTEXTURE_8bit)
+ 128 * 256 * tilemap_offset);
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT |
GU_TRANSFORM_2D, 2, NULL,(void*)frame_128_256);
}
}
static void draw_sprites(void)
{
int i;
psp1_sprite_t* tile_coords = sceGuGetMemory(128*sizeof(psp1_sprite_t));
// sceGuClutLoad(32, palette_ram + 256);
int mapping_mode_1D = gba_video_registers->lcd_control.obj_character_vram_mapping;
typedef struct {
int w;
int h;
}obj_size_t;
static const obj_size_t obj_size[4][4]=
{
{{8,8},{16,16},{32,32},{64,64}},
{{16,8},{32,8},{32,16},{64,32}},
{{8,16},{8,32},{16,32},{32,64}},
{{0,0},{0,0},{0,0},{0,0}}
};
sceGuTexMode(GU_PSM_T16, 0, 0, GU_TRUE);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
sceGuTexScale_8bit(1.0,1.0);
sceGuClutLoad(32, palette_ram_4bit+256);
// for (i=0; i < 128; i++)
for (i=127; i >= 0; i--)
{
if (oam_attributes[i].obj_disable_flag)
continue;
if (oam_attributes[i].mode > 1)
continue;
if (oam_attributes[i].palette_mode_256)
{
sceGuClutLoad(32, palette_ram_8bit+256);
printf("256!\n");
sceGuClutLoad(32, palette_ram_4bit+256);
}
else
{
// printf("16!\n");
int size_id = oam_attributes[i].size;
int shape_id = oam_attributes[i].shape;
if (shape_id>3)
continue;
int width = obj_size[shape_id][size_id].w;
int height = obj_size[shape_id][size_id].h;
psp1_sprite_t temp;
temp = sprite_tiles[oam_attributes[i].flip_XY];
// temp = sprite_tiles[0];
temp.v1.x = width;
temp.v1.y = height;
*tile_coords = temp;
sceGuOffset_(-oam_attributes[i].X, -oam_attributes[i].Y);
if (mapping_mode_1D)
{
sceGuTexImage(0, width, height, width,
GBA_VRAMTEXTURE_4bit + 256*256*2 + oam_attributes[i].id * 64);
}
else
{
// printf("2d!!\n");
sceGuTexImage(0, width, height, 256,
GBA_VRAMTEXTURE_4bit + 256*256*2 + oam_attributes[i].id * 64);
}
sceGuClutMode(GU_PSM_5551,0,0x0F,oam_attributes[i].palette_id);
sceGuDrawArray(GU_SPRITES, GU_TEXTURE_8BIT | GU_VERTEX_16BIT |
GU_TRANSFORM_3D, 2, NULL,(void*)(tile_coords++));
}
}
}
static void draw_bg(REG_BGxCNT_t* BG_control, REG_BGxOFS_t* BG_scroll)
{
BGMAP_TEXT_t* map_data;
unsigned offsetX, offsetY;
map_data = (BGMAP_TEXT_t*)(vram + BG_control->screen_base_block * 0x800);
offsetX = BG_scroll->X;
offsetY = BG_scroll->Y;
sceGuTexMode(GU_PSM_T16, 0, 0, GU_TRUE);
sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);
sceGuTexScale_8bit(1.0,1.0);
sceGuEnable(GU_TEXTURE_2D);
sceGuDepthOffset(100 + BG_control->priority);
if (BG_control->palette_mode_256)
{
sceGuClutLoad(32, palette_ram_8bit);
draw_bg_map_256(map_data,BG_control->character_base_block, offsetX, offsetY);
switch (BG_control->screen_size)
{
case 1:
// printf("1!!!\n");
draw_bg_map_256(map_data + 0x800, BG_control->character_base_block, offsetX + 256, offsetY);
break;
case 2:
printf("2!!!\n");
draw_bg_map_256(map_data + 0x800, BG_control->character_base_block, offsetX, offsetY + 256);
break;
case 3:
printf("3!!!\n");
draw_bg_map_256(map_data + 0x800, BG_control->character_base_block, offsetX + 256, offsetY);
draw_bg_map_256(map_data + 0x800 * 2, BG_control->character_base_block, offsetX, offsetY + 256);
draw_bg_map_256(map_data + 0x800 * 3, BG_control->character_base_block, offsetX + 256, offsetY + 256);
}
}
else
{
sceGuClutLoad(32, palette_ram_4bit);
sceGuOffset_(offsetX, offsetY);
draw_bg_map_16(map_data,BG_control->character_base_block);
switch (BG_control->screen_size)
{
case 1:
sceGuOffset_(offsetX + 256, offsetY);
draw_bg_map_16(map_data + 0x800, BG_control->character_base_block);
break;
case 2:
sceGuOffset_(offsetX, offsetY + 256);
draw_bg_map_16(map_data + 0x800, BG_control->character_base_block);
break;
case 3:
sceGuOffset_(offsetX + 256, offsetY);
draw_bg_map_16(map_data + 0x800, BG_control->character_base_block);
sceGuOffset_(offsetX, offsetY + 256);
draw_bg_map_16(map_data + 0x800 * 2, BG_control->character_base_block);
sceGuOffset_(offsetX + 256, offsetY + 256);
draw_bg_map_16(map_data + 0x800 * 3, BG_control->character_base_block);
}
}
}
