geemili
/
SDL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ISO C90 fixes

main
Ivan Epifanov 2020-12-18 14:28:09 +03:00 committed by Sam Lantinga
parent 0de7b0eca0
commit 7d89f09f74
11 changed files with 422 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/audio/vita/SDL_vitaaudio.c
View File

@ -87,8 +87,8 @@ VITAAUD_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
} }
if(this->spec.freq < 48000) { if(this->spec.freq < 48000) {
port = SCE_AUDIO_OUT_PORT_TYPE_BGM; port = SCE_AUDIO_OUT_PORT_TYPE_BGM;
} }
this->hidden->channel = sceAudioOutOpenPort(port, this->spec.samples, this->spec.freq, format); this->hidden->channel = sceAudioOutOpenPort(port, this->spec.samples, this->spec.freq, format);
if (this->hidden->channel < 0) { if (this->hidden->channel < 0) {

28
src/file/SDL_rwops.c
View File

@ -590,20 +590,22 @@ SDL_RWFromFile(const char *file, const char *mode)
rwops->close = windows_file_close; rwops->close = windows_file_close;
rwops->type = SDL_RWOPS_WINFILE; rwops->type = SDL_RWOPS_WINFILE;
#elif defined(__VITA__) #elif defined(__VITA__)
/* Try to open the file on the filesystem first */ {
FILE *fp = fopen(file, mode); /* Try to open the file on the filesystem first */
if (fp) { FILE *fp = fopen(file, mode);
return SDL_RWFromFP(fp, 1); if (fp) {
} else { return SDL_RWFromFP(fp, 1);
/* Try opening it from app0:/ container if it's a relative path */ } else {
char path[4096]; /* Try opening it from app0:/ container if it's a relative path */
SDL_snprintf(path, 4096, "app0:/%s", file); char path[4096];
fp = fopen(path, mode); SDL_snprintf(path, 4096, "app0:/%s", file);
if (fp) { fp = fopen(path, mode);
return SDL_RWFromFP(fp, 1); if (fp) {
} return SDL_RWFromFP(fp, 1);
}
}
SDL_SetError("Couldn't open %s", file);
} }
SDL_SetError("Couldn't open %s", file);
#elif HAVE_STDIO_H #elif HAVE_STDIO_H
{ {
#ifdef __APPLE__ #ifdef __APPLE__

42
src/joystick/vita/SDL_sysjoystick.c
View File

@ -67,10 +67,10 @@ static point c = { 128, 32767 };
static point d = { 128, 32767 }; static point d = { 128, 32767 };
/* simple linear interpolation between two points */ /* simple linear interpolation between two points */
static SDL_INLINE void lerp (point *dest, point *a, point *b, float t) static SDL_INLINE void lerp (point *dest, point *first, point *second, float t)
{ {
dest->x = a->x + (b->x - a->x)*t; dest->x = first->x + (second->x - first->x) * t;
dest->y = a->y + (b->y - a->y)*t; dest->y = first->y + (second->y - first->y) * t;
} }
/* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */ /* evaluate a point on a bezier-curve. t goes from 0 to 1.0 */
@ -93,6 +93,7 @@ static int calc_bezier_y(float t)
int VITA_JoystickInit(void) int VITA_JoystickInit(void)
{ {
int i; int i;
SceCtrlPortInfo myPortInfo;
/* Setup input */ /* Setup input */
sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE); sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE);
@ -106,27 +107,26 @@ int VITA_JoystickInit(void)
analog_map[127-i] = -1 * analog_map[i+128]; analog_map[127-i] = -1 * analog_map[i+128];
} }
SceCtrlPortInfo myPortInfo; // Assume we have at least one controller, even when nothing is paired
// This way the user can jump in, pair a controller
// and control things immediately even if it is paired
// after the app has already started.
// Assume we have at least one controller, even when nothing is paired SDL_numjoysticks = 1;
// This way the user can jump in, pair a controller
// and control things immediately even if it is paired
// after the app has already started.
SDL_numjoysticks = 1; // How many additional paired controllers are there?
sceCtrlGetControllerPortInfo(&myPortInfo);
//How many additional paired controllers are there? // On Vita TV, port 0 and 1 are the same controller
sceCtrlGetControllerPortInfo(&myPortInfo); // and that is the first one, so start at port 2
//On Vita TV, port 0 and 1 are the same controller for (i=2; i<=4; i++)
//and that is the first one, so start at port 2 {
for (i=2; i<=4; i++) if (myPortInfo.port[i]!=SCE_CTRL_TYPE_UNPAIRED)
{ {
if (myPortInfo.port[i]!=SCE_CTRL_TYPE_UNPAIRED) SDL_numjoysticks++;
{ }
SDL_numjoysticks++; }
} return SDL_numjoysticks;
}
return SDL_numjoysticks;
} }
int VITA_JoystickGetCount() int VITA_JoystickGetCount()

100
src/render/vitagxm/SDL_render_vita_gxm.c
View File

