From 7d89f09f74e257d161acf710254f8ee194fd7c66 Mon Sep 17 00:00:00 2001
From: Ivan Epifanov <[EMAIL REDACTED]>
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 | 48 +-
src/render/vitagxm/SDL_render_vita_gxm.c | 100 ++--
.../vitagxm/SDL_render_vita_gxm_tools.c | 493 +++++++++---------
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 | 112 ++--
src/video/vita/SDL_vitatouch.c | 10 +-
src/video/vita/SDL_vitavideo.c | 6 +-
11 files changed, 434 insertions(+), 388 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.
-
- SDL_numjoysticks = 1;
-
- //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;
+ // 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;
+
+ // 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;
}
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
- };
-
- 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
+ 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;
+ }
- // 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;
+ }
- 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
+ );
}
- // 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 *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
- color
(Patch may be truncated, please check the link at the top of this post.)