/*

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "../../SDL_internal.h"

#if SDL_VIDEO_RENDER_PSP

#include "SDL_hints.h"

#include "../SDL_sysrender.h"

#include <pspkernel.h>

#include <pspdisplay.h>

#include <pspgu.h>

#include <pspgum.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <pspge.h>

#include <stdarg.h>

#include <stdlib.h>

#include <vram.h>

/* PSP renderer implementation, based on the PGE */

#define PSP_SCREEN_WIDTH 480

#define PSP_SCREEN_HEIGHT 272

#define PSP_FRAME_BUFFER_WIDTH 512

#define PSP_FRAME_BUFFER_SIZE (PSP_FRAME_BUFFER_WIDTH*PSP_SCREEN_HEIGHT)

static unsigned int __attribute__((aligned(16))) DisplayList[262144];

#define COL5650(r,g,b,a) ((r>>3) | ((g>>2)<<5) | ((b>>3)<<11))

#define COL5551(r,g,b,a) ((r>>3) | ((g>>3)<<5) | ((b>>3)<<10) | (a>0?0x7000:0))

#define COL4444(r,g,b,a) ((r>>4) | ((g>>4)<<4) | ((b>>4)<<8) | ((a>>4)<<12))

#define COL8888(r,g,b,a) ((r) | ((g)<<8) | ((b)<<16) | ((a)<<24))

typedef struct

{

void* frontbuffer ;

void* backbuffer ;

SDL_bool initialized ;

SDL_bool displayListAvail ;

unsigned int psm ;

unsigned int bpp ;

SDL_bool vsync;

unsigned int currentColor;

int currentBlendMode;

} PSP_RenderData;

typedef struct

{

void *data; /**< Image data. */

unsigned int size; /**< Size of data in bytes. */

unsigned int width; /**< Image width. */

unsigned int height; /**< Image height. */

unsigned int textureWidth; /**< Texture width (power of two). */

unsigned int textureHeight; /**< Texture height (power of two). */

unsigned int bits; /**< Image bits per pixel. */

unsigned int format; /**< Image format - one of ::pgePixelFormat. */

unsigned int pitch;

SDL_bool swizzled; /**< Is image swizzled. */

} PSP_TextureData;

typedef struct

{

float x, y, z;

} VertV;

typedef struct

{

float u, v;

float x, y, z;

} VertTV;

#define PI 3.14159265358979f

#define radToDeg(x) ((x)*180.f/PI)

#define degToRad(x) ((x)*PI/180.f)

float MathAbs(float x)

{

float result;

__asm__ volatile (

"mtv %1, S000\n"

"vabs.s S000, S000\n"

"mfv %0, S000\n"

: "=r"(result) : "r"(x));

return result;

}

void MathSincos(float r, float *s, float *c)

{

__asm__ volatile (

"mtv %2, S002\n"

"vcst.s S003, VFPU_2_PI\n"

"vmul.s S002, S002, S003\n"

"vrot.p C000, S002, [s, c]\n"

"mfv %0, S000\n"

"mfv %1, S001\n"

: "=r"(*s), "=r"(*c): "r"(r));

}

void Swap(float *a, float *b)

{

float n=*a;

*a = *b;

*b = n;

}

/* Return next power of 2 */

static int

TextureNextPow2(unsigned int w)

{

if(w == 0)

return 0;

unsigned int n = 2;

while(w > n)

n <<= 1;

return n;

}

static int

PixelFormatToPSPFMT(Uint32 format)

{

switch (format) {

case SDL_PIXELFORMAT_BGR565:

return GU_PSM_5650;

case SDL_PIXELFORMAT_ABGR1555:

return GU_PSM_5551;

case SDL_PIXELFORMAT_ABGR4444:

return GU_PSM_4444;

case SDL_PIXELFORMAT_ABGR8888:

return GU_PSM_8888;

default:

return GU_PSM_8888;

}

}

void

StartDrawing(SDL_Renderer * renderer)

{

PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;

if(data->displayListAvail)

return;

sceGuStart(GU_DIRECT, DisplayList);

data->displayListAvail = SDL_TRUE;

}

int

TextureSwizzle(PSP_TextureData *psp_texture)

{

if(psp_texture->swizzled)

return 1;

int bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);

int height = psp_texture->size / bytewidth;

int rowblocks = (bytewidth>>4);

int rowblocksadd = (rowblocks-1)<<7;