@ -470,12 +470,14 @@ VITA_GXM_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const S
static int static int
VITA_GXM_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count) VITA_GXM_QueueFillRects(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const SDL_FRect * rects, int count)
{ {
int color;
color_vertex *vertices;
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
cmd->data.draw.count = count; cmd->data.draw.count = count;
int color = data->drawstate.color; color = data->drawstate.color;
color_vertex *vertices = (color_vertex *)pool_memalign( vertices = (color_vertex *)pool_memalign(
data, data,
4 * count * sizeof(color_vertex), // 4 vertices * count 4 * count * sizeof(color_vertex), // 4 vertices * count
sizeof(color_vertex)); sizeof(color_vertex));
@ -532,12 +534,13 @@ static int
VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture, VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect) const SDL_Rect * srcrect, const SDL_FRect * dstrect)
{ {
texture_vertex *vertices;
float u0, v0, u1, v1;
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
cmd->data.draw.count = 1; cmd->data.draw.count = 1;
texture_vertex *vertices = (texture_vertex *)pool_memalign( vertices = (texture_vertex *)pool_memalign(
data, data,
4 * sizeof(texture_vertex), // 4 vertices 4 * sizeof(texture_vertex), // 4 vertices
sizeof(texture_vertex)); sizeof(texture_vertex));
@ -545,10 +548,10 @@ VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture
cmd->data.draw.first = (size_t)vertices; cmd->data.draw.first = (size_t)vertices;
cmd->data.draw.texture = texture; cmd->data.draw.texture = texture;
const float u0 = (float)srcrect->x / (float)texture->w; u0 = (float)srcrect->x / (float)texture->w;
const float v0 = (float)srcrect->y / (float)texture->h; v0 = (float)srcrect->y / (float)texture->h;
const float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
const float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
vertices[0].x = dstrect->x; vertices[0].x = dstrect->x;
vertices[0].y = dstrect->y; vertices[0].y = dstrect->y;
@ -582,11 +585,23 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
const SDL_Rect * srcrect, const SDL_FRect * dstrect, const SDL_Rect * srcrect, const SDL_FRect * dstrect,
const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip) const double angle, const SDL_FPoint *center, const SDL_RendererFlip flip)
{ {
texture_vertex *vertices;
float u0, v0, u1, v1;
float s, c;
float cw, sw, ch, sh;
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
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;
cmd->data.draw.count = 1; cmd->data.draw.count = 1;
texture_vertex *vertices = (texture_vertex *)pool_memalign( vertices = (texture_vertex *)pool_memalign(
data, data,
4 * sizeof(texture_vertex), // 4 vertices 4 * sizeof(texture_vertex), // 4 vertices
sizeof(texture_vertex)); sizeof(texture_vertex));
@ -594,10 +609,10 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
cmd->data.draw.first = (size_t)vertices; cmd->data.draw.first = (size_t)vertices;
cmd->data.draw.texture = texture; cmd->data.draw.texture = texture;
float u0 = (float)srcrect->x / (float)texture->w; u0 = (float)srcrect->x / (float)texture->w;
float v0 = (float)srcrect->y / (float)texture->h; v0 = (float)srcrect->y / (float)texture->h;
float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w;
float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h;
if (flip & SDL_FLIP_VERTICAL) { if (flip & SDL_FLIP_VERTICAL) {
Swap(&v0, &v1); Swap(&v0, &v1);
@ -607,20 +622,13 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
Swap(&u0, &u1); Swap(&u0, &u1);
} }
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;
MathSincos(degToRad(angle), &s, &c); MathSincos(degToRad(angle), &s, &c);
const float cw = c * width; cw = c * width;
const float sw = s * width; sw = s * width;
const float ch = c * height; ch = c * height;
const float sh = s * height; sh = s * height;
vertices[0].x = x - cw + sh; vertices[0].x = x - cw + sh;
vertices[0].y = y - sw - ch; vertices[0].y = y - sw - ch;
@ -654,9 +662,11 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur
static int static int
VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd) VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
{ {
void *color_buffer;
float clear_color[4];
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
float clear_color[4];
clear_color[0] = (cmd->data.color.r)/255.0f; clear_color[0] = (cmd->data.color.r)/255.0f;
clear_color[1] = (cmd->data.color.g)/255.0f; clear_color[1] = (cmd->data.color.g)/255.0f;
clear_color[2] = (cmd->data.color.b)/255.0f; clear_color[2] = (cmd->data.color.b)/255.0f;
@ -669,7 +679,6 @@ VITA_GXM_RenderClear(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
sceGxmSetFragmentProgram(data->gxm_context, data->clearFragmentProgram); sceGxmSetFragmentProgram(data->gxm_context, data->clearFragmentProgram);
// set the clear color // set the clear color
void *color_buffer;
sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer); sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer);
sceGxmSetUniformDataF(color_buffer, data->clearClearColorParam, 0, 4, clear_color); sceGxmSetUniformDataF(color_buffer, data->clearClearColorParam, 0, 4, clear_color);
@ -726,6 +735,7 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
SceGxmVertexProgram *vertex_program; SceGxmVertexProgram *vertex_program;
SDL_bool matrix_updated = SDL_FALSE; SDL_bool matrix_updated = SDL_FALSE;
SDL_bool program_updated = SDL_FALSE; SDL_bool program_updated = SDL_FALSE;
Uint32 texture_color;
Uint8 r, g, b, a; Uint8 r, g, b, a;
r = cmd->data.draw.r; r = cmd->data.draw.r;
@ -802,7 +812,7 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
program_updated = SDL_TRUE; program_updated = SDL_TRUE;
} }
Uint32 texture_color = ((a << 24) | (b << 16) | (g << 8) | r); texture_color = ((a << 24) | (b << 16) | (g << 8) | r);
if (program_updated || matrix_updated) { if (program_updated || matrix_updated) {
if (data->drawstate.fragment_program == data->textureFragmentProgram) { if (data->drawstate.fragment_program == data->textureFragmentProgram) {
@ -811,13 +821,14 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix); sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
} else if (data->drawstate.fragment_program == data->textureTintFragmentProgram) { } else if (data->drawstate.fragment_program == data->textureTintFragmentProgram) {
void *vertex_wvp_buffer; void *vertex_wvp_buffer;
void *texture_tint_color_buffer;
float *tint_color;
sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer); sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer);
sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix); sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix);
void *texture_tint_color_buffer;
sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer); sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer);
float *tint_color = pool_memalign( tint_color = pool_memalign(
data, data,
4 * sizeof(float), // RGBA 4 * sizeof(float), // RGBA
sizeof(float) sizeof(float)
@ -837,9 +848,10 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s
} else { } else {
if (data->drawstate.fragment_program == data->textureTintFragmentProgram && data->drawstate.texture_color != texture_color) { if (data->drawstate.fragment_program == data->textureTintFragmentProgram && data->drawstate.texture_color != texture_color) {
void *texture_tint_color_buffer; void *texture_tint_color_buffer;
float *tint_color;
sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer); sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer);
float *tint_color = pool_memalign( tint_color = pool_memalign(
data, data,
4 * sizeof(float), // RGBA 4 * sizeof(float), // RGBA
sizeof(float) sizeof(float)
@ -879,8 +891,8 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd)
static int static int
VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize) VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
{ {
StartDrawing(renderer);
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
StartDrawing(renderer);
data->drawstate.target = renderer->target; data->drawstate.target = renderer->target;
if (!data->drawstate.target) { if (!data->drawstate.target) {
@ -963,13 +975,16 @@ VITA_GXM_RunCommandQueue(SDL_Renderer * renderer, SDL_RenderCommand *cmd, void *
void read_pixels(int x, int y, size_t width, size_t height, void *data) { void read_pixels(int x, int y, size_t width, size_t height, void *data) {
SceDisplayFrameBuf pParam; SceDisplayFrameBuf pParam;
int i, j;
Uint32 *out32;
Uint32 *in32;
pParam.size = sizeof(SceDisplayFrameBuf); pParam.size = sizeof(SceDisplayFrameBuf);
sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME); sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME);
int i, j; out32 = (Uint32 *)data;
Uint32 *out32 = (Uint32 *)data; in32 = (Uint32 *)pParam.base;
Uint32 *in32 = (Uint32 *)pParam.base;
in32 += (x + y * pParam.pitch); in32 += (x + y * pParam.pitch);
@ -986,11 +1001,6 @@ static int
VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
Uint32 pixel_format, void *pixels, int pitch) Uint32 pixel_format, void *pixels, int pitch)
{ {
// TODO: read from texture rendertarget. Although no-one sane should do it.
if (renderer->target) {
return SDL_Unsupported();
}
Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888; Uint32 temp_format = renderer->target ? renderer->target->format : SDL_PIXELFORMAT_ABGR8888;
size_t buflen; size_t buflen;
void *temp_pixels; void *temp_pixels;
@ -999,6 +1009,12 @@ VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect,
int w, h, length, rows; int w, h, length, rows;
int status; int status;
// TODO: read from texture rendertarget. Although no-one sane should do it.
if (renderer->target) {
return SDL_Unsupported();
}
temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format); temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
buflen = rect->h * temp_pitch; buflen = rect->h * temp_pitch;
if (buflen == 0) { if (buflen == 0) {
@ -1047,14 +1063,10 @@ static void
VITA_GXM_RenderPresent(SDL_Renderer *renderer) VITA_GXM_RenderPresent(SDL_Renderer *renderer)
{ {
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
SceCommonDialogUpdateParam updateParam;
// sceGxmFinish(data->gxm_context);
data->displayData.address = data->displayBufferData[data->backBufferIndex]; data->displayData.address = data->displayBufferData[data->backBufferIndex];
SceCommonDialogUpdateParam updateParam;
SDL_memset(&updateParam, 0, sizeof(updateParam)); SDL_memset(&updateParam, 0, sizeof(updateParam));
updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT; updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT;

471
src/render/vitagxm/SDL_render_vita_gxm_tools.c
View File

@ -71,8 +71,8 @@ init_orthographic_matrix(float *m, float left, float right, float bottom, float
static void * static void *
patcher_host_alloc(void *user_data, unsigned int size) patcher_host_alloc(void *user_data, unsigned int size)
{ {
(void)user_data;
void *mem = SDL_malloc(size); void *mem = SDL_malloc(size);
(void)user_data;
return mem; return mem;
} }
@ -222,6 +222,7 @@ make_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out,
static void static void
set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h) set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
{ {
void *vertexDefaultBuffer;
color_vertex *vertices = (color_vertex *)pool_memalign( color_vertex *vertices = (color_vertex *)pool_memalign(
data, data,
4 * sizeof(color_vertex), // 4 vertices 4 * sizeof(color_vertex), // 4 vertices
@ -253,7 +254,6 @@ set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h)
sceGxmSetVertexProgram(data->gxm_context, data->colorVertexProgram); sceGxmSetVertexProgram(data->gxm_context, data->colorVertexProgram);
sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram); sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram);
void *vertexDefaultBuffer;
sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer); sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer);
sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix); sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix);
@ -324,6 +324,84 @@ gxm_init(SDL_Renderer *renderer)
{ {
unsigned int i, x, y; unsigned int i, x, y;
int err; int err;
void *vdmRingBuffer;
void *vertexRingBuffer;
void *fragmentRingBuffer;
unsigned int fragmentUsseRingBufferOffset;
void *fragmentUsseRingBuffer;
unsigned int patcherVertexUsseOffset;
unsigned int patcherFragmentUsseOffset;
void *patcherBuffer;
void *patcherVertexUsse;
void *patcherFragmentUsse;
SceGxmRenderTargetParams renderTargetParams;
SceGxmShaderPatcherParams patcherParams;
// compute the memory footprint of the depth buffer
const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
unsigned int sampleCount = alignedWidth * alignedHeight;
unsigned int depthStrideInSamples = alignedWidth;
// set buffer sizes for this sample
const unsigned int patcherBufferSize = 64*1024;
const unsigned int patcherVertexUsseSize = 64*1024;
const unsigned int patcherFragmentUsseSize = 64*1024;
// Fill SceGxmBlendInfo
static const SceGxmBlendInfo blend_info_none = {
.colorFunc = SCE_GXM_BLEND_FUNC_NONE,
.alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
.colorSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.colorDst = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaDst = SCE_GXM_BLEND_FACTOR_ZERO,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_blend = {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD,
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ONE,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_add = {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD,
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_mod = {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD,
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
.colorSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.colorDst = SCE_GXM_BLEND_FACTOR_SRC_COLOR,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_mul = {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD,
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD,
.colorSrc = SCE_GXM_BLEND_FACTOR_DST_COLOR,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaSrc = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata;
@ -343,29 +421,28 @@ gxm_init(SDL_Renderer *renderer)
} }
// allocate ring buffer memory using default sizes // allocate ring buffer memory using default sizes
void *vdmRingBuffer = mem_gpu_alloc( vdmRingBuffer = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE,
4, 4,
SCE_GXM_MEMORY_ATTRIB_READ, SCE_GXM_MEMORY_ATTRIB_READ,
&data->vdmRingBufferUid); &data->vdmRingBufferUid);
void *vertexRingBuffer = mem_gpu_alloc( vertexRingBuffer = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE,
4, 4,
SCE_GXM_MEMORY_ATTRIB_READ, SCE_GXM_MEMORY_ATTRIB_READ,
&data->vertexRingBufferUid); &data->vertexRingBufferUid);
void *fragmentRingBuffer = mem_gpu_alloc( fragmentRingBuffer = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE,
4, 4,
SCE_GXM_MEMORY_ATTRIB_READ, SCE_GXM_MEMORY_ATTRIB_READ,
&data->fragmentRingBufferUid); &data->fragmentRingBufferUid);
unsigned int fragmentUsseRingBufferOffset; fragmentUsseRingBuffer = mem_fragment_usse_alloc(
void *fragmentUsseRingBuffer = mem_fragment_usse_alloc(
SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE,
&data->fragmentUsseRingBufferUid, &data->fragmentUsseRingBufferUid,
&fragmentUsseRingBufferOffset); &fragmentUsseRingBufferOffset);
@ -390,7 +467,6 @@ gxm_init(SDL_Renderer *renderer)
} }
// set up parameters // set up parameters
SceGxmRenderTargetParams renderTargetParams;
SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
renderTargetParams.flags = 0; renderTargetParams.flags = 0;
renderTargetParams.width = VITA_GXM_SCREEN_WIDTH; renderTargetParams.width = VITA_GXM_SCREEN_WIDTH;
@ -454,12 +530,6 @@ gxm_init(SDL_Renderer *renderer)
} }
// compute the memory footprint of the depth buffer
const unsigned int alignedWidth = ALIGN(VITA_GXM_SCREEN_WIDTH, SCE_GXM_TILE_SIZEX);
const unsigned int alignedHeight = ALIGN(VITA_GXM_SCREEN_HEIGHT, SCE_GXM_TILE_SIZEY);
unsigned int sampleCount = alignedWidth * alignedHeight;
unsigned int depthStrideInSamples = alignedWidth;
// allocate the depth buffer // allocate the depth buffer
data->depthBufferData = mem_gpu_alloc( data->depthBufferData = mem_gpu_alloc(
@ -500,33 +570,26 @@ gxm_init(SDL_Renderer *renderer)
0xFF, 0xFF,
0xFF); 0xFF);
// set buffer sizes for this sample
const unsigned int patcherBufferSize = 64*1024;
const unsigned int patcherVertexUsseSize = 64*1024;
const unsigned int patcherFragmentUsseSize = 64*1024;
// allocate memory for buffers and USSE code // allocate memory for buffers and USSE code
void *patcherBuffer = mem_gpu_alloc( patcherBuffer = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
patcherBufferSize, patcherBufferSize,
4, 4,
SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE,
&data->patcherBufferUid); &data->patcherBufferUid);
unsigned int patcherVertexUsseOffset; patcherVertexUsse = mem_vertex_usse_alloc(
void *patcherVertexUsse = mem_vertex_usse_alloc(
patcherVertexUsseSize, patcherVertexUsseSize,
&data->patcherVertexUsseUid, &data->patcherVertexUsseUid,
&patcherVertexUsseOffset); &patcherVertexUsseOffset);
unsigned int patcherFragmentUsseOffset; patcherFragmentUsse = mem_fragment_usse_alloc(
void *patcherFragmentUsse = mem_fragment_usse_alloc(
patcherFragmentUsseSize, patcherFragmentUsseSize,
&data->patcherFragmentUsseUid, &data->patcherFragmentUsseUid,
&patcherFragmentUsseOffset); &patcherFragmentUsseOffset);
// create a shader patcher // create a shader patcher
SceGxmShaderPatcherParams patcherParams;
SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams)); SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams));
patcherParams.userData = NULL; patcherParams.userData = NULL;
patcherParams.hostAllocCallback = &patcher_host_alloc; patcherParams.hostAllocCallback = &patcher_host_alloc;
@ -639,111 +702,61 @@ gxm_init(SDL_Renderer *renderer)
return err; return err;
} }
// Fill SceGxmBlendInfo
static const SceGxmBlendInfo blend_info_none = {
.colorFunc = SCE_GXM_BLEND_FUNC_NONE,
.alphaFunc = SCE_GXM_BLEND_FUNC_NONE,
.colorSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.colorDst = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO,
.alphaDst = SCE_GXM_BLEND_FACTOR_ZERO,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_blend = { {
.colorFunc = SCE_GXM_BLEND_FUNC_ADD, // get attributes by name to create vertex format bindings
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD, const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaSrc = SCE_GXM_BLEND_FACTOR_ONE,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
static const SceGxmBlendInfo blend_info_add = { // create clear vertex format
.colorFunc = SCE_GXM_BLEND_FUNC_ADD, SceGxmVertexAttribute clearVertexAttributes[1];
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD, SceGxmVertexStream clearVertexStreams[1];
.colorSrc = SCE_GXM_BLEND_FACTOR_SRC_ALPHA, clearVertexAttributes[0].streamIndex = 0;
.colorDst = SCE_GXM_BLEND_FACTOR_ONE, clearVertexAttributes[0].offset = 0;
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO, clearVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE, clearVertexAttributes[0].componentCount = 2;
.colorMask = SCE_GXM_COLOR_MASK_ALL clearVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramClearPositionAttribute);
}; clearVertexStreams[0].stride = sizeof(clear_vertex);
clearVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
static const SceGxmBlendInfo blend_info_mod = { // create clear programs
.colorFunc = SCE_GXM_BLEND_FUNC_ADD, err = sceGxmShaderPatcherCreateVertexProgram(
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD, data->shaderPatcher,
data->clearVertexProgramId,
clearVertexAttributes,
1,
clearVertexStreams,
1,
&data->clearVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear vertex) failed: %d\n", err);
return err;
}
.colorSrc = SCE_GXM_BLEND_FACTOR_ZERO, err = sceGxmShaderPatcherCreateFragmentProgram(
.colorDst = SCE_GXM_BLEND_FACTOR_SRC_COLOR, data->shaderPatcher,
data->clearFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
0,
NULL,
clearVertexProgramGxp,
&data->clearFragmentProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear fragment) failed: %d\n", err);
return err;
}
.alphaSrc = SCE_GXM_BLEND_FACTOR_ZERO, // create the clear triangle vertex/index data
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE, data->clearVertices = (clear_vertex *)mem_gpu_alloc(
.colorMask = SCE_GXM_COLOR_MASK_ALL SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
}; 3*sizeof(clear_vertex),
4,
static const SceGxmBlendInfo blend_info_mul = { SCE_GXM_MEMORY_ATTRIB_READ,
.colorFunc = SCE_GXM_BLEND_FUNC_ADD, &data->clearVerticesUid
.alphaFunc = SCE_GXM_BLEND_FUNC_ADD, );
.colorSrc = SCE_GXM_BLEND_FACTOR_DST_COLOR,
.colorDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaSrc = SCE_GXM_BLEND_FACTOR_DST_ALPHA,
.alphaDst = SCE_GXM_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorMask = SCE_GXM_COLOR_MASK_ALL
};
// get attributes by name to create vertex format bindings
const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
// create clear vertex format
SceGxmVertexAttribute clearVertexAttributes[1];
SceGxmVertexStream clearVertexStreams[1];
clearVertexAttributes[0].streamIndex = 0;
clearVertexAttributes[0].offset = 0;
clearVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
clearVertexAttributes[0].componentCount = 2;
clearVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramClearPositionAttribute);
clearVertexStreams[0].stride = sizeof(clear_vertex);
clearVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create clear programs
err = sceGxmShaderPatcherCreateVertexProgram(
data->shaderPatcher,
data->clearVertexProgramId,
clearVertexAttributes,
1,
clearVertexStreams,
1,
&data->clearVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear vertex) failed: %d\n", err);
return err;
} }
err = sceGxmShaderPatcherCreateFragmentProgram(
data->shaderPatcher,
data->clearFragmentProgramId,
SCE_GXM_OUTPUT_REGISTER_FORMAT_UCHAR4,
0,
NULL,
clearVertexProgramGxp,
&data->clearFragmentProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (clear fragment) failed: %d\n", err);
return err;
}
// create the clear triangle vertex/index data
data->clearVertices = (clear_vertex *)mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
3*sizeof(clear_vertex),
4,
SCE_GXM_MEMORY_ATTRIB_READ,
&data->clearVerticesUid
);
// Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible // Allocate a 64k * 2 bytes = 128 KiB buffer and store all possible
// 16-bit indices in linear ascending order, so we can use this for // 16-bit indices in linear ascending order, so we can use this for
// all drawing operations where we don't want to use indexing. // all drawing operations where we don't want to use indexing.
@ -755,7 +768,7 @@ gxm_init(SDL_Renderer *renderer)
&data->linearIndicesUid &data->linearIndicesUid
); );
for (uint32_t i=0; i<=UINT16_MAX; ++i) for (i = 0; i <= UINT16_MAX; ++i)
{ {
data->linearIndices[i] = i; data->linearIndices[i] = i;
} }
@ -767,79 +780,86 @@ gxm_init(SDL_Renderer *renderer)
data->clearVertices[2].x = -1.0f; data->clearVertices[2].x = -1.0f;
data->clearVertices[2].y = 3.0f; data->clearVertices[2].y = 3.0f;
const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition"); {
const SceGxmProgramParameter *paramColorPositionAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aPosition");
const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor"); const SceGxmProgramParameter *paramColorColorAttribute = sceGxmProgramFindParameterByName(colorVertexProgramGxp, "aColor");
// create color vertex format // create color vertex format
SceGxmVertexAttribute colorVertexAttributes[2]; SceGxmVertexAttribute colorVertexAttributes[2];
SceGxmVertexStream colorVertexStreams[1]; SceGxmVertexStream colorVertexStreams[1];
/* x,y,z: 3 float 32 bits */ /* x,y,z: 3 float 32 bits */
colorVertexAttributes[0].streamIndex = 0; colorVertexAttributes[0].streamIndex = 0;
colorVertexAttributes[0].offset = 0; colorVertexAttributes[0].offset = 0;
colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
colorVertexAttributes[0].componentCount = 3; // (x, y, z) colorVertexAttributes[0].componentCount = 3; // (x, y, z)
colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute); colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute);
/* color: 4 unsigned char = 32 bits */ /* color: 4 unsigned char = 32 bits */
colorVertexAttributes[1].streamIndex = 0; colorVertexAttributes[1].streamIndex = 0;
colorVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes colorVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes
colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N; colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N;
colorVertexAttributes[1].componentCount = 4; // (color) colorVertexAttributes[1].componentCount = 4; // (color)
colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute); colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute);
// 16 bit (short) indices // 16 bit (short) indices
colorVertexStreams[0].stride = sizeof(color_vertex); colorVertexStreams[0].stride = sizeof(color_vertex);
colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create color shaders
err = sceGxmShaderPatcherCreateVertexProgram(
data->shaderPatcher,
data->colorVertexProgramId,
colorVertexAttributes,
2,
colorVertexStreams,
1,
&data->colorVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (color vertex) failed: %d\n", err);
return err;
}
// create color shaders
err = sceGxmShaderPatcherCreateVertexProgram(
data->shaderPatcher,
data->colorVertexProgramId,
colorVertexAttributes,
2,
colorVertexStreams,
1,
&data->colorVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (color vertex) failed: %d\n", err);
return err;
} }
const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
// create texture vertex format {
SceGxmVertexAttribute textureVertexAttributes[2]; const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
SceGxmVertexStream textureVertexStreams[1]; const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
/* x,y,z: 3 float 32 bits */
textureVertexAttributes[0].streamIndex = 0; // create texture vertex format
textureVertexAttributes[0].offset = 0; SceGxmVertexAttribute textureVertexAttributes[2];
textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; SceGxmVertexStream textureVertexStreams[1];
textureVertexAttributes[0].componentCount = 3; // (x, y, z) /* x,y,z: 3 float 32 bits */
textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute); textureVertexAttributes[0].streamIndex = 0;
/* u,v: 2 floats 32 bits */ textureVertexAttributes[0].offset = 0;
textureVertexAttributes[1].streamIndex = 0; textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
textureVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes textureVertexAttributes[0].componentCount = 3; // (x, y, z)
textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute);
textureVertexAttributes[1].componentCount = 2; // (u, v) /* u,v: 2 floats 32 bits */
textureVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureTexcoordAttribute); textureVertexAttributes[1].streamIndex = 0;
// 16 bit (short) indices textureVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes
textureVertexStreams[0].stride = sizeof(texture_vertex); textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32;
textureVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; textureVertexAttributes[1].componentCount = 2; // (u, v)
textureVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramTextureTexcoordAttribute);
// 16 bit (short) indices
textureVertexStreams[0].stride = sizeof(texture_vertex);
textureVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT;
// create texture shaders
err = sceGxmShaderPatcherCreateVertexProgram(
data->shaderPatcher,
data->textureVertexProgramId,
textureVertexAttributes,
2,
textureVertexStreams,
1,
&data->textureVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (texture vertex) failed: %d\n", err);
return err;
}
// create texture shaders
err = sceGxmShaderPatcherCreateVertexProgram(
data->shaderPatcher,
data->textureVertexProgramId,
textureVertexAttributes,
2,
textureVertexStreams,
1,
&data->textureVertexProgram
);
if (err != SCE_OK) {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create program (texture vertex) failed: %d\n", err);
return err;
} }
// Create variations of the fragment program based on blending mode // Create variations of the fragment program based on blending mode
@ -849,12 +869,15 @@ gxm_init(SDL_Renderer *renderer)
make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod, &blend_info_mod); make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mod, &blend_info_mod);
make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul, &blend_info_mul); make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_mul, &blend_info_mul);
// Default to blend blending mode {
fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend; // Default to blend blending mode
fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
data->colorFragmentProgram = in->color; data->colorFragmentProgram = in->color;
data->textureFragmentProgram = in->texture; data->textureFragmentProgram = in->texture;
data->textureTintFragmentProgram = in->textureTint; data->textureTintFragmentProgram = in->textureTint;
}
// find vertex uniforms by name and cache parameter information // find vertex uniforms by name and cache parameter information
data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor"); data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor");
@ -1019,15 +1042,18 @@ gxm_texture_get_datap(const gxm_texture *texture)
gxm_texture * gxm_texture *
create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget) create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, SceGxmTextureFormat format, unsigned int isRenderTarget)
{ {
format = SCE_GXM_TEXTURE_FORMAT_A8B8G8R8;
gxm_texture *texture = SDL_malloc(sizeof(gxm_texture)); gxm_texture *texture = SDL_malloc(sizeof(gxm_texture));
const int tex_size = ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
void *texture_data;
format = SCE_GXM_TEXTURE_FORMAT_A8B8G8R8;
if (!texture) if (!texture)
return NULL; return NULL;
const int tex_size = ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format);
/* Allocate a GPU buffer for the texture */ /* Allocate a GPU buffer for the texture */
void *texture_data = mem_gpu_alloc( texture_data = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW, SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW,
tex_size, tex_size,
SCE_GXM_TEXTURE_ALIGNMENT, SCE_GXM_TEXTURE_ALIGNMENT,
@ -1070,6 +1096,11 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
} }
if (isRenderTarget) { if (isRenderTarget) {
void *depthBufferData;
const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
uint32_t sampleCount = alignedWidth*alignedHeight;
uint32_t depthStrideInSamples = alignedWidth;
int err = sceGxmColorSurfaceInit( int err = sceGxmColorSurfaceInit(
&texture->gxm_colorsurface, &texture->gxm_colorsurface,
@ -1089,14 +1120,8 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
return NULL; return NULL;
} }
// create the depth/stencil surface
const uint32_t alignedWidth = ALIGN(w, SCE_GXM_TILE_SIZEX);
const uint32_t alignedHeight = ALIGN(h, SCE_GXM_TILE_SIZEY);
uint32_t sampleCount = alignedWidth*alignedHeight;
uint32_t depthStrideInSamples = alignedWidth;
// allocate it // allocate it
void *depthBufferData = mem_gpu_alloc( depthBufferData = mem_gpu_alloc(
SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE,
4*sampleCount, 4*sampleCount,
SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT, SCE_GXM_DEPTHSTENCIL_SURFACE_ALIGNMENT,
@ -1118,28 +1143,30 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
return NULL; return NULL;
} }
SceGxmRenderTarget *tgt = NULL; {
SceGxmRenderTarget *tgt = NULL;
// set up parameters // set up parameters
SceGxmRenderTargetParams renderTargetParams; SceGxmRenderTargetParams renderTargetParams;
memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams));
renderTargetParams.flags = 0; renderTargetParams.flags = 0;
renderTargetParams.width = w; renderTargetParams.width = w;
renderTargetParams.height = h; renderTargetParams.height = h;
renderTargetParams.scenesPerFrame = 1; renderTargetParams.scenesPerFrame = 1;
renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE; renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE;
renderTargetParams.multisampleLocations = 0; renderTargetParams.multisampleLocations = 0;
renderTargetParams.driverMemBlock = -1; renderTargetParams.driverMemBlock = -1;
// create the render target // create the render target
err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt); err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt);
texture->gxm_rendertarget = tgt; texture->gxm_rendertarget = tgt;
if (err < 0) { if (err < 0) {
free_gxm_texture(texture); free_gxm_texture(texture);
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err); SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err);
return NULL; return NULL;
}
} }
} }

