From dbb730d39517881860b86ee6478627b01b35a9ed Mon Sep 17 00:00:00 2001
From: Ivan Epifanov <[EMAIL REDACTED]>
Date: Sat, 14 Nov 2020 23:37:26 +0300
Subject: [PATCH] Separate vita piglet renderer. Add proper render
initialization and window re-creation.
---
Makefile.vita.dolce | 3 +-
include/SDL_config_vita.h | 6 +-
src/render/SDL_render.c | 8 +
src/render/SDL_sysrender.h | 2 +
src/render/vitagles2/SDL_gles2funcs.h | 77 +
src/render/vitagles2/SDL_render_gles2vita.c | 2103 +++++++++++++++++
.../SDL_shaders_gles2vita.c} | 296 +--
src/render/vitagles2/SDL_shaders_gles2vita.h | 70 +
src/video/vita/SDL_vitagl.c | 115 +-
src/video/vita/SDL_vitavideo.c | 27 +-
10 files changed, 2481 insertions(+), 226 deletions(-)
create mode 100644 src/render/vitagles2/SDL_gles2funcs.h
create mode 100644 src/render/vitagles2/SDL_render_gles2vita.c
rename src/render/{vita/SDL_shaders_gles2_cg.c => vitagles2/SDL_shaders_gles2vita.c} (59%)
create mode 100644 src/render/vitagles2/SDL_shaders_gles2vita.h
diff --git a/Makefile.vita.dolce b/Makefile.vita.dolce
index 2b12b25d1..d646d43dd 100644
--- a/Makefile.vita.dolce
+++ b/Makefile.vita.dolce
@@ -21,8 +21,7 @@ SOURCES = \
src/filesystem/vita/*.c \
src/render/*.c \
src/render/software/*.c \
- src/render/opengles2/SDL_render_gles2.c \
- src/render/vita/*.c \
+ src/render/vitagles2/*.c \
src/sensor/*.c \
src/sensor/dummy/*.c \
src/stdlib/*.c \
diff --git a/include/SDL_config_vita.h b/include/SDL_config_vita.h
index 05cba8f73..88fe34476 100644
--- a/include/SDL_config_vita.h
+++ b/include/SDL_config_vita.h
@@ -139,8 +139,12 @@
#define SDL_FILESYSTEM_VITA 1
-#define SDL_VIDEO_RENDER_OGL_ES2 1
+#define SDL_VIDEO_RENDER_VITA_GLES2 1
+//#define SDL_VIDEO_RENDER_VITA_GXM 1
+
+#if defined(SDL_VIDEO_RENDER_VITA_GLES2)
#define SDL_VIDEO_OPENGL_ES2 1
+#endif
/* VITA doesn't have haptic device (src/haptic/dummy/\*.c) */
diff --git a/src/render/SDL_render.c b/src/render/SDL_render.c
index 9a6f8f2c8..2a9868ade 100644
--- a/src/render/SDL_render.c
+++ b/src/render/SDL_render.c
@@ -95,6 +95,12 @@ static const SDL_RenderDriver *render_drivers[] = {
#if SDL_VIDEO_RENDER_OGL_ES2
&GLES2_RenderDriver,
#endif
+#if SDL_VIDEO_RENDER_VITA_GLES2
+ &VITA_GLES2_RenderDriver,
+#endif
+#if SDL_VIDEO_RENDER_VITA_GXM
+ &VITA_GXM__RenderDriver,
+#endif
#if SDL_VIDEO_RENDER_OGL_ES
&GLES_RenderDriver,
#endif
@@ -274,7 +280,9 @@ SDL_AllocateRenderVertices(SDL_Renderer *renderer, const size_t numbytes, const
while (newsize < needed) {
newsize *= 2;
}
+
ptr = SDL_realloc(renderer->vertex_data, newsize);
+
if (ptr == NULL) {
SDL_OutOfMemory();
return NULL;
diff --git a/src/render/SDL_sysrender.h b/src/render/SDL_sysrender.h
index 596e0ace2..b38252d30 100644
--- a/src/render/SDL_sysrender.h
+++ b/src/render/SDL_sysrender.h
@@ -245,6 +245,8 @@ extern SDL_RenderDriver D3D_RenderDriver;
extern SDL_RenderDriver D3D11_RenderDriver;
extern SDL_RenderDriver GL_RenderDriver;
extern SDL_RenderDriver GLES2_RenderDriver;
+extern SDL_RenderDriver VITA_GLES2_RenderDriver;
+extern SDL_RenderDriver VITA_GXM_RenderDriver;
extern SDL_RenderDriver GLES_RenderDriver;
extern SDL_RenderDriver DirectFB_RenderDriver;
extern SDL_RenderDriver METAL_RenderDriver;
diff --git a/src/render/vitagles2/SDL_gles2funcs.h b/src/render/vitagles2/SDL_gles2funcs.h
new file mode 100644
index 000000000..94cfb8749
--- /dev/null
+++ b/src/render/vitagles2/SDL_gles2funcs.h
@@ -0,0 +1,77 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+*/
+
+SDL_PROC(void, glActiveTexture, (GLenum))
+SDL_PROC(void, glAttachShader, (GLuint, GLuint))
+SDL_PROC(void, glBindAttribLocation, (GLuint, GLuint, const char *))
+SDL_PROC(void, glBindTexture, (GLenum, GLuint))
+SDL_PROC(void, glBlendEquationSeparate, (GLenum, GLenum))
+SDL_PROC(void, glBlendFuncSeparate, (GLenum, GLenum, GLenum, GLenum))
+SDL_PROC(void, glClear, (GLbitfield))
+SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
+SDL_PROC(void, glCompileShader, (GLuint))
+SDL_PROC(GLuint, glCreateProgram, (void))
+SDL_PROC(GLuint, glCreateShader, (GLenum))
+SDL_PROC(void, glDeleteProgram, (GLuint))
+SDL_PROC(void, glDeleteShader, (GLuint))
+SDL_PROC(void, glDeleteTextures, (GLsizei, const GLuint *))
+SDL_PROC(void, glDisable, (GLenum))
+SDL_PROC(void, glDisableVertexAttribArray, (GLuint))
+SDL_PROC(void, glDrawArrays, (GLenum, GLint, GLsizei))
+SDL_PROC(void, glEnable, (GLenum))
+SDL_PROC(void, glEnableVertexAttribArray, (GLuint))
+SDL_PROC(void, glFinish, (void))
+SDL_PROC(void, glGenFramebuffers, (GLsizei, GLuint *))
+SDL_PROC(void, glGenTextures, (GLsizei, GLuint *))
+SDL_PROC(void, glGetBooleanv, (GLenum, GLboolean *))
+SDL_PROC(const GLubyte *, glGetString, (GLenum))
+SDL_PROC(GLenum, glGetError, (void))
+SDL_PROC(void, glGetIntegerv, (GLenum, GLint *))
+SDL_PROC(void, glGetProgramiv, (GLuint, GLenum, GLint *))
+SDL_PROC(void, glGetShaderInfoLog, (GLuint, GLsizei, GLsizei *, char *))
+SDL_PROC(void, glGetShaderiv, (GLuint, GLenum, GLint *))
+SDL_PROC(GLint, glGetUniformLocation, (GLuint, const char *))
+SDL_PROC(void, glLinkProgram, (GLuint))
+SDL_PROC(void, glPixelStorei, (GLenum, GLint))
+SDL_PROC(void, glReadPixels, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*))
+SDL_PROC(void, glScissor, (GLint, GLint, GLsizei, GLsizei))
+SDL_PROC(void, glShaderBinary, (GLsizei, const GLuint *, GLenum, const void *, GLsizei))
+SDL_PROC(void, glShaderSource, (GLuint, GLsizei, const GLchar* const*, const GLint *))
+SDL_PROC(void, glTexImage2D, (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *))
+SDL_PROC(void, glTexParameteri, (GLenum, GLenum, GLint))
+SDL_PROC(void, glTexSubImage2D, (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *))
+SDL_PROC(void, glUniform1i, (GLint, GLint))
+SDL_PROC(void, glUniform4f, (GLint, GLfloat, GLfloat, GLfloat, GLfloat))
+SDL_PROC(void, glUniformMatrix4fv, (GLint, GLsizei, GLboolean, const GLfloat *))
+SDL_PROC(void, glUseProgram, (GLuint))
+SDL_PROC(void, glVertexAttribPointer, (GLuint, GLint, GLenum, GLboolean, GLsizei, const void *))
+SDL_PROC(void, glViewport, (GLint, GLint, GLsizei, GLsizei))
+SDL_PROC(void, glBindFramebuffer, (GLenum, GLuint))
+SDL_PROC(void, glFramebufferTexture2D, (GLenum, GLenum, GLenum, GLuint, GLint))
+SDL_PROC(GLenum, glCheckFramebufferStatus, (GLenum))
+SDL_PROC(void, glDeleteFramebuffers, (GLsizei, const GLuint *))
+SDL_PROC(GLint, glGetAttribLocation, (GLuint, const GLchar *))
+SDL_PROC(void, glGetProgramInfoLog, (GLuint, GLsizei, GLsizei*, GLchar*))
+SDL_PROC(void, glGenBuffers, (GLsizei, GLuint *))
+SDL_PROC(void, glDeleteBuffers, (GLsizei, const GLuint *))
+SDL_PROC(void, glBindBuffer, (GLenum, GLuint))
+SDL_PROC(void, glBufferData, (GLenum, GLsizeiptr, const GLvoid *, GLenum))
+SDL_PROC(void, glBufferSubData, (GLenum, GLintptr, GLsizeiptr, const GLvoid *))
diff --git a/src/render/vitagles2/SDL_render_gles2vita.c b/src/render/vitagles2/SDL_render_gles2vita.c
new file mode 100644
index 000000000..70bbad9dd
--- /dev/null
+++ b/src/render/vitagles2/SDL_render_gles2vita.c
@@ -0,0 +1,2103 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+*/
+#include "../../SDL_internal.h"
+
+#if SDL_VIDEO_RENDER_VITA_GLES2 && !SDL_RENDER_DISABLED
+
+#include "SDL_assert.h"
+#include "SDL_hints.h"
+#include "SDL_opengles2.h"
+#include "../SDL_sysrender.h"
+#include "../../video/SDL_blit.h"
+#include "SDL_shaders_gles2vita.h"
+
+//#include <psp2/gxm.h>
+//#include <psp2/types.h>
+//#include <psp2/kernel/sysmem.h>
+
+/* To prevent unnecessary window recreation,
+ * these should match the defaults selected in SDL_GL_ResetAttributes
+ */
+#define RENDERER_CONTEXT_MAJOR 2
+#define RENDERER_CONTEXT_MINOR 0
+
+/* Used to re-create the window with OpenGL ES capability */
+extern int SDL_RecreateWindow(SDL_Window * window, Uint32 flags);
+
+/*************************************************************************************************
+ * Context structures *
+ *************************************************************************************************/
+
+typedef struct VITA_GLES2_FBOList VITA_GLES2_FBOList;
+
+struct VITA_GLES2_FBOList
+{
+ Uint32 w, h;
+ GLuint FBO;
+ VITA_GLES2_FBOList *next;
+};
+
+typedef struct VITA_GLES2_TextureData
+{
+ GLenum texture;
+ GLenum texture_type;
+ GLenum pixel_format;
+ GLenum pixel_type;
+ void *pixel_data;
+ int pitch;
+ /* YUV texture support */
+ SDL_bool yuv;
+ SDL_bool nv12;
+ GLenum texture_v;
+ GLenum texture_u;
+ VITA_GLES2_FBOList *fbo;
+} VITA_GLES2_TextureData;
+
+typedef struct VITA_GLES2_ShaderCacheEntry
+{
+ GLuint id;
+ VITA_GLES2_ShaderType type;
+ const VITA_GLES2_ShaderInstance *instance;
+ int references;
+ struct VITA_GLES2_ShaderCacheEntry *prev;
+ struct VITA_GLES2_ShaderCacheEntry *next;
+} VITA_GLES2_ShaderCacheEntry;
+
+typedef struct VITA_GLES2_ShaderCache
+{
+ int count;
+ VITA_GLES2_ShaderCacheEntry *head;
+} VITA_GLES2_ShaderCache;
+
+typedef struct VITA_GLES2_ProgramCacheEntry
+{
+ GLuint id;
+ VITA_GLES2_ShaderCacheEntry *vertex_shader;
+ VITA_GLES2_ShaderCacheEntry *fragment_shader;
+ GLuint uniform_locations[16];
+ Uint32 color;
+ GLfloat projection[4][4];
+ struct VITA_GLES2_ProgramCacheEntry *prev;
+ struct VITA_GLES2_ProgramCacheEntry *next;
+} VITA_GLES2_ProgramCacheEntry;
+
+typedef struct VITA_GLES2_ProgramCache
+{
+ int count;
+ VITA_GLES2_ProgramCacheEntry *head;
+ VITA_GLES2_ProgramCacheEntry *tail;
+} VITA_GLES2_ProgramCache;
+
+typedef enum
+{
+ VITA_GLES2_ATTRIBUTE_POSITION = 0,
+ VITA_GLES2_ATTRIBUTE_TEXCOORD = 1,
+ VITA_GLES2_ATTRIBUTE_ANGLE = 2,
+ VITA_GLES2_ATTRIBUTE_CENTER = 3,
+} VITA_GLES2_Attribute;
+
+typedef enum
+{
+ VITA_GLES2_UNIFORM_PROJECTION,
+ VITA_GLES2_UNIFORM_TEXTURE,
+ VITA_GLES2_UNIFORM_COLOR,
+ VITA_GLES2_UNIFORM_TEXTURE_U,
+ VITA_GLES2_UNIFORM_TEXTURE_V
+} VITA_GLES2_Uniform;
+
+typedef enum
+{
+ VITA_GLES2_IMAGESOURCE_INVALID,
+ VITA_GLES2_IMAGESOURCE_SOLID,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_ABGR,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_ARGB,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_RGB,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_BGR,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_YUV,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_NV12,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_NV21,
+ VITA_GLES2_IMAGESOURCE_TEXTURE_EXTERNAL_OES
+} VITA_GLES2_ImageSource;
+
+typedef struct
+{
+ SDL_Rect viewport;
+ SDL_bool viewport_dirty;
+ SDL_Texture *texture;
+ SDL_Texture *target;
+ SDL_BlendMode blend;
+ SDL_bool cliprect_enabled_dirty;
+ SDL_bool cliprect_enabled;
+ SDL_bool cliprect_dirty;
+ SDL_Rect cliprect;
+ SDL_bool texturing;
+ SDL_bool is_copy_ex;
+ Uint32 color;
+ Uint32 clear_color;
+ int drawablew;
+ int drawableh;
+ VITA_GLES2_ProgramCacheEntry *program;
+ GLfloat projection[4][4];
+} VITA_GLES2_DrawStateCache;
+
+typedef struct VITA_GLES2_RenderData
+{
+ SDL_GLContext *context;
+
+ SDL_bool debug_enabled;
+
+#define SDL_PROC(ret,func,params) ret (APIENTRY *func) params;
+#include "SDL_gles2funcs.h"
+#undef SDL_PROC
+
+ VITA_GLES2_FBOList *framebuffers;
+ GLuint window_framebuffer;
+
+ int shader_format_count;
+ GLenum *shader_formats;
+ VITA_GLES2_ShaderCache shader_cache;
+ VITA_GLES2_ProgramCache program_cache;
+ Uint8 clear_r, clear_g, clear_b, clear_a;
+
+ GLuint vertex_buffers[8];
+ size_t vertex_buffer_size[8];
+ int current_vertex_buffer;
+ VITA_GLES2_DrawStateCache drawstate;
+} VITA_GLES2_RenderData;
+
+#define VITA_GLES2_MAX_CACHED_PROGRAMS 8
+
+static const float inv255f = 1.0f / 255.0f;
+
+
+SDL_FORCE_INLINE const char*
+GL_TranslateError (GLenum error)
+{
+#define GL_ERROR_TRANSLATE(e) case e: return #e;
+ switch (error) {
+ GL_ERROR_TRANSLATE(GL_INVALID_ENUM)
+ GL_ERROR_TRANSLATE(GL_INVALID_VALUE)
+ GL_ERROR_TRANSLATE(GL_INVALID_OPERATION)
+ GL_ERROR_TRANSLATE(GL_OUT_OF_MEMORY)
+ GL_ERROR_TRANSLATE(GL_NO_ERROR)
+ default:
+ return "UNKNOWN";
+}
+#undef GL_ERROR_TRANSLATE
+}
+
+SDL_FORCE_INLINE void
+GL_ClearErrors(SDL_Renderer *renderer)
+{
+ VITA_GLES2_RenderData *data = (VITA_GLES2_RenderData *) renderer->driverdata;
+
+ if (!data->debug_enabled) {
+ return;
+ }
+ while (data->glGetError() != GL_NO_ERROR) {
+ /* continue; */
+ }
+}
+
+SDL_FORCE_INLINE int
+GL_CheckAllErrors (const char *prefix, SDL_Renderer *renderer, const char *file, int line, const char *function)
+{
+ VITA_GLES2_RenderData *data = (VITA_GLES2_RenderData *) renderer->driverdata;
+ int ret = 0;
+
+ if (!data->debug_enabled) {
+ return 0;
+ }
+ /* check gl errors (can return multiple errors) */
+ for (;;) {
+ GLenum error = data->glGetError();
+ if (error != GL_NO_ERROR) {
+ if (prefix == NULL || prefix[0] == '\0') {
+ prefix = "generic";
+ }
+ SDL_SetError("%s: %s (%d): %s %s (0x%X)", prefix, file, line, function, GL_TranslateError(error), error);
+ ret = -1;
+ } else {
+ break;
+ }
+ }
+ return ret;
+}
+
+#if 0
+#define GL_CheckError(prefix, renderer)
+#else
+#define GL_CheckError(prefix, renderer) GL_CheckAllErrors(prefix, renderer, SDL_FILE, SDL_LINE, SDL_FUNCTION)
+#endif
+
+/*************************************************************************************************
+ * Renderer state APIs *
+ *************************************************************************************************/
+
+static int VITA_GLES2_LoadFunctions(VITA_GLES2_RenderData * data)
+{
+#define SDL_PROC(ret,func,params) data->func=func;
+#include "SDL_gles2funcs.h"
+#undef SDL_PROC
+ return 0;
+}
+
+static VITA_GLES2_FBOList *
+VITA_GLES2_GetFBO(VITA_GLES2_RenderData *data, Uint32 w, Uint32 h)
+{
+ VITA_GLES2_FBOList *result = data->framebuffers;
+ while ((result) && ((result->w != w) || (result->h != h)) ) {
+ result = result->next;
+ }
+ if (result == NULL) {
+ result = SDL_malloc(sizeof(VITA_GLES2_FBOList));
+ result->w = w;
+ result->h = h;
+ data->glGenFramebuffers(1, &result->FBO);
+ result->next = data->framebuffers;
+ data->framebuffers = result;
+ }
+ return result;
+}
+
+static int
+VITA_GLES2_ActivateRenderer(SDL_Renderer * renderer)
+{
+ VITA_GLES2_RenderData *data = (VITA_GLES2_RenderData *)renderer->driverdata;
+
+ if (SDL_GL_GetCurrentContext() != data->context) {
+ /* Null out the current program to ensure we set it again */
+ data->drawstate.program = NULL;
+
+ if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
+ return -1;
+ }
+ }
+
+ GL_ClearErrors(renderer);
+
+ return 0;
+}
+
+static void
+VITA_GLES2_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
+{
+ VITA_GLES2_RenderData *data = (VITA_GLES2_RenderData *)renderer->driverdata;
+
+ if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
+ /* According to Apple documentation, we need to finish drawing NOW! */
+ data->glFinish();
+ }
+}
+
+static int
+VITA_GLES2_GetOutputSize(SDL_Renderer * renderer, int *w, int *h)
+{
+ SDL_GL_GetDrawableSize(renderer->window, w, h);
+ return 0;
+}
+
+static GLenum GetBlendFunc(SDL_BlendFactor factor)
+{
+ switch (factor) {
+ case SDL_BLENDFACTOR_ZERO:
+ return GL_ZERO;
+ case SDL_BLENDFACTOR_ONE:
+ return GL_ONE;
+ case SDL_BLENDFACTOR_SRC_COLOR:
+ return GL_SRC_COLOR;
+ case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
+ return GL_ONE_MINUS_SRC_COLOR;
+ case SDL_BLENDFACTOR_SRC_ALPHA:
+ return GL_SRC_ALPHA;
+ case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
+ return GL_ONE_MINUS_SRC_ALPHA;
+ case SDL_BLENDFACTOR_DST_COLOR:
+ return GL_DST_COLOR;
+ case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
+ return GL_ONE_MINUS_DST_COLOR;
+ case SDL_BLENDFACTOR_DST_ALPHA:
+ return GL_DST_ALPHA;
+ case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
+ return GL_ONE_MINUS_DST_ALPHA;
+ default:
+ return GL_INVALID_ENUM;
+ }
+}
+
+static GLenum GetBlendEquation(SDL_BlendOperation operation)
+{
+ switch (operation) {
+ case SDL_BLENDOPERATION_ADD:
+ return GL_FUNC_ADD;
+ case SDL_BLENDOPERATION_SUBTRACT:
+ return GL_FUNC_SUBTRACT;
+ case SDL_BLENDOPERATION_REV_SUBTRACT:
+ return GL_FUNC_REVERSE_SUBTRACT;
+ default:
+ return GL_INVALID_ENUM;
+ }
+}
+
+static SDL_bool
+VITA_GLES2_SupportsBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
+{
+ SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
+ SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
+ SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
+ SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
+ SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
+ SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
+
+ if (GetBlendFunc(srcColorFactor) == GL_INVALID_ENUM ||
+ GetBlendFunc(srcAlphaFactor) == GL_INVALID_ENUM ||
+ GetBlendEquation(colorOperation) == GL_INVALID_ENUM ||
+ GetBlendFunc(dstColorFactor) == GL_INVALID_ENUM ||
+ GetBlendFunc(dstAlphaFactor) == GL_INVALID_ENUM ||
+ GetBlendEquation(alphaOperation) == GL_INVALID_ENUM) {
+ return SDL_FALSE;
+ }
+ return SDL_TRUE;
+}
+
+
+static void
+VITA_GLES2_EvictShader(VITA_GLES2_RenderData *data, VITA_GLES2_ShaderCacheEntry *entry)
+{
+ /* Unlink the shader from the cache */
+ if (entry->next) {
+ entry->next->prev = entry->prev;
+ }
+ if (entry->prev) {
+ entry->prev->next = entry->next;
+ }
+ if (data->shader_cache.head == entry) {
+ data->shader_cache.head = entry->next;
+ }
+ --data->shader_cache.count;
+
+ /* Deallocate the shader */
+ data->glDeleteShader(entry->id);
+ SDL_free(entry);
+}
+
+static VITA_GLES2_ProgramCacheEntry *
+VITA_GLES2_CacheProgram(VITA_GLES2_RenderData *data, VITA_GLES2_ShaderCacheEntry *vertex,
+ VITA_GLES2_ShaderCacheEntry *fragment)
+{
+ VITA_GLES2_ProgramCacheEntry *entry;
+ VITA_GLES2_ShaderCacheEntry *shaderEntry;
+ GLint linkSuccessful;
+
+ /* Check if we've already cached this program */
+ entry = data->program_cache.head;
+ while (entry) {
+ if (entry->vertex_shader == vertex && entry->fragment_shader == fragment) {
+ break;
+ }
+ entry = entry->next;
+ }
+ if (entry) {
+ if (data->program_cache.head != entry) {
+ if (entry->next) {
+ entry->next->prev = entry->prev;
+ }
+ if (entry->prev) {
+ entry->prev->next = entry->next;
+ }
+ entry->prev = NULL;
+ entry->next = data->program_cache.head;
+ data->program_cache.head->prev = entry;
+ data->program_cache.head = entry;
+ }
+ return entry;
+ }
+
+ /* Create a program cache entry */
+ entry = (VITA_GLES2_ProgramCacheEntry *)SDL_calloc(1, sizeof(VITA_GLES2_ProgramCacheEntry));
+ if (!entry) {
+ SDL_OutOfMemory();
+ return NULL;
+ }
+ entry->vertex_shader = vertex;
+ entry->fragment_shader = fragment;
+
+ /* Create the program and link it */
+ entry->id = data->glCreateProgram();
+ data->glAttachShader(entry->id, vertex->id);
+ data->glAttachShader(entry->id, fragment->id);
+ data->glBindAttribLocation(entry->id, VITA_GLES2_ATTRIBUTE_POSITION, "a_position");
+ data->glBindAttribLocation(entry->id, VITA_GLES2_ATTRIBUTE_TEXCOORD, "a_texCoord");
+ data->glBindAttribLocation(entry->id, VITA_GLES2_ATTRIBUTE_ANGLE, "a_angle");
+ data->glBindAttribLocation(entry->id, VITA_GLES2_ATTRIBUTE_CENTER, "a_center");
+ data->glLinkProgram(entry->id);
+ data->glGetProgramiv(entry->id, GL_LINK_STATUS, &linkSuccessful);
+ if (!linkSuccessful) {
+ data->glDeleteProgram(entry->id);
+ SDL_free(entry);
+ SDL_SetError("Failed to link shader program");
+ return NULL;
+ }
+
+ /* Predetermine locations of uniform variables */
+ entry->uniform_locations[VITA_GLES2_UNIFORM_PROJECTION] =
+ data->glGetUniformLocation(entry->id, "u_projection");
+ entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_V] =
+ data->glGetUniformLocation(entry->id, "u_texture_v");
+ entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_U] =
+ data->glGetUniformLocation(entry->id, "u_texture_u");
+ entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE] =
+ data->glGetUniformLocation(entry->id, "u_texture");
+ entry->uniform_locations[VITA_GLES2_UNIFORM_COLOR] =
+ data->glGetUniformLocation(entry->id, "u_color");
+
+ entry->color = 0;
+
+ data->glUseProgram(entry->id);
+ if (entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_V] != -1) {
+ data->glUniform1i(entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_V], 2); /* always texture unit 2. */
+ }
+ if (entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_U] != -1) {
+ data->glUniform1i(entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE_U], 1); /* always texture unit 1. */
+ }
+ if (entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE] != -1) {
+ data->glUniform1i(entry->uniform_locations[VITA_GLES2_UNIFORM_TEXTURE], 0); /* always texture unit 0. */
+ }
+ if (entry->uniform_locations[VITA_GLES2_UNIFORM_PROJECTION] != -1) {
+ data->glUniformMatrix4fv(entry->uniform_locations[VITA_GLES2_UNIFORM_PROJECTION], 1, GL_FALSE, (GLfloat *)entry->projection);
+ }
+ if (entry->uniform_locations[VITA_GLES2_UNIFORM_COLOR] != -1) {
+ data->glUniform4f(entry->uniform_locations[VITA_GLES2_UNIFORM_COLOR], 0.0f, 0.0f, 0.0f, 0.0f);
+ }
+
+ /* Cache the linked program */
+ if (data->program_cache.head) {
+ entry->next = data->program_cache.head;
+ data->program_cache.head->prev = entry;
+ } else {
+ data->program_cache.tail = entry;
+ }
+ data->program_cache.head = entry;
+ ++data->program_cache.count;
+
+ /* Increment the refcount of the shaders we're using */
+ ++vertex->references;
+ ++fragment->references;
+
+ /* Evict the last entry from the cache if we exceed the limit */
+ if (data->program_cache.count > VITA_GLES2_MAX_CACHED_PROGRAMS) {
+ shaderEntry = data->program_cache.tail->vertex_shader;
+ if (--shaderEntry->references <= 0) {
+ VITA_GLES2_EvictShader(data, shaderEntry);
+ }
+ shaderEntry = data->program_cache.tail->fragment_shader;
+ if (--shaderEntry->references <= 0) {
+ VITA_GLES2_EvictShader(data, shaderEntry);
+ }
+ data->glDeleteProgram(data->program_cache.tail->id);
+ data->program_cache.tail = data->program_cache.tail->prev;
+ if (data->program_cache.tail != NULL) {
+ SDL_free(data->program_cache.tail->next);
+ data->program_cache.tail->next = NULL;
+ }
+ --data->program_cache.count;
+ }
+ return entry;
+}
+
+static VITA_GLES2_ShaderCacheEntry *
+VITA_GLES2_CacheShader(VITA_GLES2_RenderData *data, VITA_GLES2_ShaderType type)
+{
+ const VITA_GLES2_Shader *shader;
+ const VITA_GLES2_ShaderInstance *instance = NULL;
+ VITA_GLES2_ShaderCacheEntry *entry = NULL;
+ GLint compileSuccessful = GL_FALSE;
+ int i, j;
+
+ /* Find the corresponding shader */
+ shader = VITA_GLES2_GetShader(type);
+ if (!shader) {
+ SDL_SetError("No shader matching the requested characteristics was found");
+ return NULL;
+ }
+
+ /* Find a matching shader instance that's supported on this hardware */
+ for (i = 0; i < shader->instance_count && !instance; ++i) {
+ for (j = 0; j < data->shader_format_count && !instance; ++j) {
+ if (!shader->instances[i]) {
+ continue;
+ }
+ if (shader->instances[i]->format != data->shader_formats[j]) {
+ continue;
+ }
+ instance = shader->instances[i];
+ }
+ }
+ if (!instance) {
+ SDL_SetError("The specified shader cannot be loaded on the current platform");
+ return NULL;
+ }
+
+ /* Check if we've already cached this shader */
+ entry = data->shader_cache.head;
+ while (entry) {
+ if (entry->instance == instance) {
+ break;
+ }
+ entry = entry->next;
+ }
+ if (entry) {
+ return entry;
+ }
+
+ /* Create a shader cache entry */
+ entry = (VITA_GLES2_ShaderCacheEntry *)SDL_calloc(1, sizeof(VITA_GLES2_ShaderCacheEntry));
+ if (!entry) {
+ SDL_OutOfMemory();
+ return NULL;
+ }
+ entry->type = type;
+ entry->instance = instance;
+
+ /* Compile or load the selected shader instance */
+ entry->id = data->glCreateShader(instance->type);
+ if (instance->format == (GLenum)-1) {
+ data->glShaderSource(entry->id, 1, (const char **)(char *)&instance->data, NULL);
+ data->glCompileShader(entry->id);
+ data->glGetShaderiv(entry->id, GL_COMPILE_STATUS, &compileSuccessful);
+ } else {
+ data->glShaderBinary(1, &entry->id, instance->format, instance->data, instance->length);
+ compileSuccessful = GL_TRUE;
+ }
+ if (!compileSuccessful) {
+ SDL_bool isstack = SDL_FALSE;
+ char *info = NULL;
+ int length = 0;
+
+ data->glGetShaderiv(entry->id, GL_INFO_LOG_LENGTH, &length);
+ if (length > 0) {
+ info = SDL_small_alloc(char, length, &isstack);
+ if (info) {
+ data->glGetShaderInfoLog(entry->id, length, &length, info);
+ }
+ }
+ if (info) {
+ SDL_SetError("Failed to load the shader: %s", info);
+ SDL_small_free(info, isstack);
+ } else {
+ SDL_SetError("Failed to load the shader");
+ }
+ data->glDeleteShader(entry->id);
+ SDL_free(entry);
+ return NULL;
+ }
+
+ /* Link the shader entry in at the front of the cache */
+ if (data->shader_cache.head) {
+ entry->next = data->shader_cache.head;
+ data->shader_cache.head->prev = entry;
+ }
+ data->shader_cache.head = entry;
+ ++data->shader_cache.count;
+ return entry;
+}
+
+static int
+VITA_GLES2_SelectProgram(VITA_GLES2_RenderData *data, VITA_GLES2_ImageSource source, int w, int h)
+{
+ VITA_GLES2_ShaderCacheEntry *vertex = NULL;
+ VITA_GLES2_ShaderCacheEntry *fragment = NULL;
+ VITA_GLES2_ShaderType vtype, ftype;
+ VITA_GLES2_ProgramCacheEntry *program;
+
+ /* Select an appropriate shader pair for the specified modes */
+ vtype = VITA_GLES2_SHADER_VERTEX_DEFAULT;
+ switch (source) {
+ case VITA_GLES2_IMAGESOURCE_SOLID:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_SOLID_SRC;
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_ABGR:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_ABGR_SRC;
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_ARGB:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_ARGB_SRC;
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_RGB:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_RGB_SRC;
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_BGR:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_BGR_SRC;
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_YUV:
+ switch (SDL_GetYUVConversionModeForResolution(w, h)) {
+ case SDL_YUV_CONVERSION_JPEG:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_YUV_JPEG_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT601:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT601_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT709:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_YUV_BT709_SRC;
+ break;
+ default:
+ SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h));
+ goto fault;
+ }
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_NV12:
+ switch (SDL_GetYUVConversionModeForResolution(w, h)) {
+ case SDL_YUV_CONVERSION_JPEG:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV12_JPEG_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT601:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT601_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT709:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV12_BT709_SRC;
+ break;
+ default:
+ SDL_SetError("Unsupported YUV conversion mode: %d\n", SDL_GetYUVConversionModeForResolution(w, h));
+ goto fault;
+ }
+ break;
+ case VITA_GLES2_IMAGESOURCE_TEXTURE_NV21:
+ switch (SDL_GetYUVConversionModeForResolution(w, h)) {
+ case SDL_YUV_CONVERSION_JPEG:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV21_JPEG_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT601:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT601_SRC;
+ break;
+ case SDL_YUV_CONVERSION_BT709:
+ ftype = VITA_GLES2_SHADER_FRAGMENT_TEXTURE_NV21_BT709_SRC;
+ break;
+ default:
+ SDL_SetError("Unsupport
(Patch may be truncated, please check the link at the top of this post.)