unsigned int blockaddress = 0;

unsigned int *src = (unsigned int*) psp_texture->data;

unsigned char *data = NULL;

data = malloc(psp_texture->size);

int j;

for(j = 0; j < height; j++, blockaddress += 16)

{

unsigned int *block;

block = (unsigned int*)&data[blockaddress];

int i;

for(i = 0; i < rowblocks; i++)

{

*block++ = *src++;

*block++ = *src++;

*block++ = *src++;

*block++ = *src++;

block += 28;

}

if((j & 0x7) == 0x7)

blockaddress += rowblocksadd;

}

free(psp_texture->data);

psp_texture->data = data;

psp_texture->swizzled = SDL_TRUE;

return 1;

}

int TextureUnswizzle(PSP_TextureData *psp_texture)

{

if(!psp_texture->swizzled)

return 1;

int blockx, blocky;

int bytewidth = psp_texture->textureWidth*(psp_texture->bits>>3);

int height = psp_texture->size / bytewidth;

int widthblocks = bytewidth/16;

int heightblocks = height/8;

int dstpitch = (bytewidth - 16)/4;

int dstrow = bytewidth * 8;

unsigned int *src = (unsigned int*) psp_texture->data;

unsigned char *data = NULL;

data = malloc(psp_texture->size);

if(!data)

return 0;

sceKernelDcacheWritebackAll();

int j;

unsigned char *ydst = (unsigned char *)data;

for(blocky = 0; blocky < heightblocks; ++blocky)

{

unsigned char *xdst = ydst;

for(blockx = 0; blockx < widthblocks; ++blockx)

{

unsigned int *block;

block = (unsigned int*)xdst;

for(j = 0; j < 8; ++j)

{

*(block++) = *(src++);

*(block++) = *(src++);

*(block++) = *(src++);

*(block++) = *(src++);

block += dstpitch;

}

xdst += 16;

}

ydst += dstrow;

}

free(psp_texture->data);

psp_texture->data = data;

psp_texture->swizzled = SDL_FALSE;

return 1;

}

static void

PSP_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)

{

}

static int

PSP_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

/* PSP_RenderData *renderdata = (PSP_RenderData *) renderer->driverdata; */

PSP_TextureData* psp_texture = (PSP_TextureData*) SDL_calloc(1, sizeof(*psp_texture));

if(!psp_texture)

return -1;

psp_texture->swizzled = SDL_FALSE;

psp_texture->width = texture->w;

psp_texture->height = texture->h;

psp_texture->textureHeight = TextureNextPow2(texture->h);

psp_texture->textureWidth = TextureNextPow2(texture->w);

psp_texture->format = PixelFormatToPSPFMT(texture->format);

switch(psp_texture->format)

{

case GU_PSM_5650:

case GU_PSM_5551:

case GU_PSM_4444:

psp_texture->bits = 16;

break;

case GU_PSM_8888:

psp_texture->bits = 32;

break;

default:

return -1;

}

psp_texture->pitch = psp_texture->textureWidth * SDL_BYTESPERPIXEL(texture->format);

psp_texture->size = psp_texture->textureHeight*psp_texture->pitch;

psp_texture->data = SDL_calloc(1, psp_texture->size);

if(!psp_texture->data)

{

SDL_free(psp_texture);

return SDL_OutOfMemory();

}

texture->driverdata = psp_texture;

return 0;

}

static int

PSP_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)

{

return SDL_Unsupported();

}

void

TextureActivate(SDL_Texture * texture)

{

PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;

/* Swizzling is useless with small textures. */

if (texture->w >= 16 || texture->h >= 16)

{

TextureSwizzle(psp_texture);

}

sceGuEnable(GU_TEXTURE_2D);

sceGuTexWrap(GU_REPEAT, GU_REPEAT);

sceGuTexMode(psp_texture->format, 0, 0, psp_texture->swizzled);

sceGuTexFilter(scaleMode, scaleMode); /* GU_NEAREST good for tile-map */

/* GU_LINEAR good for scaling */

sceGuTexImage(0, psp_texture->textureWidth, psp_texture->textureHeight, psp_texture->textureWidth, psp_texture->data);

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

}

static int

PSP_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, const void *pixels, int pitch)

