mirrors/SDL
1
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-10-03 00:18:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

ISO C90 fixes

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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

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

@@ -71,8 +71,8 @@ init_orthographic_matrix(float *m, float left, float right, float bottom, float
static void *
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;
}
}
}