2
src/sensor/vita/SDL_vitasensor.c
View File

@ -137,10 +137,10 @@ SDL_VITA_SensorOpen(SDL_Sensor *sensor, int device_index)
static void static void
SDL_VITA_SensorUpdate(SDL_Sensor *sensor) SDL_VITA_SensorUpdate(SDL_Sensor *sensor)
{ {
int err = SCE_OK;
SceMotionSensorState motionState[SCE_MOTION_MAX_NUM_STATES]; SceMotionSensorState motionState[SCE_MOTION_MAX_NUM_STATES];
SDL_memset(motionState, 0, sizeof(motionState)); SDL_memset(motionState, 0, sizeof(motionState));
int err = SCE_OK;
err = sceMotionGetSensorState(motionState, SCE_MOTION_MAX_NUM_STATES); err = sceMotionGetSensorState(motionState, SCE_MOTION_MAX_NUM_STATES);
if (err != SCE_OK) if (err != SCE_OK)
{ {

10
src/timer/vita/SDL_systimer.c
View File

@ -20,7 +20,7 @@
*/ */
#include "../../SDL_internal.h" #include "../../SDL_internal.h"
#ifdef SDL_TIMERS_VITA #ifdef SDL_TIMER_VITA
#include "SDL_thread.h" #include "SDL_thread.h"
#include "SDL_timer.h" #include "SDL_timer.h"
@ -53,13 +53,13 @@ SDL_TicksQuit(void)
Uint32 SDL_GetTicks(void) Uint32 SDL_GetTicks(void)
{ {
uint64_t now;
Uint32 ticks;
if (!ticks_started) { if (!ticks_started) {
SDL_TicksInit(); SDL_TicksInit();
} }
uint64_t now;
Uint32 ticks;
now = sceKernelGetProcessTimeWide(); now = sceKernelGetProcessTimeWide();
ticks = (now - start)/1000; ticks = (now - start)/1000;
return (ticks); return (ticks);
@ -85,7 +85,7 @@ void SDL_Delay(Uint32 ms)
sceKernelDelayThreadCB(ms * 1000); sceKernelDelayThreadCB(ms * 1000);
} }
#endif /* SDL_TIMERS_VITA */ #endif /* SDL_TIMER_VITA */
/* vim: ts=4 sw=4 /* vim: ts=4 sw=4
*/ */

9
src/video/vita/SDL_vitagl.c
View File

@ -81,6 +81,11 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window)
EGLint num_configs; EGLint num_configs;
int i; int i;
const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLCHK(display = eglGetDisplay(0)); EGLCHK(display = eglGetDisplay(0));
EGLCHK(eglInitialize(display, NULL, NULL)); EGLCHK(eglInitialize(display, NULL, NULL));
@ -122,10 +127,6 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window)
return 0; return 0;
} }
const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLCHK(surface = eglCreateWindowSurface(display, config, VITA_WINDOW_960X544, NULL)); EGLCHK(surface = eglCreateWindowSurface(display, config, VITA_WINDOW_960X544, NULL));

