/* * Copyright (C) 2021 Andy Nguyen * Copyright (C) 2021 Rinnegatamante * Copyright (C) 2022-2023 Volodymyr Atamanenko * * This software may be modified and distributed under the terms * of the MIT license. See the LICENSE file for details. */ #include "utils/glutil.h" #include "utils/utils.h" #include "utils/dialog.h" #include "utils/logger.h" #include #include #include #include #include // Helpers for our handling of shaders GLboolean skip_next_compile = GL_FALSE; char next_shader_fname[256]; static unsigned int draw_calls; static unsigned int matrix_uploads; static unsigned int attrib_updates; static unsigned int texture_uploads; void load_shader(GLuint shader, const char * string, size_t length); void gl_preload() { if (!file_exists("ur0:/data/libshacccg.suprx") && !file_exists("ur0:/data/external/libshacccg.suprx")) { fatal_error("Error: libshacccg.suprx is not installed. " "Google \"ShaRKBR33D\" for quick installation."); } #ifdef USE_GLSL_SHADERS /* v0.19-v0.23 hardware tests confirmed POSTPONED as the working mode once the temporary loading renderer is released before nativeInit. */ vglSetSemanticBindingMode(VGL_MODE_POSTPONED); #endif } void gl_init() { /* * Cocos2d-x uses the programmable GLES2 pipeline. Keep the legacy pool at * zero and avoid 4x MSAA: this 2D game does not request it and the extra * multisampled target wastes VRAM and can disagree with its EGL config. */ l_info("VitaGL pipeline=modern GLSL semantics=postponed legacy_pool=0 msaa=none"); vglInitExtended(0, 960, 544, 6 * 1024 * 1024, SCE_GXM_MULTISAMPLE_NONE); } void gl_swap() { vglSwapBuffers(GL_FALSE); } void glShaderSource_soloader(GLuint shader, GLsizei count, const GLchar **string, const GLint *_length) { #ifdef DEBUG_OPENGL sceClibPrintf("[gl_dbg] glShaderSource<%p>(shader: %i, count: %i, string: %p, length: %p)\n", __builtin_return_address(0), shader, count, string, _length); #endif if (!string) { l_error("<%p> Shader source string is NULL, count: %i", __builtin_return_address(0), count); skip_next_compile = GL_TRUE; return; } else if (!*string) { l_error("<%p> Shader source *string is NULL, count: %i", __builtin_return_address(0), count); skip_next_compile = GL_TRUE; return; } size_t total_length = 0; for (int i = 0; i < count; ++i) { if (!_length) { total_length += strlen(string[i]); } else { total_length += _length[i]; } } char * str = malloc(total_length+1); size_t l = 0; for (int i = 0; i < count; ++i) { if (!_length) { memcpy(str + l, string[i], strlen(string[i])); l += strlen(string[i]); } else { memcpy(str + l, string[i], _length[i]); l += _length[i]; } } str[total_length] = '\0'; load_shader(shader, str, total_length); free(str); } void glCompileShader_soloader(GLuint shader) { #ifdef DEBUG_OPENGL sceClibPrintf("[gl_dbg] glCompileShader<%p>(shader: %i)\n", __builtin_return_address(0), shader); #endif #ifndef USE_GXP_SHADERS if (!skip_next_compile) { glCompileShader(shader); /* VGL_MODE_POSTPONED deliberately compiles the shader at link time. */ l_info("GL shader queued id=%u", shader); #ifdef DUMP_COMPILED_SHADERS void *bin = vglMalloc(32 * 1024); GLsizei len; vglGetShaderBinary(shader, 32 * 1024, &len, bin); file_save(next_shader_fname, bin, len); vglFree(bin); #endif } skip_next_compile = GL_FALSE; #endif } void glLinkProgram_soloader(GLuint program) { glLinkProgram(program); GLint linked = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linked); if (!linked) { char info[1024] = {0}; GLsizei length = 0; glGetProgramInfoLog(program, sizeof(info) - 1, &length, info); l_error("GL program link failed id=%u log=%s", program, length ? info : ""); } else { l_info("GL program linked id=%u", program); } } void glDrawArrays_soloader(GLenum mode, GLint first, GLsizei count) { ++draw_calls; /* The game's 2D sprites use premultiplied alpha. Reassert the expected Cocos2d-x blend function because the translated Android EGL state did not modify any framebuffer pixels despite valid draws. */ glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); if (draw_calls <= 8) { GLint program = 0, framebuffer = 0; glGetIntegerv(GL_CURRENT_PROGRAM, &program); glGetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer); l_info("GL drawArrays call=%u mode=0x%x first=%d count=%d program=%d fb=%d", draw_calls, mode, first, count, program, framebuffer); } glDrawArrays(mode, first, count); } void glDrawElements_soloader(GLenum mode, GLsizei count, GLenum type, const void *indices) { ++draw_calls; glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); if (draw_calls <= 8) { GLint program = 0, framebuffer = 0, element_buffer = 0; glGetIntegerv(GL_CURRENT_PROGRAM, &program); glGetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer); glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &element_buffer); l_info("GL drawElements call=%u mode=0x%x count=%d type=0x%x program=%d fb=%d ebo=%d indices=%p", draw_calls, mode, count, type, program, framebuffer, element_buffer, indices); } glDrawElements(mode, count, type, indices); } unsigned int gl_draw_call_count(void) { return draw_calls; } void glUniformMatrix4fv_soloader(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) { ++matrix_uploads; if (matrix_uploads <= 12 && value) { l_info("GL matrix call=%u loc=%d count=%d transpose=%d m=[%.3f %.3f %.3f %.3f | %.3f %.3f %.3f %.3f | %.3f %.3f %.3f %.3f | %.3f %.3f %.3f %.3f]", matrix_uploads, location, count, transpose, value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8], value[9], value[10], value[11], value[12], value[13], value[14], value[15]); } glUniformMatrix4fv(location, count, transpose, value); } void glVertexAttribPointer_soloader(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { ++attrib_updates; if (attrib_updates <= 20) { GLint array_buffer = 0; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &array_buffer); l_info("GL attrib call=%u index=%u size=%d type=0x%x norm=%d stride=%d vbo=%d ptr=%p", attrib_updates, index, size, type, normalized, stride, array_buffer, pointer); } glVertexAttribPointer(index, size, type, normalized, stride, pointer); } void glTexImage2D_soloader(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { ++texture_uploads; if (texture_uploads <= 32) { GLint texture = 0; glGetIntegerv(GL_TEXTURE_BINDING_2D, &texture); l_info("GL texture upload=%u id=%d level=%d size=%dx%d internal=0x%x format=0x%x type=0x%x pixels=%p", texture_uploads, texture, level, width, height, internalformat, format, type, pixels); } /* Discard an error left by earlier GLES compatibility queries so the result below belongs specifically to this upload. */ while (glGetError() != GL_NO_ERROR) {} glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); GLenum error = glGetError(); if (error != GL_NO_ERROR) l_error("GL texture upload=%u failed error=0x%04x size=%dx%d", texture_uploads, error, width, height); } void glTexSubImage2D_soloader(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); GLenum error = glGetError(); if (error != GL_NO_ERROR) l_error("GL texture sub-upload failed error=0x%04x size=%dx%d at=%d,%d", error, width, height, xoffset, yoffset); } #if defined(USE_GLSL_SHADERS) && defined(DUMP_COMPILED_SHADERS) void load_shader(GLuint shader, const char * string, size_t length) { char* sha_name = str_sha1sum(string, length); char gxp_path[256]; snprintf(gxp_path, sizeof(gxp_path), DATA_PATH"gxp/%s.gxp", sha_name); if (file_exists(gxp_path)) { uint8_t *buffer; size_t size; file_load(gxp_path, &buffer, &size); glShaderBinary(1, &shader, 0, buffer, (int32_t) size); free(buffer); skip_next_compile = GL_TRUE; } else { glShaderSource(shader, 1, &string, &length); strcpy(next_shader_fname, gxp_path); } free(sha_name); } #elif defined(USE_GLSL_SHADERS) void load_shader(GLuint shader, const char * string, size_t length) { glShaderSource(shader, 1, &string, &length); } #elif defined(USE_CG_SHADERS) && defined(DUMP_COMPILED_SHADERS) void load_shader(GLuint shader, const char * string, size_t length) { char* sha_name = str_sha1sum(string, length); char gxp_path[256]; char cg_path[256]; snprintf(gxp_path, sizeof(gxp_path), DATA_PATH"gxp/%s.gxp", sha_name); snprintf(cg_path, sizeof(cg_path), DATA_PATH"cg/%s.cg", sha_name); if (file_exists(gxp_path)) { uint8_t *buffer; size_t size; file_load(gxp_path, &buffer, &size); glShaderBinary(1, &shader, 0, buffer, (int32_t) size); free(buffer); skip_next_compile = GL_TRUE; } else if (file_exists(cg_path)) { char *buffer; size_t size; file_load(cg_path, (uint8_t **) &buffer, &size); glShaderSource(shader, 1, &string, &size); strcpy(next_shader_fname, gxp_path); free(buffer); skip_next_compile = GL_FALSE; } else { l_warn("Encountered an untranslated shader %s, saving GLSL " "and using a dummy shader.", sha_name); char glsl_path[256]; snprintf(glsl_path, sizeof(glsl_path), DATA_PATH"glsl/%s.glsl", sha_name); file_mkpath(glsl_path, 0777); file_save(glsl_path, (const uint8_t *) string, length); if (strstr(string, "gl_FragColor")) { const char *dummy_shader = "float4 main() { return float4(1.0,1.0,1.0,1.0); }"; int32_t dummy_shader_len = (int32_t) strlen(dummy_shader); glShaderSource(shader, 1, &dummy_shader, &dummy_shader_len); } else { const char *dummy_shader = "void main(float4 out gl_Position : POSITION ) { gl_Position = float4(1.0,1.0,1.0,1.0); }"; int32_t dummy_shader_len = (int32_t) strlen(dummy_shader); glShaderSource(shader, 1, &dummy_shader, &dummy_shader_len); } skip_next_compile = GL_FALSE; } free(sha_name); } #elif defined(USE_CG_SHADERS) || defined(USE_GXP_SHADERS) void load_shader(GLuint shader, const char * string, size_t length) { char* sha_name = str_sha1sum(string, length); char path[256]; #ifdef USE_CG_SHADERS snprintf(path, sizeof(path), DATA_PATH"cg/%s.cg", sha_name); #else snprintf(path, sizeof(path), DATA_PATH"gxp/%s.gxp", sha_name); #endif if (file_exists(path)) { #ifdef USE_CG_SHADERS char *buffer; size_t size; file_load(path, (uint8_t **) &buffer, &size); glShaderSource(shader, 1, &string, &size); free(buffer); #else uint8_t *buffer; size_t size; file_load(path, &buffer, &size); glShaderBinary(1, &shader, 0, buffer, (int32_t) size); free(buffer); #endif } else { l_warn("Encountered an untranslated shader %s, saving GLSL " "and using a dummy shader.", sha_name); char glsl_path[256]; snprintf(glsl_path, sizeof(glsl_path), DATA_PATH"glsl/%s.glsl", sha_name); file_mkpath(glsl_path, 0777); file_save(glsl_path, (const uint8_t *) string, length); if (strstr(string, "gl_FragColor")) { const char *dummy_shader = "float4 main() { return float4(1.0,1.0,1.0,1.0); }"; int32_t dummy_shader_len = (int32_t) strlen(dummy_shader); glShaderSource(shader, 1, &dummy_shader, &dummy_shader_len); } else { const char *dummy_shader = "void main(float4 out gl_Position : POSITION ) { gl_Position = float4(1.0,1.0,1.0,1.0); }"; int32_t dummy_shader_len = (int32_t) strlen(dummy_shader); glShaderSource(shader, 1, &dummy_shader, &dummy_shader_len); } } free(sha_name); } #else #error "Define one of (USE_GLSL_SHADERS, USE_CG_SHADERS, USE_GXP_SHADERS)" #endif