{

/* PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata; */

const Uint8 *src;

Uint8 *dst;

int row, length,dpitch;

src = pixels;

PSP_LockTexture(renderer, texture,rect,(void **)&dst, &dpitch);

length = rect->w * SDL_BYTESPERPIXEL(texture->format);

if (length == pitch && length == dpitch) {

SDL_memcpy(dst, src, length*rect->h);

} else {

for (row = 0; row < rect->h; ++row) {

SDL_memcpy(dst, src, length);

src += pitch;

dst += dpitch;

}

}

sceKernelDcacheWritebackAll();

return 0;

}

static int

PSP_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, void **pixels, int *pitch)

{

PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;

*pixels =

(void *) ((Uint8 *) psp_texture->data + rect->y * psp_texture->pitch +

rect->x * SDL_BYTESPERPIXEL(texture->format));

*pitch = psp_texture->pitch;

return 0;

}

static void

PSP_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;

SDL_Rect rect;

/* We do whole texture updates, at least for now */

rect.x = 0;

rect.y = 0;

rect.w = texture->w;

rect.h = texture->h;

PSP_UpdateTexture(renderer, texture, &rect, psp_texture->data, psp_texture->pitch);

}

static int

PSP_SetRenderTarget(SDL_Renderer * renderer, SDL_Texture * texture)

{

return 0;

}

static int

}

static int

if (!verts) {

return -1;

}

for (i = 0; i < count; i++, verts++, points++) {

verts->x = points->x;

verts->y = points->y;

verts->z = 0.0f;

}

return 0;

}

static int

if (!verts) {

return -1;

}

cmd->data.draw.count = count;

for (i = 0; i < count; i++, rects++) {

verts->x = rect->x;

verts->y = rect->y;

verts->z = 0.0f;

verts++;

verts->x = rect->x + rect->w;

verts->y = rect->y + rect->h;

verts->z = 0.0f;

verts++;

}

return 0;

}

static int

PSP_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,

const SDL_Rect * srcrect, const SDL_FRect * dstrect)

VertTV *verts;

const float x = dstrect->x;

const float y = dstrect->y;

const float width = dstrect->w;

const float height = dstrect->h;

const float u0 = srcrect->x;

const float v0 = srcrect->y;

const float u1 = srcrect->x + srcrect->w;

const float v1 = srcrect->y + srcrect->h;

if((MathAbs(u1) - MathAbs(u0)) < 64.0f)

{

verts = (VertTV *) SDL_AllocateRenderVertices(renderer, 2 * sizeof (VertTV), 4, &cmd->data.draw.first);

if (!verts) {

return -1;

}

cmd->data.draw.count = 1;

verts->u = u0;

verts->v = v0;

verts->x = x;

verts->y = y;

verts->z = 0;

verts++;

verts->u = u1;

verts->v = v1;

verts->x = x + width;

verts->y = y + height;

verts->z = 0;

verts++;

}

else

{

float start, end;

float curU = u0;

float curX = x;

const float endX = x + width;

const float slice = 64.0f;

const size_t count = SDL_ceilf(width / slice);

size_t i;

float ustep = (u1 - u0)/width * slice;

if(ustep < 0.0f)

ustep = -ustep;

cmd->data.draw.count = count;

verts = (VertTV *) SDL_AllocateRenderVertices(renderer, count * sizeof (VertTV), 4, &cmd->data.draw.first);

if (!verts) {

return -1;

}

for(i = 0, start = 0, end = width; i < count; i++, start += slice)

const float polyWidth = ((curX + slice) > endX) ? (endX - curX) : slice;

const float sourceWidth = ((curU + ustep) > u1) ? (u1 - curU) : ustep;

verts->u = curU;

verts->v = v0;

verts->x = curX;

verts->y = y;

verts->z = 0;

curU += sourceWidth;

curX += polyWidth;

verts->u = curU;

verts->v = v1;

verts->x = curX;

verts->y = (y + height);

verts->z = 0;

}

}

return 0;

}

static int

PSP_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,

const SDL_Rect * srcrect, const SDL_FRect * dstrect,

const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)

VertTV *verts = (VertTV *) SDL_AllocateRenderVertices(renderer, 4 * sizeof (VertTV), 4, &cmd->data.draw.first);

const float centerx = center->x;

const float centery = center->y;

const float x = dstrect->x + centerx;

const float y = dstrect->y + centery;

const float width = dstrect->w - centerx;

const float height = dstrect->h - centery;

float s, c;

float u0 = srcrect->x;

float v0 = srcrect->y;