116
src/video/vita/SDL_vitakeyboard.c
View File

@ -105,70 +105,72 @@ VITA_PollKeyboard(void)
} }
} }
Uint8 changed_modifiers = k_reports[numReports - 1].modifiers[0] ^ prev_modifiers; {
Uint8 changed_modifiers = k_reports[numReports - 1].modifiers[0] ^ prev_modifiers;
if (changed_modifiers & 0x01) { if (changed_modifiers & 0x01) {
if (prev_modifiers & 0x01) { if (prev_modifiers & 0x01) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LCTRL); SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LCTRL);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LCTRL);
}
} }
if (changed_modifiers & 0x02) {
if (prev_modifiers & 0x02) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT);
}
else { else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LCTRL); SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT);
}
} }
if (changed_modifiers & 0x04) {
if (prev_modifiers & 0x04) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LALT);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LALT);
}
}
if (changed_modifiers & 0x08) {
if (prev_modifiers & 0x08) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LGUI);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LGUI);
}
}
if (changed_modifiers & 0x10) {
if (prev_modifiers & 0x10) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RCTRL);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RCTRL);
}
} }
if (changed_modifiers & 0x02) { if (changed_modifiers & 0x20) {
if (prev_modifiers & 0x02) { if (prev_modifiers & 0x20) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT); SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RSHIFT);
}
} }
else { if (changed_modifiers & 0x40) {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT); if (prev_modifiers & 0x40) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RALT);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RALT);
}
} }
} if (changed_modifiers & 0x80) {
if (changed_modifiers & 0x04) { if (prev_modifiers & 0x80) {
if (prev_modifiers & 0x04) { SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RGUI);
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LALT); }
} else {
else { SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI);
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LALT); }
}
}
if (changed_modifiers & 0x08) {
if (prev_modifiers & 0x08) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LGUI);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LGUI);
}
}
if (changed_modifiers & 0x10) {
if (prev_modifiers & 0x10) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RCTRL);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RCTRL);
}
}
if (changed_modifiers & 0x20) {
if (prev_modifiers & 0x20) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RSHIFT);
}
}
if (changed_modifiers & 0x40) {
if (prev_modifiers & 0x40) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RALT);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RALT);
}
}
if (changed_modifiers & 0x80) {
if (prev_modifiers & 0x80) {
SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RGUI);
}
else {
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI);
} }
} }

