encounter
/
SDL
mirror of https://github.com/encounter/SDL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ISO C90 fixes

This commit is contained in:
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

2
src/file/SDL_rwops.c
View File

@ -590,6 +590,7 @@ 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 */ /* Try to open the file on the filesystem first */
FILE *fp = fopen(file, mode); FILE *fp = fopen(file, mode);
if (fp) { if (fp) {
@ -604,6 +605,7 @@ SDL_RWFromFile(const char *file, const char *mode)
} }
} }
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__

10
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,8 +107,6 @@ 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 // Assume we have at least one controller, even when nothing is paired
// This way the user can jump in, pair a controller // This way the user can jump in, pair a controller
// and control things immediately even if it is paired // and control things immediately even if it is paired
@ -117,6 +116,7 @@ int VITA_JoystickInit(void)
// How many additional paired controllers are there? // How many additional paired controllers are there?
sceCtrlGetControllerPortInfo(&myPortInfo); sceCtrlGetControllerPortInfo(&myPortInfo);
// On Vita TV, port 0 and 1 are the same controller // On Vita TV, port 0 and 1 are the same controller
// and that is the first one, so start at port 2 // and that is the first one, so start at port 2
for (i=2; i<=4; i++) for (i=2; i<=4; i++)

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;

201
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,59 +702,8 @@ 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,
.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
};
{
// get attributes by name to create vertex format bindings // get attributes by name to create vertex format bindings
const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition"); const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition");
@ -743,6 +755,7 @@ gxm_init(SDL_Renderer *renderer)
SCE_GXM_MEMORY_ATTRIB_READ, SCE_GXM_MEMORY_ATTRIB_READ,
&data->clearVerticesUid &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
@ -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,6 +780,7 @@ 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");
@ -805,6 +819,10 @@ gxm_init(SDL_Renderer *renderer)
return err; return err;
} }
}
{
const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition"); const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition");
const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord"); const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord");
@ -842,6 +860,8 @@ gxm_init(SDL_Renderer *renderer)
return err; return err;
} }
}
// Create variations of the fragment program based on blending mode // Create variations of the fragment program based on blending mode
make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none, &blend_info_none); make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_none, &blend_info_none);
make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend, &blend_info_blend); make_fragment_programs(data, &data->blendFragmentPrograms.blend_mode_blend, &blend_info_blend);
@ -849,6 +869,7 @@ 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 // Default to blend blending mode
fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend; fragment_programs *in = &data->blendFragmentPrograms.blend_mode_blend;
@ -856,6 +877,8 @@ gxm_init(SDL_Renderer *renderer)
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");
data->colorWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp"); data->colorWvpParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(colorVertexProgramGxp, "wvp");
@ -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,6 +1143,7 @@ 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
@ -1141,6 +1167,7 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc
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));

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

@ -105,6 +105,7 @@ 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) {
@ -171,6 +172,7 @@ VITA_PollKeyboard(void)
SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI); SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI);
} }
} }
}
prev_modifiers = k_reports[numReports - 1].modifiers[0]; prev_modifiers = k_reports[numReports - 1].modifiers[0];

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);