float u1 = srcrect->x + srcrect->w;

float v1 = srcrect->y + srcrect->h;

if (!verts) {

return -1;

}

const float cw = c * width;

const float sw = s * width;

const float ch = c * height;

const float sh = s * height;

if (flip & SDL_FLIP_VERTICAL) {

Swap(&v0, &v1);

}

if (flip & SDL_FLIP_HORIZONTAL) {

Swap(&u0, &u1);

}

verts->u = u0;

verts->v = v0;

verts->x = x - cw + sh;

verts->y = y - sw - ch;

verts->z = 0;

verts++;

verts->u = u0;

verts->v = v1;

verts->x = x - cw - sh;

verts->y = y - sw + ch;

verts->z = 0;

verts++;

verts->u = u1;

verts->v = v1;

verts->x = x + cw - sh;

verts->y = y + sw + ch;

verts->z = 0;

verts++;

verts->u = u1;

verts->v = v0;

verts->x = x + cw + sh;

verts->y = y + sw - ch;

verts->z = 0;

verts++;

return 0;

}

static void

PSP_SetBlendMode(SDL_Renderer * renderer, int blendMode)

{

PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;

if (blendMode != data-> currentBlendMode) {

switch (blendMode) {

case SDL_BLENDMODE_NONE:

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

sceGuDisable(GU_BLEND);

break;

case SDL_BLENDMODE_BLEND:

sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);

sceGuEnable(GU_BLEND);

sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 );

break;

case SDL_BLENDMODE_ADD:

sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);

sceGuEnable(GU_BLEND);

sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_FIX, 0, 0x00FFFFFF );

break;

case SDL_BLENDMODE_MOD:

sceGuTexFunc(GU_TFX_MODULATE , GU_TCC_RGBA);

sceGuEnable(GU_BLEND);

sceGuBlendFunc( GU_ADD, GU_FIX, GU_SRC_COLOR, 0, 0);

break;

}

data->currentBlendMode = blendMode;

static int

PSP_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)

{

PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;

size_t i;

/* note that before the renderer interface change, this would do extrememly small

batches with sceGuGetMemory()--a few vertices at a time--and it's not clear that

this won't fail if you try to push 100,000 draw calls in a single batch.

I don't know what the limits on PSP hardware are. It might be useful to have

rendering backends report a reasonable maximum, so the higher level can flush

if we appear to be exceeding that. */

Uint8 *gpumem = (Uint8 *) sceGuGetMemory(vertsize);

if (!gpumem) {

return SDL_SetError("Couldn't obtain a %d-byte vertex buffer!", (int) vertsize);

}

SDL_memcpy(gpumem, vertices, vertsize);

while (cmd) {

switch (cmd->command) {

case SDL_RENDERCMD_SETDRAWCOLOR: {

break; /* !!! FIXME: we could cache drawstate like color */

}

case SDL_RENDERCMD_SETVIEWPORT: {

SDL_Rect *viewport = &data->drawstate.viewport;

if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect)) != 0) {

SDL_memcpy(viewport, &cmd->data.viewport.rect, sizeof (SDL_Rect));

data->drawstate.viewport_dirty = SDL_TRUE;

}

break;

}

case SDL_RENDERCMD_SETCLIPRECT: {

const SDL_Rect *rect = &cmd->data.cliprect.rect;

if (data->drawstate.cliprect_enabled != cmd->data.cliprect.enabled) {

data->drawstate.cliprect_enabled = cmd->data.cliprect.enabled;

data->drawstate.cliprect_enabled_dirty = SDL_TRUE;

}

if (SDL_memcmp(&data->drawstate.cliprect, rect, sizeof (SDL_Rect)) != 0) {

SDL_memcpy(&data->drawstate.cliprect, rect, sizeof (SDL_Rect));

data->drawstate.cliprect_dirty = SDL_TRUE;

}

break;

}

case SDL_RENDERCMD_CLEAR: {

const Uint8 r = cmd->data.color.r;

const Uint8 g = cmd->data.color.g;

const Uint8 b = cmd->data.color.b;

const Uint8 a = cmd->data.color.a;

const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);

/* !!! FIXME: we could cache drawstate like clear color */

sceGuClearColor(color);

sceGuClearDepth(0);

sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT|GU_FAST_CLEAR_BIT);

break;

}