10
src/video/vita/SDL_vitatouch.c
View File

@ -77,13 +77,13 @@ VITA_QuitTouch(void){
void void
VITA_PollTouch(void) VITA_PollTouch(void)
{ {
SDL_FingerID finger_id = 0;
int port;
// We skip polling touch if no window is created // We skip polling touch if no window is created
if (Vita_Window == NULL) if (Vita_Window == NULL)
return; return;
SDL_FingerID finger_id = 0;
int port;
memcpy(touch_old, touch, sizeof(touch_old)); memcpy(touch_old, touch, sizeof(touch_old));
for(port = 0; port < SCE_TOUCH_PORT_MAX_NUM; port++) { for(port = 0; port < SCE_TOUCH_PORT_MAX_NUM; port++) {
@ -97,8 +97,8 @@ VITA_PollTouch(void)
// for the back panel, the active touch area is used as reference // for the back panel, the active touch area is used as reference
float x = 0; float x = 0;
float y = 0; float y = 0;
VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port);
float force = (touch[port].report[i].force - force_info[port].min) / force_info[port].range; float force = (touch[port].report[i].force - force_info[port].min) / force_info[port].range;
VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port);
finger_id = (SDL_FingerID) touch[port].report[i].id; finger_id = (SDL_FingerID) touch[port].report[i].id;
// Send an initial touch // Send an initial touch
@ -134,8 +134,8 @@ VITA_PollTouch(void)
if (finger_up == 1) { if (finger_up == 1) {
float x = 0; float x = 0;
float y = 0; float y = 0;
VITA_ConvertTouchXYToSDLXY(&x, &y, touch_old[port].report[i].x, touch_old[port].report[i].y, port);
float force = (touch_old[port].report[i].force - force_info[port].min) / force_info[port].range; float force = (touch_old[port].report[i].force - force_info[port].min) / force_info[port].range;
VITA_ConvertTouchXYToSDLXY(&x, &y, touch_old[port].report[i].x, touch_old[port].report[i].y, port);
finger_id = (SDL_FingerID) touch_old[port].report[i].id; finger_id = (SDL_FingerID) touch_old[port].report[i].id;
// Finger released from screen // Finger released from screen
SDL_SendTouch((SDL_TouchID)port, SDL_SendTouch((SDL_TouchID)port,

6
src/video/vita/SDL_vitavideo.c
View File

@ -327,6 +327,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window)
wchar_t *title = L""; wchar_t *title = L"";
wchar_t *text = L""; wchar_t *text = L"";
SceInt32 res;
SceImeDialogParam param; SceImeDialogParam param;
sceImeDialogParamInit(&param); sceImeDialogParamInit(&param);
@ -342,7 +343,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window)
param.initialText = text; param.initialText = text;
param.inputTextBuffer = videodata->ime_buffer; param.inputTextBuffer = videodata->ime_buffer;
SceInt32 res = sceImeDialogInit(&param); res = sceImeDialogInit(&param);
if (res < 0) { if (res < 0) {
SDL_SetError("Failed to init IME dialog"); SDL_SetError("Failed to init IME dialog");
return; return;
@ -413,14 +414,15 @@ void VITA_PumpEvents(_THIS)
// update IME status. Terminate, if finished // update IME status. Terminate, if finished
SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus(); SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus();
if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) { if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) {
uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
SceImeDialogResult result; SceImeDialogResult result;
SDL_memset(&result, 0, sizeof(SceImeDialogResult)); SDL_memset(&result, 0, sizeof(SceImeDialogResult));
sceImeDialogGetResult(&result); sceImeDialogGetResult(&result);
// Convert UTF16 to UTF8 // Convert UTF16 to UTF8
uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH];
utf16_to_utf8(videodata->ime_buffer, utf8_buffer); utf16_to_utf8(videodata->ime_buffer, utf8_buffer);
// send sdl event // send sdl event
SDL_SendKeyboardText((const char*)utf8_buffer); SDL_SendKeyboardText((const char*)utf8_buffer);