From 7d89f09f74e257d161acf710254f8ee194fd7c66 Mon Sep 17 00:00:00 2001 From: Ivan Epifanov Date: Fri, 18 Dec 2020 14:28:09 +0300 Subject: [PATCH] ISO C90 fixes --- src/audio/vita/SDL_vitaaudio.c | 4 +- src/file/SDL_rwops.c | 28 +- src/joystick/vita/SDL_sysjoystick.c | 42 +- src/render/vitagxm/SDL_render_vita_gxm.c | 100 ++-- .../vitagxm/SDL_render_vita_gxm_tools.c | 471 +++++++++--------- src/sensor/vita/SDL_vitasensor.c | 2 +- src/timer/vita/SDL_systimer.c | 10 +- src/video/vita/SDL_vitagl.c | 9 +- src/video/vita/SDL_vitakeyboard.c | 116 ++--- src/video/vita/SDL_vitatouch.c | 10 +- src/video/vita/SDL_vitavideo.c | 6 +- 11 files changed, 422 insertions(+), 376 deletions(-) diff --git a/src/audio/vita/SDL_vitaaudio.c b/src/audio/vita/SDL_vitaaudio.c index 24aa0f5be..810b5f415 100644 --- a/src/audio/vita/SDL_vitaaudio.c +++ b/src/audio/vita/SDL_vitaaudio.c @@ -87,8 +87,8 @@ VITAAUD_OpenDevice(_THIS, void *handle, const char *devname, int iscapture) } 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); if (this->hidden->channel < 0) { diff --git a/src/file/SDL_rwops.c b/src/file/SDL_rwops.c index 2d5bcc992..d2a7831d2 100644 --- a/src/file/SDL_rwops.c +++ b/src/file/SDL_rwops.c @@ -590,20 +590,22 @@ SDL_RWFromFile(const char *file, const char *mode) rwops->close = windows_file_close; rwops->type = SDL_RWOPS_WINFILE; #elif defined(__VITA__) - /* Try to open the file on the filesystem first */ - FILE *fp = fopen(file, mode); - if (fp) { - return SDL_RWFromFP(fp, 1); - } else { - /* Try opening it from app0:/ container if it's a relative path */ - char path[4096]; - SDL_snprintf(path, 4096, "app0:/%s", file); - fp = fopen(path, mode); - if (fp) { - return SDL_RWFromFP(fp, 1); - } + { + /* Try to open the file on the filesystem first */ + FILE *fp = fopen(file, mode); + if (fp) { + return SDL_RWFromFP(fp, 1); + } else { + /* Try opening it from app0:/ container if it's a relative path */ + char path[4096]; + SDL_snprintf(path, 4096, "app0:/%s", file); + fp = fopen(path, mode); + 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 { #ifdef __APPLE__ diff --git a/src/joystick/vita/SDL_sysjoystick.c b/src/joystick/vita/SDL_sysjoystick.c index 2ce10907b..ccd217b4f 100644 --- a/src/joystick/vita/SDL_sysjoystick.c +++ b/src/joystick/vita/SDL_sysjoystick.c @@ -67,10 +67,10 @@ static point c = { 128, 32767 }; static point d = { 128, 32767 }; /* 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->y = a->y + (b->y - a->y)*t; + dest->x = first->x + (second->x - first->x) * t; + dest->y = first->y + (second->y - first->y) * t; } /* 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 i; + SceCtrlPortInfo myPortInfo; /* Setup input */ sceCtrlSetSamplingMode(SCE_CTRL_MODE_ANALOG_WIDE); @@ -106,27 +107,26 @@ int VITA_JoystickInit(void) 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 - // 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; - SDL_numjoysticks = 1; + // How many additional paired controllers are there? + sceCtrlGetControllerPortInfo(&myPortInfo); - //How many additional paired controllers are there? - sceCtrlGetControllerPortInfo(&myPortInfo); - //On Vita TV, port 0 and 1 are the same controller - //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) - { - SDL_numjoysticks++; - } - } - return SDL_numjoysticks; + // On Vita TV, port 0 and 1 are the same controller + // 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) + { + SDL_numjoysticks++; + } + } + return SDL_numjoysticks; } int VITA_JoystickGetCount() diff --git a/src/render/vitagxm/SDL_render_vita_gxm.c b/src/render/vitagxm/SDL_render_vita_gxm.c index 4ffe51d36..d3c2f9dac 100644 --- a/src/render/vitagxm/SDL_render_vita_gxm.c +++ b/src/render/vitagxm/SDL_render_vita_gxm.c @@ -470,12 +470,14 @@ VITA_GXM_QueueDrawLines(SDL_Renderer * renderer, SDL_RenderCommand *cmd, const S static int 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; 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, 4 * count * sizeof(color_vertex), // 4 vertices * count sizeof(color_vertex)); @@ -532,12 +534,13 @@ static int VITA_GXM_QueueCopy(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Texture * texture, 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; cmd->data.draw.count = 1; - texture_vertex *vertices = (texture_vertex *)pool_memalign( + vertices = (texture_vertex *)pool_memalign( data, 4 * sizeof(texture_vertex), // 4 vertices 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.texture = texture; - const float u0 = (float)srcrect->x / (float)texture->w; - const float v0 = (float)srcrect->y / (float)texture->h; - const float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; - const float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; + u0 = (float)srcrect->x / (float)texture->w; + v0 = (float)srcrect->y / (float)texture->h; + u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; + v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; vertices[0].x = dstrect->x; 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 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; + 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; - texture_vertex *vertices = (texture_vertex *)pool_memalign( + vertices = (texture_vertex *)pool_memalign( data, 4 * sizeof(texture_vertex), // 4 vertices 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.texture = texture; - float u0 = (float)srcrect->x / (float)texture->w; - float v0 = (float)srcrect->y / (float)texture->h; - float u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; - float v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; + u0 = (float)srcrect->x / (float)texture->w; + v0 = (float)srcrect->y / (float)texture->h; + u1 = (float)(srcrect->x + srcrect->w) / (float)texture->w; + v1 = (float)(srcrect->y + srcrect->h) / (float)texture->h; if (flip & SDL_FLIP_VERTICAL) { Swap(&v0, &v1); @@ -607,20 +622,13 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur 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); - const float cw = c * width; - const float sw = s * width; - const float ch = c * height; - const float sh = s * height; + cw = c * width; + sw = s * width; + ch = c * height; + sh = s * height; vertices[0].x = x - cw + sh; vertices[0].y = y - sw - ch; @@ -654,9 +662,11 @@ VITA_GXM_QueueCopyEx(SDL_Renderer * renderer, SDL_RenderCommand *cmd, SDL_Textur static int 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; - float clear_color[4]; clear_color[0] = (cmd->data.color.r)/255.0f; clear_color[1] = (cmd->data.color.g)/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); // set the clear color - void *color_buffer; sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &color_buffer); 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; SDL_bool matrix_updated = SDL_FALSE; SDL_bool program_updated = SDL_FALSE; + Uint32 texture_color; Uint8 r, g, b, a; 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; } - 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 (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); } else if (data->drawstate.fragment_program == data->textureTintFragmentProgram) { void *vertex_wvp_buffer; + void *texture_tint_color_buffer; + float *tint_color; sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertex_wvp_buffer); sceGxmSetUniformDataF(vertex_wvp_buffer, data->textureWvpParam, 0, 16, data->ortho_matrix); - void *texture_tint_color_buffer; sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer); - float *tint_color = pool_memalign( + tint_color = pool_memalign( data, 4 * sizeof(float), // RGBA sizeof(float) @@ -837,9 +848,10 @@ SetDrawState(VITA_GXM_RenderData *data, const SDL_RenderCommand *cmd, SDL_bool s } else { if (data->drawstate.fragment_program == data->textureTintFragmentProgram && data->drawstate.texture_color != texture_color) { void *texture_tint_color_buffer; + float *tint_color; sceGxmReserveFragmentDefaultUniformBuffer(data->gxm_context, &texture_tint_color_buffer); - float *tint_color = pool_memalign( + tint_color = pool_memalign( data, 4 * sizeof(float), // RGBA sizeof(float) @@ -879,8 +891,8 @@ SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd) static int 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; + StartDrawing(renderer); data->drawstate.target = renderer->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) { SceDisplayFrameBuf pParam; + int i, j; + Uint32 *out32; + Uint32 *in32; + pParam.size = sizeof(SceDisplayFrameBuf); sceDisplayGetFrameBuf(&pParam, SCE_DISPLAY_SETBUF_NEXTFRAME); - int i, j; - Uint32 *out32 = (Uint32 *)data; - Uint32 *in32 = (Uint32 *)pParam.base; + out32 = (Uint32 *)data; + in32 = (Uint32 *)pParam.base; in32 += (x + y * pParam.pitch); @@ -986,11 +1001,6 @@ static int VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, 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; size_t buflen; void *temp_pixels; @@ -999,6 +1009,12 @@ VITA_GXM_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect, int w, h, length, rows; 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); buflen = rect->h * temp_pitch; if (buflen == 0) { @@ -1047,14 +1063,10 @@ static void VITA_GXM_RenderPresent(SDL_Renderer *renderer) { VITA_GXM_RenderData *data = (VITA_GXM_RenderData *) renderer->driverdata; - -// sceGxmFinish(data->gxm_context); + SceCommonDialogUpdateParam updateParam; data->displayData.address = data->displayBufferData[data->backBufferIndex]; - - SceCommonDialogUpdateParam updateParam; - SDL_memset(&updateParam, 0, sizeof(updateParam)); updateParam.renderTarget.colorFormat = VITA_GXM_COLOR_FORMAT; diff --git a/src/render/vitagxm/SDL_render_vita_gxm_tools.c b/src/render/vitagxm/SDL_render_vita_gxm_tools.c index 12065cedf..411c70ca4 100644 --- a/src/render/vitagxm/SDL_render_vita_gxm_tools.c +++ b/src/render/vitagxm/SDL_render_vita_gxm_tools.c @@ -71,8 +71,8 @@ init_orthographic_matrix(float *m, float left, float right, float bottom, float static void * patcher_host_alloc(void *user_data, unsigned int size) { - (void)user_data; void *mem = SDL_malloc(size); + (void)user_data; return mem; } @@ -222,6 +222,7 @@ make_fragment_programs(VITA_GXM_RenderData *data, fragment_programs *out, static void set_stencil_mask(VITA_GXM_RenderData *data, float x, float y, float w, float h) { + void *vertexDefaultBuffer; color_vertex *vertices = (color_vertex *)pool_memalign( data, 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); sceGxmSetFragmentProgram(data->gxm_context, data->colorFragmentProgram); - void *vertexDefaultBuffer; sceGxmReserveVertexDefaultUniformBuffer(data->gxm_context, &vertexDefaultBuffer); sceGxmSetUniformDataF(vertexDefaultBuffer, data->colorWvpParam, 0, 16, data->ortho_matrix); @@ -324,6 +324,84 @@ gxm_init(SDL_Renderer *renderer) { unsigned int i, x, y; 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; @@ -343,29 +421,28 @@ gxm_init(SDL_Renderer *renderer) } // allocate ring buffer memory using default sizes - void *vdmRingBuffer = mem_gpu_alloc( + vdmRingBuffer = mem_gpu_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_GXM_DEFAULT_VDM_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, &data->vdmRingBufferUid); - void *vertexRingBuffer = mem_gpu_alloc( + vertexRingBuffer = mem_gpu_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_GXM_DEFAULT_VERTEX_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, &data->vertexRingBufferUid); - void *fragmentRingBuffer = mem_gpu_alloc( + fragmentRingBuffer = mem_gpu_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, SCE_GXM_DEFAULT_FRAGMENT_RING_BUFFER_SIZE, 4, SCE_GXM_MEMORY_ATTRIB_READ, &data->fragmentRingBufferUid); - unsigned int fragmentUsseRingBufferOffset; - void *fragmentUsseRingBuffer = mem_fragment_usse_alloc( + fragmentUsseRingBuffer = mem_fragment_usse_alloc( SCE_GXM_DEFAULT_FRAGMENT_USSE_RING_BUFFER_SIZE, &data->fragmentUsseRingBufferUid, &fragmentUsseRingBufferOffset); @@ -390,7 +467,6 @@ gxm_init(SDL_Renderer *renderer) } // set up parameters - SceGxmRenderTargetParams renderTargetParams; SDL_memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); renderTargetParams.flags = 0; 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 data->depthBufferData = mem_gpu_alloc( @@ -500,33 +570,26 @@ gxm_init(SDL_Renderer *renderer) 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 - void *patcherBuffer = mem_gpu_alloc( + patcherBuffer = mem_gpu_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, patcherBufferSize, 4, SCE_GXM_MEMORY_ATTRIB_READ | SCE_GXM_MEMORY_ATTRIB_WRITE, &data->patcherBufferUid); - unsigned int patcherVertexUsseOffset; - void *patcherVertexUsse = mem_vertex_usse_alloc( + patcherVertexUsse = mem_vertex_usse_alloc( patcherVertexUsseSize, &data->patcherVertexUsseUid, &patcherVertexUsseOffset); - unsigned int patcherFragmentUsseOffset; - void *patcherFragmentUsse = mem_fragment_usse_alloc( + patcherFragmentUsse = mem_fragment_usse_alloc( patcherFragmentUsseSize, &data->patcherFragmentUsseUid, &patcherFragmentUsseOffset); // create a shader patcher - SceGxmShaderPatcherParams patcherParams; SDL_memset(&patcherParams, 0, sizeof(SceGxmShaderPatcherParams)); patcherParams.userData = NULL; patcherParams.hostAllocCallback = &patcher_host_alloc; @@ -639,111 +702,61 @@ gxm_init(SDL_Renderer *renderer) 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 - }; + { + // get attributes by name to create vertex format bindings + const SceGxmProgramParameter *paramClearPositionAttribute = sceGxmProgramFindParameterByName(clearVertexProgramGxp, "aPosition"); - 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 - }; + // 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; - static const SceGxmBlendInfo blend_info_mod = { - .colorFunc = SCE_GXM_BLEND_FUNC_ADD, - .alphaFunc = SCE_GXM_BLEND_FUNC_ADD, + // 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; + } - .colorSrc = SCE_GXM_BLEND_FACTOR_ZERO, - .colorDst = SCE_GXM_BLEND_FACTOR_SRC_COLOR, + 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; + } - .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 - 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; + // 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 + ); } - 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 // 16-bit indices in linear ascending order, so we can use this for // all drawing operations where we don't want to use indexing. @@ -755,7 +768,7 @@ gxm_init(SDL_Renderer *renderer) &data->linearIndicesUid ); - for (uint32_t i=0; i<=UINT16_MAX; ++i) + for (i = 0; i <= UINT16_MAX; ++i) { data->linearIndices[i] = i; } @@ -767,79 +780,86 @@ gxm_init(SDL_Renderer *renderer) data->clearVertices[2].x = -1.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 - SceGxmVertexAttribute colorVertexAttributes[2]; - SceGxmVertexStream colorVertexStreams[1]; - /* x,y,z: 3 float 32 bits */ - colorVertexAttributes[0].streamIndex = 0; - colorVertexAttributes[0].offset = 0; - colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - colorVertexAttributes[0].componentCount = 3; // (x, y, z) - colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute); - /* color: 4 unsigned char = 32 bits */ - colorVertexAttributes[1].streamIndex = 0; - colorVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes - colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N; - colorVertexAttributes[1].componentCount = 4; // (color) - colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute); - // 16 bit (short) indices - colorVertexStreams[0].stride = sizeof(color_vertex); - colorVertexStreams[0].indexSource = SCE_GXM_INDEX_SOURCE_INDEX_16BIT; + // create color vertex format + SceGxmVertexAttribute colorVertexAttributes[2]; + SceGxmVertexStream colorVertexStreams[1]; + /* x,y,z: 3 float 32 bits */ + colorVertexAttributes[0].streamIndex = 0; + colorVertexAttributes[0].offset = 0; + colorVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + colorVertexAttributes[0].componentCount = 3; // (x, y, z) + colorVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorPositionAttribute); + /* color: 4 unsigned char = 32 bits */ + colorVertexAttributes[1].streamIndex = 0; + colorVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes + colorVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_U8N; + colorVertexAttributes[1].componentCount = 4; // (color) + colorVertexAttributes[1].regIndex = sceGxmProgramParameterGetResourceIndex(paramColorColorAttribute); + // 16 bit (short) indices + colorVertexStreams[0].stride = sizeof(color_vertex); + 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]; - SceGxmVertexStream textureVertexStreams[1]; - /* x,y,z: 3 float 32 bits */ - textureVertexAttributes[0].streamIndex = 0; - textureVertexAttributes[0].offset = 0; - textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - textureVertexAttributes[0].componentCount = 3; // (x, y, z) - textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute); - /* u,v: 2 floats 32 bits */ - textureVertexAttributes[1].streamIndex = 0; - textureVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes - textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; - 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; + { + const SceGxmProgramParameter *paramTexturePositionAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aPosition"); + const SceGxmProgramParameter *paramTextureTexcoordAttribute = sceGxmProgramFindParameterByName(textureVertexProgramGxp, "aTexcoord"); + + // create texture vertex format + SceGxmVertexAttribute textureVertexAttributes[2]; + SceGxmVertexStream textureVertexStreams[1]; + /* x,y,z: 3 float 32 bits */ + textureVertexAttributes[0].streamIndex = 0; + textureVertexAttributes[0].offset = 0; + textureVertexAttributes[0].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + textureVertexAttributes[0].componentCount = 3; // (x, y, z) + textureVertexAttributes[0].regIndex = sceGxmProgramParameterGetResourceIndex(paramTexturePositionAttribute); + /* u,v: 2 floats 32 bits */ + textureVertexAttributes[1].streamIndex = 0; + textureVertexAttributes[1].offset = 12; // (x, y, z) * 4 = 12 bytes + textureVertexAttributes[1].format = SCE_GXM_ATTRIBUTE_FORMAT_F32; + 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 @@ -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_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->textureFragmentProgram = in->texture; - data->textureTintFragmentProgram = in->textureTint; + data->colorFragmentProgram = in->color; + data->textureFragmentProgram = in->texture; + data->textureTintFragmentProgram = in->textureTint; + + } // find vertex uniforms by name and cache parameter information data->clearClearColorParam = (SceGxmProgramParameter *)sceGxmProgramFindParameterByName(clearFragmentProgramGxp, "uClearColor"); @@ -1019,15 +1042,18 @@ gxm_texture_get_datap(const gxm_texture *texture) gxm_texture * 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)); + const int tex_size = ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format); + void *texture_data; + + format = SCE_GXM_TEXTURE_FORMAT_A8B8G8R8; + if (!texture) return NULL; - const int tex_size = ((w + 7) & ~ 7) * h * tex_format_to_bytespp(format); /* 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, tex_size, SCE_GXM_TEXTURE_ALIGNMENT, @@ -1070,6 +1096,11 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc } 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( &texture->gxm_colorsurface, @@ -1089,14 +1120,8 @@ create_gxm_texture(VITA_GXM_RenderData *data, unsigned int w, unsigned int h, Sc 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 - void *depthBufferData = mem_gpu_alloc( + depthBufferData = mem_gpu_alloc( SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE, 4*sampleCount, 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; } - SceGxmRenderTarget *tgt = NULL; + { + SceGxmRenderTarget *tgt = NULL; - // set up parameters - SceGxmRenderTargetParams renderTargetParams; - memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); - renderTargetParams.flags = 0; - renderTargetParams.width = w; - renderTargetParams.height = h; - renderTargetParams.scenesPerFrame = 1; - renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE; - renderTargetParams.multisampleLocations = 0; - renderTargetParams.driverMemBlock = -1; + // set up parameters + SceGxmRenderTargetParams renderTargetParams; + memset(&renderTargetParams, 0, sizeof(SceGxmRenderTargetParams)); + renderTargetParams.flags = 0; + renderTargetParams.width = w; + renderTargetParams.height = h; + renderTargetParams.scenesPerFrame = 1; + renderTargetParams.multisampleMode = SCE_GXM_MULTISAMPLE_NONE; + renderTargetParams.multisampleLocations = 0; + renderTargetParams.driverMemBlock = -1; - // create the render target - err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt); + // create the render target + err = sceGxmCreateRenderTarget(&renderTargetParams, &tgt); - texture->gxm_rendertarget = tgt; + texture->gxm_rendertarget = tgt; - if (err < 0) { - free_gxm_texture(texture); - SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err); - return NULL; + if (err < 0) { + free_gxm_texture(texture); + SDL_LogError(SDL_LOG_CATEGORY_RENDER, "create render target failed: %d\n", err); + return NULL; + } } } diff --git a/src/sensor/vita/SDL_vitasensor.c b/src/sensor/vita/SDL_vitasensor.c index e54d279aa..85f941d60 100644 --- a/src/sensor/vita/SDL_vitasensor.c +++ b/src/sensor/vita/SDL_vitasensor.c @@ -137,10 +137,10 @@ SDL_VITA_SensorOpen(SDL_Sensor *sensor, int device_index) static void SDL_VITA_SensorUpdate(SDL_Sensor *sensor) { + int err = SCE_OK; SceMotionSensorState motionState[SCE_MOTION_MAX_NUM_STATES]; SDL_memset(motionState, 0, sizeof(motionState)); - int err = SCE_OK; err = sceMotionGetSensorState(motionState, SCE_MOTION_MAX_NUM_STATES); if (err != SCE_OK) { diff --git a/src/timer/vita/SDL_systimer.c b/src/timer/vita/SDL_systimer.c index 91902d9fc..a9009f744 100644 --- a/src/timer/vita/SDL_systimer.c +++ b/src/timer/vita/SDL_systimer.c @@ -20,7 +20,7 @@ */ #include "../../SDL_internal.h" -#ifdef SDL_TIMERS_VITA +#ifdef SDL_TIMER_VITA #include "SDL_thread.h" #include "SDL_timer.h" @@ -53,13 +53,13 @@ SDL_TicksQuit(void) Uint32 SDL_GetTicks(void) { + uint64_t now; + Uint32 ticks; + if (!ticks_started) { SDL_TicksInit(); } - uint64_t now; - Uint32 ticks; - now = sceKernelGetProcessTimeWide(); ticks = (now - start)/1000; return (ticks); @@ -85,7 +85,7 @@ void SDL_Delay(Uint32 ms) sceKernelDelayThreadCB(ms * 1000); } -#endif /* SDL_TIMERS_VITA */ +#endif /* SDL_TIMER_VITA */ /* vim: ts=4 sw=4 */ diff --git a/src/video/vita/SDL_vitagl.c b/src/video/vita/SDL_vitagl.c index c457e0f22..d8ee86f49 100644 --- a/src/video/vita/SDL_vitagl.c +++ b/src/video/vita/SDL_vitagl.c @@ -81,6 +81,11 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window) EGLint num_configs; int i; + const EGLint contextAttribs[] = { + EGL_CONTEXT_CLIENT_VERSION, 2, + EGL_NONE + }; + EGLCHK(display = eglGetDisplay(0)); EGLCHK(eglInitialize(display, NULL, NULL)); @@ -122,10 +127,6 @@ VITA_GL_CreateContext(_THIS, SDL_Window * window) return 0; } - const EGLint contextAttribs[] = { - EGL_CONTEXT_CLIENT_VERSION, 2, - EGL_NONE - }; EGLCHK(surface = eglCreateWindowSurface(display, config, VITA_WINDOW_960X544, NULL)); diff --git a/src/video/vita/SDL_vitakeyboard.c b/src/video/vita/SDL_vitakeyboard.c index efa407f03..f196e3340 100644 --- a/src/video/vita/SDL_vitakeyboard.c +++ b/src/video/vita/SDL_vitakeyboard.c @@ -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 (prev_modifiers & 0x01) { - SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LCTRL); + if (changed_modifiers & 0x01) { + if (prev_modifiers & 0x01) { + 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 { - 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 (prev_modifiers & 0x02) { - SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT); + if (changed_modifiers & 0x20) { + if (prev_modifiers & 0x20) { + SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RSHIFT); + } + else { + SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RSHIFT); + } } - else { - SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT); + 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 & 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 & 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); + if (changed_modifiers & 0x80) { + if (prev_modifiers & 0x80) { + SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_RGUI); + } + else { + SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_RGUI); + } } } diff --git a/src/video/vita/SDL_vitatouch.c b/src/video/vita/SDL_vitatouch.c index 5913db5b0..7399618ce 100644 --- a/src/video/vita/SDL_vitatouch.c +++ b/src/video/vita/SDL_vitatouch.c @@ -77,13 +77,13 @@ VITA_QuitTouch(void){ void VITA_PollTouch(void) { + SDL_FingerID finger_id = 0; + int port; + // We skip polling touch if no window is created if (Vita_Window == NULL) return; - SDL_FingerID finger_id = 0; - int port; - memcpy(touch_old, touch, sizeof(touch_old)); 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 float x = 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; + VITA_ConvertTouchXYToSDLXY(&x, &y, touch[port].report[i].x, touch[port].report[i].y, port); finger_id = (SDL_FingerID) touch[port].report[i].id; // Send an initial touch @@ -134,8 +134,8 @@ VITA_PollTouch(void) if (finger_up == 1) { float x = 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; + 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 released from screen SDL_SendTouch((SDL_TouchID)port, diff --git a/src/video/vita/SDL_vitavideo.c b/src/video/vita/SDL_vitavideo.c index e639305fc..8bc1ee752 100644 --- a/src/video/vita/SDL_vitavideo.c +++ b/src/video/vita/SDL_vitavideo.c @@ -327,6 +327,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window) wchar_t *title = L""; wchar_t *text = L""; + SceInt32 res; SceImeDialogParam param; sceImeDialogParamInit(¶m); @@ -342,7 +343,7 @@ void VITA_ShowScreenKeyboard(_THIS, SDL_Window *window) param.initialText = text; param.inputTextBuffer = videodata->ime_buffer; - SceInt32 res = sceImeDialogInit(¶m); + res = sceImeDialogInit(¶m); if (res < 0) { SDL_SetError("Failed to init IME dialog"); return; @@ -413,14 +414,15 @@ void VITA_PumpEvents(_THIS) // update IME status. Terminate, if finished SceCommonDialogStatus dialogStatus = sceImeDialogGetStatus(); if (dialogStatus == SCE_COMMON_DIALOG_STATUS_FINISHED) { + uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH]; SceImeDialogResult result; SDL_memset(&result, 0, sizeof(SceImeDialogResult)); sceImeDialogGetResult(&result); // Convert UTF16 to UTF8 - uint8_t utf8_buffer[SCE_IME_DIALOG_MAX_TEXT_LENGTH]; utf16_to_utf8(videodata->ime_buffer, utf8_buffer); + // send sdl event SDL_SendKeyboardText((const char*)utf8_buffer);