TheCloud/MobileGlues
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGlues.git synced 2025-09-22 10:42:11 -04:00
Code Issues Packages Projects Releases Wiki Activity

[Refactor] (Config): Improve code.

Browse Source
This commit is contained in:
BZLZHH 2025-07-13 14:17:49 +08:00
parent bb1c9eb2a2
commit 164862ee09
7 changed files with 150 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

198
src/main/cpp/config/settings.cpp
View File

@ -14,10 +14,10 @@ struct global_settings_t global_settings;
void init_settings() {
#if defined(__APPLE__)
global_settings.angle = 0;
global_settings.ignore_error = 1;
global_settings.ext_gl43 = 0;
global_settings.ext_compute_shader = 0;
global_settings.angle = AngleMode::Disabled;
global_settings.ignore_error = IgnoreErrorLevel::Partial;
global_settings.ext_gl43 = false;
global_settings.ext_compute_shader = false;
global_settings.max_glsl_cache_size = 30 * 1024 * 1024;
global_settings.multidraw_mode = multidraw_mode_t::DrawElements;
#else
@ -30,154 +30,154 @@ void init_settings() {
}
}
int enableANGLE = success ? config_get_int("enableANGLE") : 0;
int enableNoError = success ? config_get_int("enableNoError") : 0;
int enableExtGL43 = success ? config_get_int("enableExtGL43") : 0;
int enableExtComputeShader = success ? config_get_int("enableExtComputeShader") : 0;
AngleConfig angleConfig = success ? static_cast<AngleConfig>(config_get_int("enableANGLE")) : AngleConfig::DisableIfPossible;
NoErrorConfig noErrorConfig = success ? static_cast<NoErrorConfig>(config_get_int("enableNoError")) : NoErrorConfig::Auto;
bool enableExtGL43 = success ? (config_get_int("enableExtGL43") != 0) : false;
bool enableExtComputeShader = success ? (config_get_int("enableExtComputeShader") != 0) : false;
int enableCompatibleMode = success ? config_get_int("enableCompatibleMode") : 0;
multidraw_mode_t multidrawMode = success ? (multidraw_mode_t)config_get_int("multidrawMode") : multidraw_mode_t::Auto;
// multidraw_mode_t multidrawMode = multidraw_mode_t::PreferUnroll;
multidraw_mode_t multidrawMode = success ? static_cast<multidraw_mode_t>(config_get_int("multidrawMode")) : multidraw_mode_t::Auto;
size_t maxGlslCacheSize = 0;
if (config_get_int("maxGlslCacheSize") > 0)
if (config_get_int("maxGlslCacheSize") > 0) {
maxGlslCacheSize = success ? config_get_int("maxGlslCacheSize") * 1024 * 1024 : 0;
}
if (enableANGLE < 0 || enableANGLE > 3)
enableANGLE = 0;
if (enableNoError < 0 || enableNoError > 3)
enableNoError = 0;
if (enableExtGL43 < 0 || enableExtGL43 > 1)
enableExtGL43 = 0;
if (enableExtComputeShader < 0 || enableExtComputeShader > 1)
enableExtComputeShader = 0;
if (enableCompatibleMode < 0 || enableCompatibleMode > 1)
enableCompatibleMode = 0;
if ((int)multidrawMode < 0 || (int)multidrawMode >= (int)multidraw_mode_t::MaxValue)
if (static_cast<int>(angleConfig) < 0 || static_cast<int>(angleConfig) > 3) {
angleConfig = AngleConfig::DisableIfPossible;
}
if (static_cast<int>(noErrorConfig) < 0 || static_cast<int>(noErrorConfig) > 3) {
noErrorConfig = NoErrorConfig::Auto;
}
if (static_cast<int>(multidrawMode) < 0 || static_cast<int>(multidrawMode) >= static_cast<int>(multidraw_mode_t::MaxValue)) {
multidrawMode = multidraw_mode_t::Auto;
}
if (enableCompatibleMode < 0 || enableCompatibleMode > 1) {
enableCompatibleMode = 0;
}
// 1205
int fclVersion = 0;
GetEnvVarInt("FCL_VERSION_CODE", &fclVersion, 0);
// 140000
int zlVersion = 0;
GetEnvVarInt("ZALITH_VERSION_CODE", &zlVersion, 0);
// unknown
int pgwVersion = 0;
GetEnvVarInt("PGW_VERSION_CODE", &pgwVersion, 0);
char* var = getenv("MG_DIR_PATH");
LOG_V("MG_DIR_PATH = %s", var ? var : "(null)")
if (fclVersion == 0 && zlVersion == 0 && pgwVersion == 0 && !var) {
LOG_V("Unsupported launcher detected, force using default config.")
enableANGLE = 0;
enableNoError = 0;
enableExtGL43 = 0;
enableExtComputeShader = 0;
angleConfig = AngleConfig::DisableIfPossible;
noErrorConfig = NoErrorConfig::Auto;
enableExtGL43 = false;
enableExtComputeShader = false;
maxGlslCacheSize = 0;
enableCompatibleMode = 0;
}
// Determining actual ANGLE mode
AngleMode finalAngleMode = AngleMode::Disabled;
std::string gpuString = getGPUInfo();
const char* gpu_cstr = gpuString.c_str();
LOG_D("GPU: %s", gpu_cstr ? gpu_cstr : "(unknown)")
if (enableANGLE == 2 || enableANGLE == 3) {
// Force enable / disable
global_settings.angle = enableANGLE - 2;
} else {
int isQcom = isAdreno(gpu_cstr);
int is740 = isAdreno740(gpu_cstr);
//int is830 = isAdreno830(gpu_cstr);
int hasVk13 = hasVulkan13();
switch (angleConfig) {
case AngleConfig::ForceDisable:
finalAngleMode = AngleMode::Disabled;
LOG_D("ANGLE: Force disabled");
break;
case AngleConfig::ForceEnable:
finalAngleMode = AngleMode::Enabled;
LOG_D("ANGLE: Force enabled");
break;
case AngleConfig::EnableIfPossible: {
int isQcom = isAdreno(gpu_cstr);
int is740 = isAdreno740(gpu_cstr);
int hasVk13 = hasVulkan13();
LOG_D("Is Adreno? = %s", isQcom ? "true" : "false")
//LOG_D("Is Adreno 830? = %s", is830 ? "true" : "false")
LOG_D("Is Adreno 740? = %s", is740 ? "true" : "false")
LOG_D("Has Vulkan 1.3? = %s", hasVk13 ? "true" : "false")
LOG_D("Is Adreno? = %s", isQcom ? "true" : "false")
LOG_D("Is Adreno 740? = %s", is740 ? "true" : "false")
LOG_D("Has Vulkan 1.3? = %s", hasVk13 ? "true" : "false")
//if (is830)
// global_settings.angle = 1;
if (is740)
global_settings.angle = 0;
else
global_settings.angle = hasVk13 && enableANGLE;
finalAngleMode = (is740 || !hasVk13) ? AngleMode::Disabled : AngleMode::Enabled;
LOG_D("ANGLE: Conditionally %s", (finalAngleMode == AngleMode::Enabled) ? "enabled" : "disabled");
break;
}
case AngleConfig::DisableIfPossible:
default:
finalAngleMode = AngleMode::Disabled;
LOG_D("ANGLE: Disabled by default");
break;
}
LOG_D("enableANGLE = %d", enableANGLE)
LOG_D("global_settings.angle = %d", global_settings.angle)
global_settings.angle = finalAngleMode;
LOG_D("Final ANGLE setting: %d", static_cast<int>(global_settings.angle))
// if (enableANGLE == 1) {
// global_settings.angle = (isAdreno740(gpuString) || !hasVulkan13()) ? 0 : 1;
// } else if (enableANGLE == 2 || enableANGLE == 3) {
// global_settings.angle = enableANGLE - 2;
// } else {
// int is830 = isAdreno830(gpuString);
// LOG_D("Is Adreno 830? = %s", is830 ? "true" : "false")
// global_settings.angle = is830 ? 1 : 0;
// }
if (global_settings.angle) {
if (global_settings.angle == AngleMode::Enabled) {
setenv("LIBGL_GLES", "libGLESv2_angle.so", 1);
setenv("LIBGL_EGL", "libEGL_angle.so", 1);
}
if (enableNoError == 1 || enableNoError == 2 || enableNoError == 3) {
global_settings.ignore_error = enableNoError - 1;
} else {
global_settings.ignore_error = 0;
switch (noErrorConfig) {
case NoErrorConfig::Level1:
global_settings.ignore_error = IgnoreErrorLevel::Partial;
LOG_D("Error ignoring: Level 1 (Partial)");
break;
case NoErrorConfig::Level2:
global_settings.ignore_error = IgnoreErrorLevel::Full;
LOG_D("Error ignoring: Level 2 (Full)");
break;
case NoErrorConfig::Auto:
case NoErrorConfig::Disable:
default:
global_settings.ignore_error = IgnoreErrorLevel::None;
LOG_D("Error ignoring: Disabled");
break;
}
global_settings.ext_gl43 = enableExtGL43;
global_settings.ext_compute_shader = enableExtComputeShader;
global_settings.max_glsl_cache_size = maxGlslCacheSize;
global_settings.multidraw_mode = multidrawMode;
#endif
std::string draw_mode_str;
switch (global_settings.multidraw_mode) {
case multidraw_mode_t::PreferIndirect:
draw_mode_str = "Indirect";
break;
case multidraw_mode_t::PreferBaseVertex:
draw_mode_str = "Unroll";
break;
case multidraw_mode_t::PreferMultidrawIndirect:
draw_mode_str = "Multidraw indirect";
break;
case multidraw_mode_t::DrawElements:
draw_mode_str = "DrawElements";
break;
case multidraw_mode_t::Compute:
draw_mode_str = "Compute";
break;
case multidraw_mode_t::Auto:
draw_mode_str = "Auto";
break;
case multidraw_mode_t::PreferIndirect: draw_mode_str = "Indirect"; break;
case multidraw_mode_t::PreferBaseVertex: draw_mode_str = "Unroll"; break;
case multidraw_mode_t::PreferMultidrawIndirect: draw_mode_str = "Multidraw indirect"; break;
case multidraw_mode_t::DrawElements: draw_mode_str = "DrawElements"; break;
case multidraw_mode_t::Compute: draw_mode_str = "Compute"; break;
case multidraw_mode_t::Auto: draw_mode_str = "Auto"; break;
default:
draw_mode_str = "(Unknown)";
global_settings.multidraw_mode = multidraw_mode_t::Auto;
break;
}
LOG_V("[MobileGlues] Setting: enableAngle = %s", global_settings.angle ? "true" : "false")
LOG_V("[MobileGlues] Setting: ignoreError = %i", global_settings.ignore_error)
LOG_V("[MobileGlues] Setting: enableExtComputeShader = %s", global_settings.ext_compute_shader ? "true" : "false")
LOG_V("[MobileGlues] Setting: enableExtGL43 = %s", global_settings.ext_gl43 ? "true" : "false")
LOG_V("[MobileGlues] Setting: maxGlslCacheSize = %i", global_settings.max_glsl_cache_size / 1024 / 1024)
LOG_V("[MobileGlues] Setting: enableAngle = %s",
global_settings.angle == AngleMode::Enabled ? "true" : "false")
LOG_V("[MobileGlues] Setting: ignoreError = %i",
static_cast<int>(global_settings.ignore_error))
LOG_V("[MobileGlues] Setting: enableExtComputeShader = %s",
global_settings.ext_compute_shader ? "true" : "false")
LOG_V("[MobileGlues] Setting: enableExtGL43 = %s",
global_settings.ext_gl43 ? "true" : "false")
LOG_V("[MobileGlues] Setting: maxGlslCacheSize = %i",
static_cast<int>(global_settings.max_glsl_cache_size / 1024 / 1024))
LOG_V("[MobileGlues] Setting: multidrawMode = %s", draw_mode_str.c_str())
}
void init_settings_post() {
bool multidraw = g_gles_caps.GL_EXT_multi_draw_indirect;
bool basevertex =
g_gles_caps.GL_OES_draw_elements_base_vertex ||
(g_gles_caps.major == 3 && g_gles_caps.minor >= 2) || (g_gles_caps.major > 3);
bool indirect = (g_gles_caps.major == 3 && g_gles_caps.minor >= 1) || (g_gles_caps.major > 3);
bool basevertex = g_gles_caps.GL_OES_draw_elements_base_vertex ||
(g_gles_caps.major == 3 && g_gles_caps.minor >= 2) ||
(g_gles_caps.major > 3);
bool indirect = (g_gles_caps.major == 3 && g_gles_caps.minor >= 1) ||
(g_gles_caps.major > 3);
switch (global_settings.multidraw_mode) {
case multidraw_mode_t::PreferIndirect:
@ -237,4 +237,4 @@ void init_settings_post() {
}
break;
}
}
}

66
src/main/cpp/config/settings.h
View File

@ -12,33 +12,57 @@ extern "C" {
#if !defined(__APPLE__)
#include <__stddef_size_t.h>
#else
typedef unsigned long size_t;
typedef unsigned long size_t;
#endif
enum class multidraw_mode_t: int {
Auto = 0,
PreferIndirect,
PreferBaseVertex,
PreferMultidrawIndirect,
DrawElements,
Compute,
MaxValue
};
enum class multidraw_mode_t : int {
Auto = 0,
PreferIndirect,
PreferBaseVertex,
PreferMultidrawIndirect,
DrawElements,
Compute,
MaxValue
};
struct global_settings_t {
int angle; // 0, 1
int ignore_error; // 0, 1, 2
int ext_gl43; // 0, 1
int ext_compute_shader; // 0, 1
size_t max_glsl_cache_size; // 0~
multidraw_mode_t multidraw_mode; // 0, 1, 2, 3, 4
};
enum class AngleConfig : int {
DisableIfPossible = 0,
EnableIfPossible = 1,
ForceDisable = 2,
ForceEnable = 3
};
extern struct global_settings_t global_settings;
enum class AngleMode : int {
Disabled = 0,
Enabled = 1
};
void init_settings();
enum class IgnoreErrorLevel : int {
None = 0,
Partial = 1,
Full = 2
};
void init_settings_post();
enum class NoErrorConfig : int {
Auto = 0,
Disable = 1,
Level1 = 2,
Level2 = 3
};
struct global_settings_t {
AngleMode angle;
IgnoreErrorLevel ignore_error;
bool ext_gl43;
bool ext_compute_shader;
size_t max_glsl_cache_size;
multidraw_mode_t multidraw_mode;
};
extern struct global_settings_t global_settings;
void init_settings();
void init_settings_post();
#ifdef __cplusplus
}

2
src/main/cpp/gl/framebuffer.cpp
View File

@ -171,7 +171,7 @@ void glReadBuffer(GLenum src) {
GLenum glCheckFramebufferStatus(GLenum target) {
LOG()
GLenum status = GLES.glCheckFramebufferStatus(target);
if(global_settings.ignore_error >= 2 && status != GL_FRAMEBUFFER_COMPLETE) {
if(global_settings.ignore_error == IgnoreErrorLevel::Full && status != GL_FRAMEBUFFER_COMPLETE) {
LOG_W_FORCE("Framebuffer %d isn't GL_FRAMEBUFFER_COMPLETE: %d", target, status)
LOG_W_FORCE("Now try to cheat.")
return GL_FRAMEBUFFER_COMPLETE;

2
src/main/cpp/gl/program.cpp
View File

@ -116,7 +116,7 @@ void glLinkProgram(GLuint program) {
void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
LOG()
GLES.glGetProgramiv(program, pname, params);
if(global_settings.ignore_error >= 1 && (pname == GL_LINK_STATUS || pname == GL_VALIDATE_STATUS) && !*params) {
if(global_settings.ignore_error >= IgnoreErrorLevel::Partial && (pname == GL_LINK_STATUS || pname == GL_VALIDATE_STATUS) && !*params) {
GLchar infoLog[512];
GLES.glGetProgramInfoLog(program, 512, nullptr, infoLog);

2
src/main/cpp/gl/shader.cpp
View File

@ -113,7 +113,7 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, c
void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
LOG()
GLES.glGetShaderiv(shader, pname, params);
if(global_settings.ignore_error >= 1 && pname == GL_COMPILE_STATUS && !*params) {
if(global_settings.ignore_error >= IgnoreErrorLevel::Partial && pname == GL_COMPILE_STATUS && !*params) {
GLchar infoLog[512];
GLES.glGetShaderInfoLog(shader, 512, nullptr, infoLog);
LOG_W_FORCE("Shader %d compilation failed: \n%s", shader, infoLog)

2
src/main/cpp/gl/texture.cpp
View File

@ -63,7 +63,7 @@ void internal_convert(GLenum* internal_format, GLenum* type, GLenum* format) {
break;
case GL_DEPTH_COMPONENT:
LOG_D("Find GL_DEPTH_COMPONENT: internalFormat: %s, format: %s, type: %s", glEnumToString(*internal_format), glEnumToString(*format), glEnumToString(*type))
LOG_V("Find GL_DEPTH_COMPONENT: internalFormat: %s, format: %s, type: %s", glEnumToString(*internal_format), glEnumToString(*format), glEnumToString(*type))
if (type) {
switch (*type) {
case GL_UNSIGNED_SHORT:

4
src/main/cpp/gles/loader.cpp
View File

@ -91,8 +91,8 @@ void load_libs() {
static int first = 1;
if (!first) return;
first = 0;
const char *gles_override = global_settings.angle ? GLES_ANGLE : nullptr;
const char *egl_override = global_settings.angle ? EGL_ANGLE : nullptr;
const char *gles_override = global_settings.angle == AngleMode::Enabled ? GLES_ANGLE : nullptr;
const char *egl_override = global_settings.angle == AngleMode::Enabled ? EGL_ANGLE : nullptr;
gles = open_lib(gles3_lib, gles_override);
egl = open_lib(egl_lib, egl_override);
#else