case SDL_RENDERCMD_DRAW_POINTS: {

const size_t count = cmd->data.draw.count;

const VertV *verts = (VertV *) (gpumem + cmd->data.draw.first);

const Uint8 r = cmd->data.draw.r;

const Uint8 g = cmd->data.draw.g;

const Uint8 b = cmd->data.draw.b;

const Uint8 a = cmd->data.draw.a;

const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);

/* !!! FIXME: we could cache draw state like color, texturing, etc */

sceGuColor(color);

sceGuDisable(GU_TEXTURE_2D);

sceGuShadeModel(GU_FLAT);

sceGuDrawArray(GU_POINTS, GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);

sceGuShadeModel(GU_SMOOTH);

sceGuEnable(GU_TEXTURE_2D);

break;

}

case SDL_RENDERCMD_DRAW_LINES: {

const size_t count = cmd->data.draw.count;

const VertV *verts = (VertV *) (gpumem + cmd->data.draw.first);

const Uint8 r = cmd->data.draw.r;

const Uint8 g = cmd->data.draw.g;

const Uint8 b = cmd->data.draw.b;

const Uint8 a = cmd->data.draw.a;

const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);

/* !!! FIXME: we could cache draw state like color, texturing, etc */

sceGuColor(color);

sceGuDisable(GU_TEXTURE_2D);

sceGuShadeModel(GU_FLAT);

sceGuDrawArray(GU_LINE_STRIP, GU_VERTEX_32BITF|GU_TRANSFORM_2D, count, 0, verts);

sceGuShadeModel(GU_SMOOTH);

sceGuEnable(GU_TEXTURE_2D);

break;

}

case SDL_RENDERCMD_FILL_RECTS: {

const size_t count = cmd->data.draw.count;

const VertV *verts = (VertV *) (gpumem + cmd->data.draw.first);

const Uint8 r = cmd->data.draw.r;

const Uint8 g = cmd->data.draw.g;

const Uint8 b = cmd->data.draw.b;

const Uint8 a = cmd->data.draw.a;

const Uint32 color = ((a << 24) | (b << 16) | (g << 8) | r);

/* !!! FIXME: we could cache draw state like color, texturing, etc */

sceGuColor(color);

sceGuDisable(GU_TEXTURE_2D);

sceGuShadeModel(GU_FLAT);

sceGuDrawArray(GU_SPRITES, GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2 * count, 0, verts);

sceGuShadeModel(GU_SMOOTH);

sceGuEnable(GU_TEXTURE_2D);

break;

}

case SDL_RENDERCMD_COPY: {

const size_t count = cmd->data.draw.count;

const VertTV *verts = (VertTV *) (gpumem + cmd->data.draw.first);

const Uint8 alpha = cmd->data.draw.a;

TextureActivate(cmd->data.draw.texture);

PSP_SetBlendMode(renderer, cmd->data.draw.blend);

if(alpha != 255) { /* !!! FIXME: is this right? */

sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);

sceGuColor(GU_RGBA(255, 255, 255, alpha));

} else {

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

sceGuColor(0xFFFFFFFF);

}

sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2 * count, 0, verts);

if(alpha != 255) {

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

}

break;

}

case SDL_RENDERCMD_COPY_EX: {

const VertTV *verts = (VertTV *) (gpumem + cmd->data.draw.first);

const Uint8 alpha = cmd->data.draw.a;

TextureActivate(cmd->data.draw.texture);

PSP_SetBlendMode(renderer, cmd->data.draw.blend);

if(alpha != 255) { /* !!! FIXME: is this right? */

sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA);

sceGuColor(GU_RGBA(255, 255, 255, alpha));

} else {

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

sceGuColor(0xFFFFFFFF);

}

sceGuDrawArray(GU_TRIANGLE_FAN, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 4, 0, verts);

if(alpha != 255) {

sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA);

}

break;

}

case SDL_RENDERCMD_NO_OP:

break;

}

cmd = cmd->next;

}

return 0;

}

static int

PSP_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,

Uint32 pixel_format, void * pixels, int pitch)

{

return SDL_Unsupported();

}

static void

PSP_RenderPresent(SDL_Renderer * renderer)

{

PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;

if(!data->displayListAvail)

return;

data->displayListAvail = SDL_FALSE;

sceGuFinish();

sceGuSync(0,0);

/* if(data->vsync) */

sceDisplayWaitVblankStart();

data->backbuffer = data->frontbuffer;

data->frontbuffer = vabsptr(sceGuSwapBuffers());

}

static void

PSP_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)

{

PSP_RenderData *renderdata = (PSP_RenderData *) renderer->driverdata;

PSP_TextureData *psp_texture = (PSP_TextureData *) texture->driverdata;

if (renderdata == 0)

return;

if(psp_texture == 0)

return;

SDL_free(psp_texture->data);

SDL_free(psp_texture);

texture->driverdata = NULL;

}

static void

PSP_DestroyRenderer(SDL_Renderer * renderer)

{

PSP_RenderData *data = (PSP_RenderData *) renderer->driverdata;

if (data) {

if (!data->initialized)

return;

StartDrawing(renderer);

sceGuTerm();

/* vfree(data->backbuffer); */

/* vfree(data->frontbuffer); */

data->initialized = SDL_FALSE;

data->displayListAvail = SDL_FALSE;

SDL_free(data);

}

SDL_free(renderer);

}

SDL_Renderer *

PSP_CreateRenderer(SDL_Window * window, Uint32 flags)

{

SDL_Renderer *renderer;

PSP_RenderData *data;

int pixelformat;

renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));

if (!renderer) {

SDL_OutOfMemory();

return NULL;

}

data = (PSP_RenderData *) SDL_calloc(1, sizeof(*data));

if (!data) {

PSP_DestroyRenderer(renderer);

SDL_OutOfMemory();

return NULL;

}

renderer->WindowEvent = PSP_WindowEvent;

renderer->CreateTexture = PSP_CreateTexture;

renderer->SetTextureColorMod = PSP_SetTextureColorMod;

renderer->UpdateTexture = PSP_UpdateTexture;

renderer->LockTexture = PSP_LockTexture;

renderer->UnlockTexture = PSP_UnlockTexture;

renderer->SetRenderTarget = PSP_SetRenderTarget;

renderer->QueueSetViewport = PSP_QueueSetViewport;

renderer->QueueSetDrawColor = PSP_QueueSetViewport; /* SetViewport and SetDrawColor are (currently) no-ops. */

renderer->QueueDrawPoints = PSP_QueueDrawPoints;

renderer->QueueDrawLines = PSP_QueueDrawPoints; /* lines and points queue vertices the same way. */

renderer->QueueFillRects = PSP_QueueFillRects;

renderer->QueueCopy = PSP_QueueCopy;

renderer->QueueCopyEx = PSP_QueueCopyEx;

renderer->RunCommandQueue = PSP_RunCommandQueue;

renderer->RenderReadPixels = PSP_RenderReadPixels;

renderer->RenderPresent = PSP_RenderPresent;

renderer->DestroyTexture = PSP_DestroyTexture;

renderer->DestroyRenderer = PSP_DestroyRenderer;

renderer->info = PSP_RenderDriver.info;

renderer->info.flags = (SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE);

renderer->driverdata = data;

renderer->window = window;

if (data->initialized != SDL_FALSE)

return 0;

data->initialized = SDL_TRUE;

if (flags & SDL_RENDERER_PRESENTVSYNC) {

data->vsync = SDL_TRUE;

} else {

data->vsync = SDL_FALSE;

}

pixelformat=PixelFormatToPSPFMT(SDL_GetWindowPixelFormat(window));

switch(pixelformat)

{

case GU_PSM_4444:

case GU_PSM_5650:

case GU_PSM_5551:

data->frontbuffer = (unsigned int *)(PSP_FRAME_BUFFER_SIZE<<1);

data->backbuffer = (unsigned int *)(0);

data->bpp = 2;

data->psm = pixelformat;

break;

default:

data->frontbuffer = (unsigned int *)(PSP_FRAME_BUFFER_SIZE<<2);

data->backbuffer = (unsigned int *)(0);

data->bpp = 4;

data->psm = GU_PSM_8888;

break;

}

sceGuInit();

/* setup GU */

sceGuStart(GU_DIRECT, DisplayList);

sceGuDrawBuffer(data->psm, data->frontbuffer, PSP_FRAME_BUFFER_WIDTH);

sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, data->backbuffer, PSP_FRAME_BUFFER_WIDTH);

sceGuOffset(2048 - (PSP_SCREEN_WIDTH>>1), 2048 - (PSP_SCREEN_HEIGHT>>1));

sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT);

data->frontbuffer = vabsptr(data->frontbuffer);

data->backbuffer = vabsptr(data->backbuffer);