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

[Refactor] (...): Optimize code.

Browse Source 
Signed-off-by: BZLZHH <admin@bzlzhh.top>
This commit is contained in:
BZLZHH 2025-02-28 13:25:26 +08:00
parent 1d1f6ad419
commit 00929e3f59
25 changed files with 507 additions and 601 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/cpp/CMakeLists.txt
View File

@ -38,6 +38,7 @@ add_library(${CMAKE_PROJECT_NAME} SHARED
gl/mg.cpp
gl/buffer.cpp
gl/getter.cpp
gl/pixel.cpp
gl/glsl/glsl_for_es.cpp
gl/glsl/cache.cpp
gl/glsl/preConvertedGlsl.cpp

68
src/main/cpp/gl/buffer.cpp
View File

@ -30,32 +30,39 @@ void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage
void* glMapBuffer(GLenum target, GLenum access) {
LOG()
LOG_D("glMapBuffer, target = %s, access = %s", glEnumToString(target), glEnumToString(access))
if(g_gles_caps.GL_OES_mapbuffer) {
LOAD_GLES_FUNC(glMapBufferOES)
return gles_glMapBufferOES(target, access);
}
if (get_binding_query(target) == 0) {
return NULL;
return nullptr;
}
GLint current_buffer;
glGetIntegerv(get_binding_query(target), &current_buffer);
LOAD_GLES_FUNC(glGetIntegerv)
LOAD_GLES_FUNC(glGetBufferParameteriv)
LOAD_GLES_FUNC(glMapBufferRange)
gles_glGetIntegerv(get_binding_query(target), &current_buffer);
if (current_buffer == 0) {
return NULL;
return nullptr;
}
if (g_active_mappings[current_buffer].mapped_ptr != NULL) {
return NULL;
if (g_active_mappings[current_buffer].mapped_ptr != nullptr) {
return nullptr;
}
GLint buffer_size;
glGetBufferParameteriv(target, GL_BUFFER_SIZE, &buffer_size);
gles_glGetBufferParameteriv(target, GL_BUFFER_SIZE, &buffer_size);
if (buffer_size <= 0 || glGetError() != GL_NO_ERROR) {
return NULL;
return nullptr;
}
GLbitfield flags = 0;
switch (access) {
case GL_READ_ONLY: flags = GL_MAP_READ_BIT; break;
case GL_WRITE_ONLY: flags = GL_MAP_WRITE_BIT; /*| GL_MAP_INVALIDATE_BUFFER_BIT*/; break;
case GL_WRITE_ONLY: flags = GL_MAP_WRITE_BIT /*| GL_MAP_INVALIDATE_BUFFER_BIT*/; break;
case GL_READ_WRITE: flags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT; break;
default:
return NULL;
return nullptr;
}
void* ptr = glMapBufferRange(target, 0, buffer_size, flags);
if (!ptr) return NULL;
void* ptr = gles_glMapBufferRange(target, 0, buffer_size, flags);
if (!ptr) return nullptr;
BufferMapping mapping;
mapping.target = target;
mapping.buffer_id = (GLuint)current_buffer;
@ -81,28 +88,6 @@ void* glMapBuffer(GLenum target, GLenum access) {
#endif
}
GLboolean force_unmap() {
if (g_active_mappings.empty())
return GL_FALSE;
LOAD_GLES(glBindBuffer, void, GLenum target, GLuint buffer)
LOAD_GLES(glUnmapBuffer, GLboolean, GLenum target);
for (auto& [buffer, binding]: g_active_mappings) {
GLint prev_buffer = 0;
GLenum binding_query = get_binding_query(binding.target);
glGetIntegerv(binding_query, &prev_buffer);
gles_glBindBuffer(binding.target, binding.buffer_id);
GLboolean result = gles_glUnmapBuffer(binding.target);
gles_glBindBuffer(binding.target, prev_buffer);
}
g_active_mappings.clear();
return GL_TRUE;
}
#if GLOBAL_DEBUG || DEBUG
#include <fstream>
#define BIN_FILE_PREFIX "/sdcard/MG/buf/"
@ -110,10 +95,14 @@ GLboolean force_unmap() {
GLboolean glUnmapBuffer(GLenum target) {
LOG()
LOAD_GLES_FUNC(glUnmapBuffer)
if(g_gles_caps.GL_OES_mapbuffer)
return gles_glUnmapBuffer(target);
GLint buffer;
GLenum binding_query = get_binding_query(target);
glGetIntegerv(binding_query, &buffer);
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(binding_query, &buffer);
if (buffer == 0)
return GL_FALSE;
@ -130,15 +119,12 @@ GLboolean glUnmapBuffer(GLenum target) {
// memset(mapping.mapped_ptr, 0xFF, mapping.size);
memcpy(mapping.mapped_ptr, mapping.client_ptr, mapping.size);
free(mapping.client_ptr);
mapping.client_ptr = NULL;
mapping.client_ptr = nullptr;
}
#endif
LOAD_GLES(glUnmapBuffer, GLboolean, GLenum target);
GLboolean result = gles_glUnmapBuffer(target);
g_active_mappings.erase(buffer);
CHECK_GL_ERROR
return result;
}
@ -146,14 +132,14 @@ GLboolean glUnmapBuffer(GLenum target) {
void glBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) {
LOG()
LOAD_GLES_FUNC(glBufferStorageEXT)
gles_glBufferStorageEXT(target,size,data,flags);
if(gles_glBufferStorageEXT)
gles_glBufferStorageEXT(target,size,data,flags);
CHECK_GL_ERROR
}
void glBindBuffer(GLenum target, GLuint buffer) {
LOG()
LOG_D("glBindBuffer, target = %s, buffer = %d", glEnumToString(target), buffer)
LOAD_GLES_FUNC(glBindBuffer)
gles_glBindBuffer(target, buffer);
}

2
src/main/cpp/gl/buffer.h
View File

@ -31,8 +31,6 @@ extern "C" {
static GLenum get_binding_query(GLenum target);
GLboolean force_unmap();
GLAPI GLAPIENTRY GLboolean glUnmapBuffer(GLenum target);
GLAPI GLAPIENTRY void *glMapBuffer(GLenum target, GLenum access);

85
src/main/cpp/gl/drawing.cpp
View File

@ -8,96 +8,91 @@
#define DEBUG 0
void glMultiDrawElementsBaseVertex( GLenum mode, GLsizei *counts, GLenum type, const void * const *indices, GLsizei primcount, const GLint * basevertex) {
LOG();
if (primcount <= 0 || !counts || !indices) return;
for (int i = 0; i < primcount; i++) {
if (counts[i] > 0)
glDrawElementsBaseVertex(mode,
counts[i],
type,
indices[i],
basevertex[i]);
void glMultiDrawElementsBaseVertex(GLenum mode, GLsizei* counts, GLenum type, const void* const* indices, GLsizei primcount, const GLint* basevertex) {
LOG()
LOAD_GLES_FUNC(glDrawElementsBaseVertex)
for (GLsizei i = 0; i < primcount; ++i) {
const GLsizei count = counts[i];
if (count > 0) {
gles_glDrawElementsBaseVertex(mode, count, type, indices[i], basevertex[i]);
}
}
}
void glMultiDrawElements(GLenum mode, const GLsizei* count, GLenum type, const void* const* indices, GLsizei primcount) {
LOG()
LOAD_GLES_FUNC(glDrawElements)
void glMultiDrawElements(GLenum mode,const GLsizei * count,GLenum type,const void * const * indices,GLsizei primcount) {
LOG();
if (primcount <= 0 || !count || !indices) return;
for (GLsizei i = 0; i < primcount; ++i) {
if (count[i] > 0) {
glDrawElements(
mode,
count[i],
type,
indices[i]
);
const GLsizei c = count[i];
if (c > 0) {
gles_glDrawElements(mode, c, type, indices[i]);
}
}
}
_Thread_local static bool unexpected_error = false; // solve the crash error for ANGLE
GLAPI GLAPIENTRY void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
LOG_D("glDrawElements, mode: %d, count: %d, type: %d, indices: %p", mode, count, type, indices);
LOAD_GLES(glDrawElements, void, GLenum, GLsizei, GLenum, const void*);
LOAD_GLES_FUNC(glGetError);
void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) {
LOG_D("glDrawElements, mode: %d, count: %d, type: %d, indices: %p", mode, count, type, indices)
LOAD_GLES_FUNC(glDrawElements)
LOAD_GLES_FUNC(glGetError)
GLenum pre_err = gles_glGetError();
if(pre_err != GL_NO_ERROR) {
LOG_D("Skipping due to prior error: 0x%04X", pre_err);
LOG_D("Skipping due to prior error: 0x%04X", pre_err)
return;
}
if (!unexpected_error) {
LOG_D("es_glDrawElements, mode: %d, count: %d, type: %d, indices: %p", mode, count, type, indices);
LOG_D("es_glDrawElements, mode: %d, count: %d, type: %d, indices: %p", mode, count, type, indices)
gles_glDrawElements(mode, count, type, indices);
} else {
unexpected_error = false;
}
}
GLAPI GLAPIENTRY void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) {
LOG_D("glBindImageTexture, unit: %d, texture: %d, level: %d, layered: %d, layer: %d, access: %d, format: %d",
unit, texture, level, layered, layer, access, format);
LOAD_GLES(glBindImageTexture, void, GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum);
LOAD_GLES_FUNC(glGetError);
unit, texture, level, layered, layer, access, format)
LOAD_GLES_FUNC(glBindImageTexture)
LOAD_GLES_FUNC(glGetError)
gles_glBindImageTexture(unit, texture, level, layered, layer, access, format);
GLenum err;
while((err = gles_glGetError()) != GL_NO_ERROR) {
LOG_D("GL Error: 0x%04X", err);
LOG_D("GL Error: 0x%04X", err)
unexpected_error = true;
}
}
GLAPI GLAPIENTRY void glUniform1i(GLint location, GLint v0) {
LOG_D("glUniform1i, location: %d, v0: %d", location, v0);
LOAD_GLES(glUniform1i, void, GLint, GLint);
LOAD_GLES_FUNC(glGetError);
void glUniform1i(GLint location, GLint v0) {
LOG_D("glUniform1i, location: %d, v0: %d", location, v0)
LOAD_GLES_FUNC(glUniform1i)
LOAD_GLES_FUNC(glGetError)
gles_glUniform1i(location, v0);
GLenum err;
while((err = gles_glGetError()) != GL_NO_ERROR) {
LOG_D("GL Error: 0x%04X", err);
LOG_D("GL Error: 0x%04X", err)
unexpected_error = true;
}
}
GLAPI GLAPIENTRY void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) {
LOG_D("glDispatchCompute, num_groups_x: %d, num_groups_y: %d, num_groups_z: %d",
num_groups_x, num_groups_y, num_groups_z);
LOAD_GLES(glDispatchCompute, void, GLuint, GLuint, GLuint);
LOAD_GLES_FUNC(glGetError);
num_groups_x, num_groups_y, num_groups_z)
LOAD_GLES_FUNC(glDispatchCompute)
LOAD_GLES_FUNC(glGetError)
GLenum pre_err = gles_glGetError();
if(pre_err != GL_NO_ERROR) {
LOG_D("Skipping due to prior error: 0x%04X", pre_err);
LOG_D("Skipping due to prior error: 0x%04X", pre_err)
return;
}
if (!unexpected_error) {
LOG_D("es_glDispatchCompute, num_groups_x: %d, num_groups_y: %d, num_groups_z: %d",
num_groups_x, num_groups_y, num_groups_z);
num_groups_x, num_groups_y, num_groups_z)
gles_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
} else {
unexpected_error = false;
}
}
}

23
src/main/cpp/gl/drawing.h
View File

@ -5,11 +5,10 @@
#ifndef MOBILEGLUES_DRAWING_H
#define MOBILEGLUES_DRAWING_H
#include <stdbool.h>
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <GLES3/gl32.h>
#include "../includes.h"
#include "gl.h"
@ -22,13 +21,17 @@
extern "C" {
#endif
GLAPI GLAPIENTRY void
glMultiDrawElementsBaseVertex(GLenum mode, GLsizei *counts, GLenum type, const void *const *indices,
GLsizei primcount, const GLint *basevertex);
GLAPI GLAPIENTRY void glMultiDrawElementsBaseVertex(GLenum mode, GLsizei *counts, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex);
GLAPI GLAPIENTRY void
glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices,
GLsizei primcount);
GLAPI GLAPIENTRY void glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount);
GLAPI GLAPIENTRY void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices);
GLAPI GLAPIENTRY void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
GLAPI GLAPIENTRY void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
GLAPI GLAPIENTRY void glUniform1i(GLint location, GLint v0);
#ifdef __cplusplus
}

11
src/main/cpp/gl/envvars.cpp
View File

@ -1,9 +1,9 @@
#include "envvars.h"
#include "glext.h"
#include "../includes.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <cstdio>
#include <cstdlib>
#include <cstdarg>
const char* GetEnvVar(const char *name)
{
@ -12,7 +12,7 @@ const char* GetEnvVar(const char *name)
int HasEnvVar(const char *name)
{
return GetEnvVar(name)!=NULL;
return GetEnvVar(name) != nullptr;
}
int ReturnEnvVarInt(const char *name)
@ -78,5 +78,4 @@ int GetEnvVarFmt(const char *name,const char *fmt,...)
va_end(args);
}
return cnt;
}
}

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

@ -14,7 +14,7 @@ GLint MAX_DRAW_BUFFERS = 0;
GLint getMaxDrawBuffers() {
if (!MAX_DRAW_BUFFERS) {
LOAD_GLES(glGetIntegerv, void, GLenum pname, GLint *params)
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(GL_MAX_DRAW_BUFFERS, &MAX_DRAW_BUFFERS);
}
return MAX_DRAW_BUFFERS;
@ -35,7 +35,7 @@ void rebind_framebuffer(GLenum old_attachment, GLenum target_attachment) {
struct attachment_t attachment = attach[old_attachment - GL_COLOR_ATTACHMENT0];
LOAD_GLES(glFramebufferTexture2D, void, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
LOAD_GLES_FUNC(glFramebufferTexture2D)
gles_glFramebufferTexture2D(bound_framebuffer->current_target, target_attachment, attachment.textarget, attachment.texture, attachment.level);
}
@ -46,7 +46,7 @@ void glBindFramebuffer(GLenum target, GLuint framebuffer) {
LOG_D("glBindFramebuffer(0x%x, %d)", target, framebuffer)
LOAD_GLES(glBindFramebuffer, void, GLenum target, GLuint framebuffer)
LOAD_GLES_FUNC(glBindFramebuffer)
gles_glBindFramebuffer(target, framebuffer);
CHECK_GL_ERROR_NO_INIT
@ -98,7 +98,7 @@ void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
bound_framebuffer->current_target = target;
}
LOAD_GLES(glFramebufferTexture2D, void, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
LOAD_GLES_FUNC(glFramebufferTexture2D)
gles_glFramebufferTexture2D(target, attachment, textarget, texture, level);
CHECK_GL_ERROR
@ -107,12 +107,13 @@ void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
void glDrawBuffer(GLenum buffer) {
LOG()
LOAD_GLES(glDrawBuffers, void, GLsizei n, const GLenum *bufs)
LOAD_GLES_FUNC(glDrawBuffers)
LOAD_GLES_FUNC(glGetIntegerv)
GLint currentFBO;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &currentFBO);
gles_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &currentFBO);
if (currentFBO == 0) { // 默认帧缓冲
if (currentFBO == 0) {
GLenum buffers[1] = {GL_NONE};
switch (buffer) {
case GL_FRONT:
@ -122,28 +123,25 @@ void glDrawBuffer(GLenum buffer) {
gles_glDrawBuffers(1, buffers);
break;
default:
// 生成错误：GL_INVALID_ENUM
break;
}
} else { // FBO场景
} else {
GLint maxAttachments;
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxAttachments);
gles_glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &maxAttachments);
if (buffer == GL_NONE) {
GLenum *buffers = (GLenum *)alloca(maxAttachments * sizeof(GLenum));
auto *buffers = (GLenum *)alloca(maxAttachments * sizeof(GLenum));
for (int i = 0; i < maxAttachments; i++) {
buffers[i] = GL_NONE;
}
gles_glDrawBuffers(maxAttachments, buffers);
} else if (buffer >= GL_COLOR_ATTACHMENT0 &&
buffer < GL_COLOR_ATTACHMENT0 + maxAttachments) {
GLenum *buffers = (GLenum *)alloca(maxAttachments * sizeof(GLenum));
auto *buffers = (GLenum *)alloca(maxAttachments * sizeof(GLenum));
for (int i = 0; i < maxAttachments; i++) {
buffers[i] = (i == (buffer - GL_COLOR_ATTACHMENT0)) ? buffer : GL_NONE;
}
gles_glDrawBuffers(maxAttachments, buffers);
} else {
// 生成错误：GL_INVALID_ENUM
}
}
}
@ -165,7 +163,7 @@ void glDrawBuffers(GLsizei n, const GLenum *bufs) {
}
}
LOAD_GLES(glDrawBuffers, void, GLsizei n, const GLenum *bufs)
LOAD_GLES_FUNC(glDrawBuffers)
gles_glDrawBuffers(n, new_bufs);
CHECK_GL_ERROR
@ -184,8 +182,8 @@ GLenum glCheckFramebufferStatus(GLenum target) {
LOAD_GLES_FUNC(glCheckFramebufferStatus)
GLenum status = gles_glCheckFramebufferStatus(target);
if(global_settings.ignore_error >= 2 && status != GL_FRAMEBUFFER_COMPLETE) {
LOG_W_FORCE("Framebuffer %d isn't GL_FRAMEBUFFER_COMPLETE: %d", target, status);
LOG_W_FORCE("Now try to cheat.");
LOG_W_FORCE("Framebuffer %d isn't GL_FRAMEBUFFER_COMPLETE: %d", target, status)
LOG_W_FORCE("Now try to cheat.")
return GL_FRAMEBUFFER_COMPLETE;
}
return status;

81
src/main/cpp/gl/getter.cpp
View File

@ -10,8 +10,8 @@
#define DEBUG 0
void glGetIntegerv(GLenum pname, GLint *params) {
LOG();
LOG_D("glGetIntegerv, pname: %s", glEnumToString(pname));
LOG()
LOG_D("glGetIntegerv, pname: %s", glEnumToString(pname))
if (pname == GL_CONTEXT_PROFILE_MASK) {
(*params) = GL_CONTEXT_CORE_PROFILE_BIT;
return;
@ -36,15 +36,15 @@ void glGetIntegerv(GLenum pname, GLint *params) {
(*params) = num_extensions;
return;
}
LOAD_GLES_FUNC(glGetIntegerv);
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(pname, params);
LOG_D(" -> %d",*params);
LOG_D(" -> %d",*params)
CHECK_GL_ERROR
}
GLenum glGetError() {
LOG();
LOAD_GLES_FUNC(glGetError);
LOG()
LOAD_GLES_FUNC(glGetError)
GLenum err = gles_glGetError();
// just clear gles error, no reporting
if (err != GL_NO_ERROR) {
@ -102,7 +102,7 @@ const char* getBeforeThirdSpace(const char* str) {
}
str++;
}
int len = str - start;
long len = str - start;
if (len >= sizeof(buffer)) len = sizeof(buffer) - 1;
strncpy(buffer, start, len);
buffer[len] = '\0';
@ -110,7 +110,7 @@ const char* getBeforeThirdSpace(const char* str) {
}
const char* getGpuName() {
LOAD_GLES_FUNC(glGetString);
LOAD_GLES_FUNC(glGetString)
const char *gpuName = (const char *) gles_glGetString(GL_RENDERER);
if (!gpuName) {
@ -141,7 +141,7 @@ const char* getGpuName() {
}
void set_es_version() {
LOAD_GLES_FUNC(glGetString);
LOAD_GLES_FUNC(glGetString)
const char* ESVersion = getBeforeThirdSpace((const char*)gles_glGetString(GL_VERSION));
int major, minor;
@ -150,15 +150,14 @@ void set_es_version() {
} else {
hardware->es_version = 300;
}
LOG_I("OpenGL ES Version: %s (%d)", ESVersion, hardware->es_version);
LOG_I("OpenGL ES Version: %s (%d)", ESVersion, hardware->es_version)
if (hardware->es_version < 300) {
LOG_I("OpenGL ES version is lower than 3.0! This version is not supported!");
LOG_I("Disable glslang and SPIRV-Cross. Using vgpu to process all shaders!");
LOG_I("OpenGL ES version is lower than 3.0! This version is not supported!")
}
}
const char* getGLESName() {
LOAD_GLES_FUNC(glGetString);
LOAD_GLES_FUNC(glGetString)
char* ESVersion = (char*)gles_glGetString(GL_VERSION);
return getBeforeThirdSpace(ESVersion);
}
@ -166,8 +165,8 @@ const char* getGLESName() {
static std::string rendererString;
static std::string versionString;
const GLubyte * glGetString( GLenum name ) {
LOG();
LOAD_GLES_FUNC(glGetString);
LOG()
LOAD_GLES_FUNC(glGetString)
/* Feature in the Future
* Advanced OpenGL driver: NV renderer.
switch (name) {
@ -184,23 +183,37 @@ const GLubyte * glGetString( GLenum name ) {
}
*/
switch (name) {
case GL_VENDOR:
return (const GLubyte *)(std::string("Swung0x48, BZLZHH, Tungsten") +
std::string(version_type == VERSION_ALPHA ? " | §c§l内测版本, 严禁任何外传!§r" : "")).c_str();
case GL_VERSION:
if (versionString == std::string("")) {
versionString = "4.0.0 MobileGlues";
std::string realVersion = " " + std::to_string(MAJOR) + "." +
std::to_string(MINOR) + "." +
std::to_string(REVISION);
if (PATCH) {
realVersion += "." + std::to_string(PATCH);
}
std::string suffix = realVersion + (version_type == VERSION_ALPHA ? " | §4§l如果您在公开平台看到这一提示, 则发布者已违规!§r" :
std::string(version_type == VERSION_DEVELOPMENT?".Dev":""));
versionString += suffix;
case GL_VENDOR: {
if(versionString.empty()) {
std::string vendor = "Swung0x48, BZLZHH, Tungsten";
#if defined(VERSION_TYPE) && (VERSION_TYPE == VERSION_ALPHA)
vendor += " | §c§l内测版本, 严禁任何外传!§r";
#endif
versionString = vendor;
}
return (const GLubyte *)versionString.c_str();
}
case GL_VERSION: {
static std::string versionCache;
if (versionCache.empty()) {
versionCache = "4.0.0 MobileGlues ";
versionCache += std::to_string(MAJOR) + "."
+ std::to_string(MINOR) + "."
+ std::to_string(REVISION);
#if PATCH != 0
versionCache += "." + std::to_string(PATCH);
#endif
#if defined(VERSION_TYPE)
#if VERSION_TYPE == VERSION_ALPHA
versionCache += " | §4§l如果您在公开平台看到这一提示, 则发布者已违规!§r";
#elif VERSION_TYPE == VERSION_DEVELOPMENT
versionCache += ".Dev";
#endif
#endif
}
return (const GLubyte *)versionCache.c_str();
}
case GL_RENDERER:
{
if (rendererString == std::string("")) {
@ -220,8 +233,8 @@ const GLubyte * glGetString( GLenum name ) {
}
const GLubyte * glGetStringi(GLenum name, GLuint index) {
LOG();
LOAD_GLES_FUNC(glGetStringi);
LOG()
LOAD_GLES_FUNC(glGetStringi)
typedef struct {
GLenum name;
const char** parts;
@ -288,13 +301,13 @@ const GLubyte * glGetStringi(GLenum name, GLuint index) {
void glGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
LOG()
LOAD_GLES_FUNC(glGetQueryObjectivEXT)
gles_glGetQueryObjectivEXT(id, pname, params);
CHECK_GL_ERROR
}
void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
LOG()
LOAD_GLES_FUNC(glGetQueryObjecti64vEXT)
gles_glGetQueryObjecti64vEXT(id, pname, params);
CHECK_GL_ERROR
}

10
src/main/cpp/gl/gl.cpp
View File

@ -11,12 +11,14 @@
#define DEBUG 0
GLAPI GLAPIENTRY void glClearDepth(GLclampd depth) {
LOG();
glClearDepthf(depth);
void glClearDepth(GLclampd depth) {
LOG()
LOAD_GLES_FUNC(glClearDepthf)
gles_glClearDepthf((float)depth);
CHECK_GL_ERROR
}
void glHint(GLenum target, GLenum mode) {
LOG();
LOG()
LOG_D("glHint, target = %s, mode = %s", glEnumToString(target), glEnumToString(mode))
}

6
src/main/cpp/gl/glsl/cache.cpp
View File

@ -164,7 +164,7 @@ bool Cache::load() {
file.read(reinterpret_cast<char*>(&esslSize), sizeof(esslSize));
string essl(esslSize, '\0');
file.read(essl.data(), esslSize);
file.read(essl.data(), (long)esslSize);
if (cacheMap.count(hash)) continue;
@ -190,9 +190,9 @@ void Cache::save() {
file.write(reinterpret_cast<const char*>(&count), sizeof(count));
for (const auto& entry : cacheList) {
file.write(reinterpret_cast<const char*>(entry.sha256.data()), entry.sha256.size());
file.write(reinterpret_cast<const char*>(entry.sha256.data()), (long)entry.sha256.size());
size_t esslSize = entry.size;
file.write(reinterpret_cast<const char*>(&esslSize), sizeof(esslSize));
file.write(entry.essl.data(), esslSize);
file.write(entry.essl.data(), (long)esslSize);
}
}

2
src/main/cpp/gl/glsl/cache.h
View File

@ -39,7 +39,7 @@ private:
std::unordered_map<std::array<uint8_t, 32>, ListIterator, SHA256Hash> cacheMap;
size_t cacheSize = 0;
std::array<uint8_t, 32> computeSHA256(const char* data);
static std::array<uint8_t, 32> computeSHA256(const char* data);
void maintainCacheSize();
};

134
src/main/cpp/gl/glsl/glsl_for_es.cpp
View File

@ -20,11 +20,26 @@
char* (*MesaConvertShader)(const char *src, unsigned int type, unsigned int glsl, unsigned int essl);
typedef std::vector<uint32_t> Spirv;
void trim(char* str) {
char* end;
while (isspace((unsigned char)*str)) str++;
if (*str == 0) return;
end = str + strlen(str) - 1;
while (end > str && isspace((unsigned char)*end)) end--;
*(end + 1) = 0;
}
int startsWith(const char *str, const char *prefix) {
if (!str || !prefix) return 0;
while (*prefix) {
if (*str++ != *prefix++) return 0;
}
return 1;
}
static TBuiltInResource InitResources()
{
TBuiltInResource Resources;
TBuiltInResource Resources{};
Resources.maxLights = 32;
Resources.maxClipPlanes = 6;
@ -119,15 +134,15 @@ static TBuiltInResource InitResources()
Resources.maxTaskWorkGroupSizeZ_NV = 1;
Resources.maxMeshViewCountNV = 4;
Resources.limits.nonInductiveForLoops = 1;
Resources.limits.whileLoops = 1;
Resources.limits.doWhileLoops = 1;
Resources.limits.generalUniformIndexing = 1;
Resources.limits.generalAttributeMatrixVectorIndexing = 1;
Resources.limits.generalVaryingIndexing = 1;
Resources.limits.generalSamplerIndexing = 1;
Resources.limits.generalVariableIndexing = 1;
Resources.limits.generalConstantMatrixVectorIndexing = 1;
Resources.limits.nonInductiveForLoops = true;
Resources.limits.whileLoops = true;
Resources.limits.doWhileLoops = true;
Resources.limits.generalUniformIndexing = true;
Resources.limits.generalAttributeMatrixVectorIndexing = true;
Resources.limits.generalVaryingIndexing = true;
Resources.limits.generalSamplerIndexing = true;
Resources.limits.generalVariableIndexing = true;
Resources.limits.generalConstantMatrixVectorIndexing = true;
return Resources;
}
@ -248,8 +263,8 @@ vec4 GI_TemporalFilter() {
)";
char *mainPos = strstr(glslCode, "\nvoid main()");
if (mainPos == NULL) {
LOG_E("Error: 'void main()' not found in GLSL code.");
if (mainPos == nullptr) {
LOG_E("Error: 'void main()' not found in GLSL code.")
return glslCode;
}
@ -258,8 +273,8 @@ vec4 GI_TemporalFilter() {
size_t insertLength = strlen(GI_TemporalFilter);
char *modifiedCode = (char *)malloc(originalLength + insertLength + 2);
if (modifiedCode == NULL) {
LOG_E("Memory allocation failed.");
if (modifiedCode == nullptr) {
LOG_E("Memory allocation failed.")
return glslCode;
}
@ -320,7 +335,7 @@ std::string removeLayoutBinding(const std::string& glslCode) {
}
// TODO
std::string makeRGBWriteonly(const std::string& input) {
[[maybe_unused]] std::string makeRGBWriteonly(const std::string& input) {
std::regex pattern(R"(.*layout\([^)]*rgba[^)]*\).*?)");
std::string result;
std::string::size_type start = 0;
@ -344,18 +359,12 @@ std::string makeRGBWriteonly(const std::string& input) {
return result;
}
std::string removeLocationBinding(const std::string& glslCode) {
std::regex locationRegex(R"(layout\s*\(\s*location\s*=\s*\d+\s*\)\s*)");
std::string result = std::regex_replace(glslCode, locationRegex, "");
return result;
}
char* removeLineDirective(char* glslCode) {
char* cursor = glslCode;
int modifiedCodeIndex = 0;
size_t maxLength = 1024 * 10;
char* modifiedGlslCode = (char*)malloc(maxLength * sizeof(char));
if (!modifiedGlslCode) return NULL;
if (!modifiedGlslCode) return nullptr;
while (*cursor) {
if (strncmp(cursor, "\n#", 2) == 0) {
@ -409,7 +418,7 @@ char* removeLineDirective(char* glslCode) {
if (modifiedCodeIndex >= maxLength - 1) {
maxLength *= 2;
modifiedGlslCode = (char*)realloc(modifiedGlslCode, maxLength);
if (!modifiedGlslCode) return NULL;
if (!modifiedGlslCode) return nullptr;
}
}
@ -417,42 +426,6 @@ char* removeLineDirective(char* glslCode) {
return modifiedGlslCode;
}
std::string replaceText(const std::string& input, const std::string& from, const std::string& to) {
std::string result = input;
size_t pos = 0;
while ((pos = result.find(from, pos)) != std::string::npos) {
result.replace(pos, from.length(), to);
pos += to.length();
}
return result;
}
std::string addPrecisionToSampler2DShadow(const std::string& glslCode) {
std::string result = glslCode;
result = replaceText(result, " sampler2DShadow ", " highp sampler2DShadow ");
result = replaceText(result, " mediump highp ", " mediump ");
result = replaceText(result, " lowp highp ", " lowp ");
result = replaceText(result, " highp highp ", " highp ");
return result;
}
void trim(char* str) {
char* end;
while (isspace((unsigned char)*str)) str++;
if (*str == 0) return;
end = str + strlen(str) - 1;
while (end > str && isspace((unsigned char)*end)) end--;
*(end + 1) = 0;
}
int startsWith(const char *str, const char *prefix) {
if (!str || !prefix) return 0;
while (*prefix) {
if (*str++ != *prefix++) return 0;
}
return 1;
}
char* process_uniform_declarations(char* glslCode) {
char* cursor = glslCode;
char name[256], type[256], initial_value[1024];
@ -539,7 +512,7 @@ char* process_uniform_declarations(char* glslCode) {
char* cursor_end = cursor;
int spaceLeft = maxLength - modifiedCodeIndex;
size_t spaceLeft = maxLength - modifiedCodeIndex;
int len = 0;
if (*initial_value) {
@ -633,7 +606,7 @@ char* GLSLtoGLSLES_2(char* glsl_code, GLenum glsl_type, uint essl_version) {
shader_language = EShLanguage::EShLangGeometry;
break;
default:
LOG_D("GLSL type not supported!");
LOG_D("GLSL type not supported!")
return nullptr;
}
@ -653,7 +626,7 @@ char* GLSLtoGLSLES_2(char* glsl_code, GLenum glsl_type, uint essl_version) {
std::strcpy(shader_source, shader_str.c_str());
}
LOG_D("GLSL version: %d",glsl_version);
LOG_D("GLSL version: %d",glsl_version)
shader.setStrings(&shader_source, 1);
@ -667,22 +640,22 @@ char* GLSLtoGLSLES_2(char* glsl_code, GLenum glsl_type, uint essl_version) {
TBuiltInResource TBuiltInResource_resources = InitResources();
if (!shader.parse(&TBuiltInResource_resources, glsl_version, true, EShMsgDefault)) {
LOG_D("GLSL Compiling ERROR: \n%s",shader.getInfoLog());
return NULL;
LOG_D("GLSL Compiling ERROR: \n%s",shader.getInfoLog())
return nullptr;
}
LOG_D("GLSL Compiled.");
LOG_D("GLSL Compiled.")
glslang::TProgram program;
program.addShader(&shader);
if (!program.link(EShMsgDefault)) {
LOG_D("Shader Linking ERROR: %s",program.getInfoLog());
LOG_D("Shader Linking ERROR: %s",program.getInfoLog())
return nullptr;
}
LOG_D("Shader Linked." );
LOG_D("Shader Linked." )
std::vector<unsigned int> spirv_code;
glslang::SpvOptions spvOptions;
spvOptions.disableOptimizer = true;
spvOptions.disableOptimizer = false;
glslang::GlslangToSpv(*program.getIntermediate(shader_language), spirv_code, &spvOptions);
std::string essl;
@ -690,17 +663,16 @@ char* GLSLtoGLSLES_2(char* glsl_code, GLenum glsl_type, uint essl_version) {
const SpvId *spirv = spirv_code.data();
size_t word_count = spirv_code.size();
spvc_context context = NULL;
spvc_parsed_ir ir = NULL;
spvc_compiler compiler_glsl = NULL;
spvc_compiler_options options = NULL;
spvc_resources resources = NULL;
const spvc_reflected_resource *list = NULL;
const char *result = NULL;
spvc_context context = nullptr;
spvc_parsed_ir ir = nullptr;
spvc_compiler compiler_glsl = nullptr;
spvc_compiler_options options = nullptr;
spvc_resources resources = nullptr;
const spvc_reflected_resource *list = nullptr;
const char *result = nullptr;
size_t count;
size_t i;
LOG_D("spirv_code.size(): %d",spirv_code.size() );
LOG_D("spirv_code.size(): %d",spirv_code.size())
spvc_context_create(&context);
spvc_context_parse_spirv(context, spirv, word_count, &ir);
spvc_context_create_compiler(context, SPVC_BACKEND_GLSL, ir, SPVC_CAPTURE_MODE_TAKE_OWNERSHIP, &compiler_glsl);
@ -711,17 +683,15 @@ char* GLSLtoGLSLES_2(char* glsl_code, GLenum glsl_type, uint essl_version) {
spvc_compiler_options_set_bool(options, SPVC_COMPILER_OPTION_GLSL_ES, SPVC_TRUE);
spvc_compiler_install_compiler_options(compiler_glsl, options);
spvc_compiler_compile(compiler_glsl, &result);
LOG_D("Shader Linked.4" );
if (!result) {
LOG_D("Error: unexpected error in spirv-cross.");
LOG_D("Error: unexpected error in spirv-cross.")
return glsl_code;
}
essl=result;
spvc_context_destroy(context);
essl = removeLayoutBinding(essl);
//essl = removeLocationBinding(essl);
//essl = addPrecisionToSampler2DShadow(essl);
essl = forceSupporterOutput(essl);
//essl = makeRGBWriteonly(essl);

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

@ -11,7 +11,7 @@
const char* glEnumToString(GLenum e) {
static char str[128];
switch (e) {
/* Boolean values */
/* Boolean values */
/* Data types */
CASE(GL_BYTE)

2
src/main/cpp/gl/log.h
View File

@ -6,6 +6,8 @@
#include "mg.h"
#define FORCE_SYNC_WITH_LOG_FILE 0
#define GLOBAL_DEBUG 0
#ifdef __cplusplus

21
src/main/cpp/gl/mg.cpp
View File

@ -21,7 +21,7 @@ void start_log() {
}
void write_log(const char* format, ...) {
if (file == NULL) {
if (file == nullptr) {
return;
}
va_list args;
@ -29,16 +29,18 @@ void write_log(const char* format, ...) {
vfprintf(file, format, args);
va_end(args);
fprintf(file, "\n");
#if FORCE_SYNC_WITH_LOG_FILE == 1
fflush(file);
// int fd = fileno(file);
// fsync(fd);
int fd = fileno(file);
fsync(fd);
#endif
// Todo: close file
//fclose(file);
}
void clear_log() {
file = fopen(LOG_FILE_PATH, "w");
if (file == NULL) {
if (file == nullptr) {
return;
}
fclose(file);
@ -58,13 +60,14 @@ GLenum map_tex_target(GLenum target) {
case GL_TEXTURE_1D:
case GL_TEXTURE_3D:
case GL_TEXTURE_RECTANGLE_ARB:
target = GL_TEXTURE_2D;
break;
return GL_TEXTURE_2D;
case GL_PROXY_TEXTURE_1D:
case GL_PROXY_TEXTURE_3D:
case GL_PROXY_TEXTURE_RECTANGLE_ARB:
target = GL_PROXY_TEXTURE_2D;
break;
return GL_PROXY_TEXTURE_2D;
default:
return target;
}
return target;
}

4
src/main/cpp/gl/mg.h
View File

@ -5,9 +5,9 @@
#ifndef MOBILEGLUES_MG_H
#define MOBILEGLUES_MG_H
#include <string.h>
#include <cstring>
#include <malloc.h>
#include <stdlib.h>
#include <cstdlib>
#include <android/log.h>
#include "gl.h"

63
src/main/cpp/gl/pixel.cpp
View File

@ -6,7 +6,7 @@
#define DEBUG 0
const GLsizei gl_sizeof(GLenum type) {
GLsizei gl_sizeof(GLenum type) {
// types
switch (type) {
case GL_DOUBLE:
@ -44,13 +44,13 @@ const GLsizei gl_sizeof(GLenum type) {
case GL_DEPTH_COMPONENT:
case GL_COLOR_INDEX:
return 1;
default:
LOG_D("Unsupported pixel data type: %s\n", glEnumToString(type))
return 0;
}
// formats
LOG_D("Unsupported pixel data type: %s\n", glEnumToString(type));
return 0;
}
const GLboolean is_type_packed(GLenum type) {
GLboolean is_type_packed(GLenum type) {
switch (type) {
case GL_4_BYTES:
case GL_3_BYTES:
@ -69,11 +69,12 @@ const GLboolean is_type_packed(GLenum type) {
case GL_UNSIGNED_SHORT_5_6_5_REV:
case GL_DEPTH_STENCIL:
return true;
default:
return false;
}
return false;
}
const GLsizei pixel_sizeof(GLenum format, GLenum type) {
GLsizei pixel_sizeof(GLenum format, GLenum type) {
GLsizei width = 0;
switch (format) {
case GL_R:
@ -102,7 +103,7 @@ const GLsizei pixel_sizeof(GLenum format, GLenum type) {
width = 4;
break;
default:
LOG_D("unsupported pixel format %s\n", glEnumToString(format));
LOG_D("unsupported pixel format %s\n", glEnumToString(format))
return 0;
}
@ -118,20 +119,20 @@ static const colorlayout_t *get_color_map(GLenum format) {
static colorlayout_t layout = {fmt, __VA_ARGS__}; \
return &layout; }
switch (format) {
map(GL_RED, 0, -1, -1, -1, 0);
map(GL_R, 0, -1, -1, -1, 0);
map(GL_RG, 0, 1, -1, -1, 0);
map(GL_RGBA,0, 1, 2, 3, 3);
map(GL_RGB, 0, 1, 2, -1, 2);
map(GL_BGRA,2, 1, 0, 3, 3);
map(GL_BGR, 2, 1, 0, -1, 2);
map(GL_LUMINANCE_ALPHA, 0, 0, 0, 1, 1);
map(GL_LUMINANCE, 0, 0, 0, -1, 0);
map(GL_ALPHA,-1, -1, -1, 0, 0);
map(GL_DEPTH_COMPONENT, 0, -1, -1, -1, 0);
map(GL_COLOR_INDEX, 0, 1, 2, 3, 3);
map(GL_RED, 0, -1, -1, -1, 0)
map(GL_R, 0, -1, -1, -1, 0)
map(GL_RG, 0, 1, -1, -1, 0)
map(GL_RGBA,0, 1, 2, 3, 3)
map(GL_RGB, 0, 1, 2, -1, 2)
map(GL_BGRA,2, 1, 0, 3, 3)
map(GL_BGR, 2, 1, 0, -1, 2)
map(GL_LUMINANCE_ALPHA, 0, 0, 0, 1, 1)
map(GL_LUMINANCE, 0, 0, 0, -1, 0)
map(GL_ALPHA,-1, -1, -1, 0, 0)
map(GL_DEPTH_COMPONENT, 0, -1, -1, -1, 0)
map(GL_COLOR_INDEX, 0, 1, 2, 3, 3)
default:
LOG_D("get_color_map: unknown pixel format %s\n", glEnumToString(format));
LOG_D("get_color_map: unknown pixel format %s\n", glEnumToString(format))
break;
}
static colorlayout_t null = {0};
@ -159,10 +160,10 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
if (*dst == src)
return true;
if (!dst_size || !pixel_sizeof(src_format, src_type)) {
LOG_D("pixel_convert: pixel conversion, unknown format size, anticipated abort\n");
LOG_D("pixel_convert: pixel conversion, unknown format size, anticipated abort\n")
return false;
}
if (*dst == NULL) // alloc dst only if dst==NULL
if (*dst == nullptr) // alloc dst only if dst==NULL
*dst = malloc(dst_size);
if (stride) // for in-place conversion
for (int yy=0; yy<height; yy++)
@ -175,12 +176,12 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
dst_color = get_color_map(dst_format);
if (!dst_size || !pixel_sizeof(src_format, src_type)
|| !src_color->type || !dst_color->type) {
LOG_D("pixel_convert: pixel conversion, anticipated abort\n");
LOG_D("pixel_convert: pixel conversion, anticipated abort\n")
return false;
}
GLsizei src_stride = pixel_sizeof(src_format, src_type);
GLsizei dst_stride = pixel_sizeof(dst_format, dst_type);
if (*dst == src || *dst == NULL)
if (*dst == src || *dst == nullptr)
*dst = malloc(dst_size);
uintptr_t src_pos = widthalign((uintptr_t)src, align);
uintptr_t dst_pos = widthalign((uintptr_t)*dst, align);
@ -261,7 +262,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_dst = (unsigned char*)dst_pos;
auto* byte_dst = (unsigned char*)dst_pos;
#ifdef __BIG_ENDIAN__
byte_dst[1] = byte_dst[2] = byte_dst[3] = *(GLubyte*)src_pos;
byte_dst[0] = 255;
@ -282,7 +283,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_dst = (unsigned char*)dst_pos;
auto* byte_dst = (unsigned char*)dst_pos;
byte_dst[0] = byte_dst[1] = byte_dst[2] = *(GLubyte*)src_pos;
src_pos += src_stride;
dst_pos += dst_stride;
@ -297,7 +298,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_src = (unsigned char*)src_pos;
auto* byte_src = (unsigned char*)src_pos;
#ifdef __BIG_ENDIAN__
*(GLushort*)dst_pos = ((((int)byte_src[3])*77 + ((int)byte_src[2])*151 + ((int)byte_src[1])*28)&0xff00)>>8 | (byte_src[0]<<8);
#else
@ -316,7 +317,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_src = (unsigned char*)src_pos;
auto* byte_src = (unsigned char*)src_pos;
#ifdef __BIG_ENDIAN__
*(GLushort*)dst_pos = ((((int)byte_src[1])*77 + ((int)byte_src[2])*151 + ((int)byte_src[3])*28)&0xff00)>>8 | (byte_src[0]<<8);
#else
@ -335,7 +336,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_src = (unsigned char*)src_pos;
auto* byte_src = (unsigned char*)src_pos;
#ifdef __BIG_ENDIAN__
*(unsigned char*)dst_pos = (((int)byte_src[3])*77 + ((int)byte_src[2])*151 + ((int)byte_src[1])*28)>>8;
#else
@ -354,7 +355,7 @@ bool pixel_convert(const GLvoid *src, GLvoid **dst,
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
//tmp = *(const GLuint*)src_pos;
unsigned char* byte_src = (unsigned char*)src_pos;
auto* byte_src = (unsigned char*)src_pos;
#ifdef __BIG_ENDIAN__
*(unsigned char*)dst_pos = (((int)byte_src[1])*77 + ((int)byte_src[2])*151 + ((int)byte_src[3])*28)>>8;
#else

6
src/main/cpp/gl/pixel.h
View File

@ -29,11 +29,11 @@ typedef struct {
#define widthalign(width, align) ((((uintptr_t)(width))+((uintptr_t)(align)-1))&(~((uintptr_t)(align)-1)))
const GLsizei gl_sizeof(GLenum type);
GLsizei gl_sizeof(GLenum type);
const GLsizei pixel_sizeof(GLenum format, GLenum type);
GLsizei pixel_sizeof(GLenum format, GLenum type);
const GLboolean is_type_packed(GLenum type);
GLboolean is_type_packed(GLenum type);
bool pixel_convert(const GLvoid *src, GLvoid **dst,
GLuint width, GLuint height,

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

@ -19,28 +19,28 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
// } else {
// LOG_W("Warning: No GL_EXT_blend_func_extended, skipping glBindFragDataLocation...");
// }
char* origin_glsl = NULL;
char* origin_glsl = nullptr;
if (shaderInfo.frag_data_changed) {
size_t glslLen = strlen(shaderInfo.frag_data_changed_converted) + 1;
origin_glsl = (char *)malloc(glslLen);
if (origin_glsl == NULL) {
LOG_E("Memory reallocation failed for frag_data_changed_converted\n");
if (origin_glsl == nullptr) {
LOG_E("Memory reallocation failed for frag_data_changed_converted\n")
return;
}
strcpy(origin_glsl, shaderInfo.frag_data_changed_converted);
} else {
size_t glslLen = strlen(shaderInfo.converted) + 1;
origin_glsl = (char *)malloc(glslLen);
if (origin_glsl == NULL) {
LOG_E("Memory reallocation failed for converted\n");
if (origin_glsl == nullptr) {
LOG_E("Memory reallocation failed for converted\n")
return;
}
strcpy(origin_glsl, shaderInfo.converted);
}
int len = strlen(name);
int tlen = len + 32;
size_t len = strlen(name);
size_t tlen = len + 32;
char *targetPattern = (char*)malloc(sizeof(char) * tlen);
if (!targetPattern) {
LOG_E("Memory allocation failed for targetPattern")
@ -49,10 +49,10 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
sprintf(targetPattern, "out[ ]+[A-Za-z0-9 ]+[ ]+%s", name);
regex_t regex;
regmatch_t pmatch[1];
char *origin = NULL;
char *result = NULL;
char *origin = nullptr;
char *result = nullptr;
if (regcomp(&regex, targetPattern, REG_EXTENDED) != 0) {
LOG_E("Failed to compile regex\n");
LOG_E("Failed to compile regex\n")
return;
}
char *searchStart = origin_glsl;
@ -60,17 +60,17 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
size_t matchLen = pmatch[0].rm_eo - pmatch[0].rm_so;
origin = (char *) malloc(matchLen + 1);
if (!origin) {
LOG_E("Memory allocation failed\n");
LOG_E("Memory allocation failed\n")
break;
}
strncpy(origin, searchStart + pmatch[0].rm_so, matchLen);
origin[matchLen] = '\0';
size_t resultLen =
strlen(origin) + 30; // "layout (location = )" + colorNumber + null terminator
strlen(origin) + 30; // "layout (location = )" + colorNumber + nullptr terminator
result = (char *) malloc(resultLen);
if (!result) {
LOG_E("Memory allocation failed\n");
LOG_E("Memory allocation failed\n")
free(origin);
break;
}
@ -84,7 +84,7 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
char *newConverted = (char *) malloc(newLen);
if (!newConverted) {
LOG_E("Memory allocation failed\n");
LOG_E("Memory allocation failed\n")
free(origin);
free(result);
break;
@ -98,8 +98,8 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
size_t newLen_2 = strlen(newConverted) + 1;
shaderInfo.frag_data_changed_converted = (char *) realloc(
shaderInfo.frag_data_changed_converted, newLen_2);
if (shaderInfo.frag_data_changed_converted == NULL) {
LOG_E("Memory reallocation failed for frag_data_changed_converted\n");
if (shaderInfo.frag_data_changed_converted == nullptr) {
LOG_E("Memory reallocation failed for frag_data_changed_converted\n")
return;
}
strcpy(shaderInfo.frag_data_changed_converted, newConverted);
@ -123,19 +123,19 @@ void glLinkProgram(GLuint program) {
LOG_D("glLinkProgram(%d)", program)
if (shaderInfo.converted && shaderInfo.frag_data_changed) {
LOAD_GLES(glShaderSource, void, GLuint shader, GLsizei count, const GLchar *const* string, const GLint *length)
LOAD_GLES(glCompileShader, void, GLuint shader)
LOAD_GLES(glDetachShader, void, GLuint program, GLuint shader)
LOAD_GLES(glAttachShader, void, GLuint program, GLuint shader)
gles_glShaderSource(shaderInfo.id, 1, (const GLchar * const*) &shaderInfo.frag_data_changed_converted, NULL);
LOAD_GLES_FUNC(glShaderSource)
LOAD_GLES_FUNC(glCompileShader)
LOAD_GLES_FUNC(glDetachShader)
LOAD_GLES_FUNC(glAttachShader)
gles_glShaderSource(shaderInfo.id, 1, (const GLchar * const*) &shaderInfo.frag_data_changed_converted, nullptr);
gles_glCompileShader(shaderInfo.id);
LOAD_GLES(glGetShaderiv, void, GLuint shader, GLenum pname, GLint *params)
LOAD_GLES_FUNC(glGetShaderiv)
GLint status = 0;
gles_glGetShaderiv(shaderInfo.id, GL_COMPILE_STATUS, &status);
if(status!=GL_TRUE) {
char tmp[500];
LOAD_GLES(glGetShaderInfoLog, void, GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
gles_glGetShaderInfoLog(shaderInfo.id, 500, NULL, tmp);
LOAD_GLES_FUNC(glGetShaderInfoLog)
gles_glGetShaderInfoLog(shaderInfo.id, 500, nullptr, tmp);
LOG_E("Failed to compile patched shader, log:\n%s", tmp)
}
gles_glDetachShader(program, shaderInfo.id);
@ -143,10 +143,10 @@ void glLinkProgram(GLuint program) {
CHECK_GL_ERROR
}
shaderInfo.id = 0;
shaderInfo.converted = NULL;
shaderInfo.frag_data_changed_converted = NULL;
shaderInfo.converted = nullptr;
shaderInfo.frag_data_changed_converted = nullptr;
shaderInfo.frag_data_changed = 0;
LOAD_GLES(glLinkProgram, void, GLuint program)
LOAD_GLES_FUNC(glLinkProgram)
gles_glLinkProgram(program);
CHECK_GL_ERROR
@ -159,9 +159,9 @@ void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
if(global_settings.ignore_error >= 1 && (pname == GL_LINK_STATUS || pname == GL_VALIDATE_STATUS) && !*params) {
GLchar infoLog[512];
LOAD_GLES_FUNC(glGetShaderInfoLog)
gles_glGetShaderInfoLog(program, 512, NULL, infoLog);
LOG_W_FORCE("Program %d linking failed: \n%s", program, infoLog);
LOG_W_FORCE("Now try to cheat.");
gles_glGetShaderInfoLog(program, 512, nullptr, infoLog);
LOG_W_FORCE("Program %d linking failed: \n%s", program, infoLog)
LOG_W_FORCE("Now try to cheat.")
*params = GL_TRUE;
}
CHECK_GL_ERROR

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

@ -2,7 +2,7 @@
// Created by BZLZHH on 2025/1/26.
//
#include <ctype.h>
#include <cctype>
#include "shader.h"
#include "gl.h"
@ -34,7 +34,6 @@ bool can_run_essl3(unsigned int esversion, const char *glsl) {
return esversion >= glsl_version;
}
bool is_direct_shader(char *glsl)
{
bool es3_ability = can_run_essl3(hardware->es_version, glsl);
@ -42,14 +41,14 @@ bool is_direct_shader(char *glsl)
}
void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, const GLint *length) {
LOG();
LOG()
shaderInfo.id = 0;
shaderInfo.converted = NULL;
shaderInfo.converted = nullptr;
shaderInfo.frag_data_changed = 0;
int l = 0;
size_t l = 0;
for (int i=0; i<count; i++) l+=(length && length[i] >= 0)?length[i]:strlen(string[i]);
char* source = NULL;
char* converted = NULL;
char* source = nullptr;
char* converted = nullptr;
source = (char*)malloc(l+1);
memset(source, 0, l+1);
if(length) {
@ -63,29 +62,30 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, c
for (int i=0; i<count; i++)
strcat(source, string[i]);
}
LOAD_GLES2(glShaderSource, void, GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
LOAD_GLES_FUNC(glShaderSource)
if (gles_glShaderSource) {
if(is_direct_shader(source)){
LOG_D("[INFO] [Shader] Direct shader source: ");
LOG_D("%s", source);
LOG_D("[INFO] [Shader] Direct shader source: ")
LOG_D("%s", source)
converted = strdup(source);
} else {
int glsl_version = getGLSLVersion(source);
LOG_D("[INFO] [Shader] Shader source: ");
LOG_D("%s", source);
LOG_D("[INFO] [Shader] Shader source: ")
LOG_D("%s", source)
GLint shaderType;
glGetShaderiv(shader, GL_SHADER_TYPE, &shaderType);
LOAD_GLES_FUNC(glGetShaderiv)
gles_glGetShaderiv(shader, GL_SHADER_TYPE, &shaderType);
converted = GLSLtoGLSLES(source, shaderType, hardware->es_version, glsl_version);
if (!converted) {
LOG_E("Failed to convert shader %d.", shader);
LOG_E("Failed to convert shader %d.", shader)
return;
}
LOG_D("\n[INFO] [Shader] Converted Shader source: \n%s", converted);
LOG_D("\n[INFO] [Shader] Converted Shader source: \n%s", converted)
}
if (converted) {
shaderInfo.id = shader;
shaderInfo.converted = converted;
gles_glShaderSource(shader, count, (const GLchar * const*)&converted, NULL);
gles_glShaderSource(shader, count, (const GLchar * const*)&converted, nullptr);
}
else
LOG_E("Failed to convert glsl.")
@ -97,14 +97,14 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, c
void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
LOG()
LOAD_GLES_FUNC(glGetShaderiv);
LOAD_GLES_FUNC(glGetShaderiv)
gles_glGetShaderiv(shader, pname, params);
if(global_settings.ignore_error >= 1 && pname == GL_COMPILE_STATUS && !*params) {
GLchar infoLog[512];
LOAD_GLES_FUNC(glGetShaderInfoLog);
gles_glGetShaderInfoLog(shader, 512, NULL, infoLog);
LOG_W_FORCE("Shader %d compilation failed: \n%s", shader, infoLog);
LOG_W_FORCE("Now try to cheat.");
LOAD_GLES_FUNC(glGetShaderInfoLog)
gles_glGetShaderInfoLog(shader, 512, nullptr, infoLog);
LOG_W_FORCE("Shader %d compilation failed: \n%s", shader, infoLog)
LOG_W_FORCE("Now try to cheat.")
*params = GL_TRUE;
}
CHECK_GL_ERROR

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

@ -37,8 +37,8 @@ std::unordered_map<GLuint, texture_t> g_textures;
GLuint bound_texture = 0;
bool check_rgba16() {
LOAD_GLES(glGetStringi, const GLubyte *, GLenum, GLuint);
LOAD_GLES(glGetIntegerv, void, GLenum pname, GLint *params);
LOAD_GLES_FUNC(glGetStringi)
LOAD_GLES_FUNC(glGetIntegerv)
GLint numFormats = 0;
gles_glGetIntegerv(GL_NUM_EXTENSIONS, &numFormats);
@ -245,61 +245,61 @@ void internal_convert(GLenum* internal_format, GLenum* type, GLenum* format) {
}
void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
LOG();
LOG()
pname = pname_convert(pname);
LOG_D("glTexParameterf, target: %d, pname: %d, param: %f",target, pname, param);
LOG_D("glTexParameterf, target: %d, pname: %d, param: %f",target, pname, param)
if (pname == GL_TEXTURE_LOD_BIAS_QCOM && !g_gles_caps.GL_QCOM_texture_lod_bias) {
LOG_D("Does not support GL_QCOM_texture_lod_bias, skipped!")
return;
}
LOAD_GLES(glTexParameterf, void, GLenum target, GLenum pname, GLfloat param);
LOAD_GLES_FUNC(glTexParameterf)
gles_glTexParameterf(target,pname, param);
CHECK_GL_ERROR
}
void glTexImage1D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
LOG();
LOG_D("glTexImage1D not implemeted!");
LOG()
LOG_D("glTexImage1D not implemeted!")
LOG_D("glTexImage1D, target: %d, level: %d, internalFormat: %d, width: %d, border: %d, format: %d, type: %d",
target, level, internalFormat, width, border, format, type);
target, level, internalFormat, width, border, format, type)
return;
internal_convert(reinterpret_cast<GLenum *>(&internalFormat), & type, &format);
GLenum rtarget = map_tex_target(target);
if (rtarget == GL_PROXY_TEXTURE_1D) {
int max1 = 4096;
LOAD_GLES(glGetIntegerv, void, GLenum pname, GLint * data)
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max1);
set_gl_state_proxy_width(((width << level) > max1) ? 0 : width);
set_gl_state_proxy_intformat(internalFormat);
return;
}
// LOAD_GLES(glTexImage1D, void, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
// LOAD_GLES_FUNC(glTexImage1D, void, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
// gles_glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
CHECK_GL_ERROR
}
void glTexImage2D(GLenum target, GLint level,GLint internalFormat,GLsizei width, GLsizei height,GLint border, GLenum format, GLenum type,const GLvoid* pixels) {
LOG();
LOG()
auto& tex = g_textures[bound_texture];
tex.internal_format = internalFormat;
GLenum transfer_format = format;
// tex.format = format;
LOG_D("mg_glTexImage2D,target: %s,level: %d,internalFormat: %s->%s,width: %d,height: %d,border: %d,format: %s,type: %s, pixels: 0x%x",
glEnumToString(target),level,glEnumToString(internalFormat),glEnumToString(internalFormat),
width,height,border,glEnumToString(format),glEnumToString(type), pixels);
width,height,border,glEnumToString(format),glEnumToString(type), pixels)
internal_convert(reinterpret_cast<GLenum *>(&internalFormat), &type, &format);
LOG_D("gles_glTexImage2D,target: %s,level: %d,internalFormat: %s->%s,width: %d,height: %d,border: %d,format: %s,type: %s, pixels: 0x%x",
glEnumToString(target),level,glEnumToString(internalFormat),glEnumToString(internalFormat),
width,height,border,glEnumToString(format),glEnumToString(type), pixels);
width,height,border,glEnumToString(format),glEnumToString(type), pixels)
GLenum rtarget = map_tex_target(target);
if(rtarget == GL_PROXY_TEXTURE_2D) {
int max1 = 4096;
LOAD_GLES(glGetIntegerv, void, GLenum pname, GLint * data)
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max1);
set_gl_state_proxy_width(((width<<level)>max1)?0:width);
set_gl_state_proxy_height(((height<<level)>max1)?0:height);
@ -309,7 +309,7 @@ void glTexImage2D(GLenum target, GLint level,GLint internalFormat,GLsizei width,
if (transfer_format == GL_BGRA && tex.format != transfer_format && internalFormat == GL_RGBA8
&& width <= 128 && height <= 128) { // xaero has 64x64 tiles...hack here
LOG_D("Detected GL_BGRA format @ tex = %d, do swizzle", bound_texture);
LOG_D("Detected GL_BGRA format @ tex = %d, do swizzle", bound_texture)
if (tex.swizzle_param[0] == 0) { // assert this as never called glTexParameteri(..., GL_TEXTURE_SWIZZLE_R, ...)
tex.swizzle_param[0] = GL_RED;
tex.swizzle_param[1] = GL_GREEN;
@ -327,7 +327,7 @@ void glTexImage2D(GLenum target, GLint level,GLint internalFormat,GLsizei width,
tex.swizzle_param[3] = r;
tex.format = transfer_format;
LOAD_GLES_FUNC(glTexParameteri);
LOAD_GLES_FUNC(glTexParameteri)
gles_glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, tex.swizzle_param[0]);
gles_glTexParameteri(target, GL_TEXTURE_SWIZZLE_G, tex.swizzle_param[1]);
gles_glTexParameteri(target, GL_TEXTURE_SWIZZLE_B, tex.swizzle_param[2]);
@ -335,23 +335,23 @@ void glTexImage2D(GLenum target, GLint level,GLint internalFormat,GLsizei width,
CHECK_GL_ERROR
}
LOAD_GLES(glTexImage2D, void, GLenum target, GLint level,GLint internalFormat,GLsizei width, GLsizei height,GLint border, GLenum format, GLenum type,const GLvoid* pixels);
LOAD_GLES_FUNC(glTexImage2D)
gles_glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
CHECK_GL_ERROR
}
void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
LOG();
LOG()
LOG_D("glTexImage3D, target: 0x%x, level: %d, internalFormat: 0x%x, width: 0x%x, height: %d, depth: %d, border: %d, format: 0x%x, type: %d",
target, level, internalFormat, width, height, depth, border, format, type);
target, level, internalFormat, width, height, depth, border, format, type)
internal_convert(reinterpret_cast<GLenum *>(&internalFormat), &type, &format);
GLenum rtarget = map_tex_target(target);
if (rtarget == GL_PROXY_TEXTURE_3D) {
int max1 = 4096;
LOAD_GLES(glGetIntegerv, void, GLenum pname, GLint * data)
LOAD_GLES_FUNC(glGetIntegerv)
gles_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max1);
set_gl_state_proxy_width(((width << level) > max1) ? 0 : width);
set_gl_state_proxy_height(((height << level) > max1) ? 0 : height);
@ -360,63 +360,63 @@ void glTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei widt
return;
}
LOAD_GLES(glTexImage3D, void, GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
LOAD_GLES_FUNC(glTexImage3D)
gles_glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
CHECK_GL_ERROR
}
void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width) {
LOG();
LOG()
LOG_D("glTexStorage1D not implemented!")
LOG_D("glTexStorage1D, target: %d, levels: %d, internalFormat: %d, width: %d",
target, levels, internalFormat, width);
target, levels, internalFormat, width)
return;
internal_convert(&internalFormat,NULL,NULL);
internal_convert(&internalFormat,nullptr,nullptr);
// LOAD_GLES(glTexStorage1D, void, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width);
// LOAD_GLES_FUNC(glTexStorage1D, void, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width);
// gles_glTexStorage1D(target, levels, internalFormat, width);
CHECK_GL_ERROR
}
void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height) {
LOG();
LOG()
LOG_D("glTexStorage2D, target: %d, levels: %d, internalFormat: %d, width: %d, height: %d",
target, levels, internalFormat, width, height);
target, levels, internalFormat, width, height)
internal_convert(&internalFormat,NULL,NULL);
internal_convert(&internalFormat,nullptr,nullptr);
LOAD_GLES(glTexStorage2D, void, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
LOAD_GLES_FUNC(glTexStorage2D)
gles_glTexStorage2D(target, levels, internalFormat, width, height);
LOAD_GLES(glGetError, GLenum);
LOAD_GLES_FUNC(glGetError)
GLenum ERR = gles_glGetError();
if (ERR != GL_NO_ERROR)
LOG_E("glTexStorage2D ERROR: %d", ERR);
LOG_E("glTexStorage2D ERROR: %d", ERR)
}
void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth) {
LOG();
LOG()
LOG_D("glTexStorage3D, target: %d, levels: %d, internalFormat: %d, width: %d, height: %d, depth: %d",
target, levels, internalFormat, width, height, depth);
target, levels, internalFormat, width, height, depth)
internal_convert(&internalFormat,NULL,NULL);
internal_convert(&internalFormat,nullptr,nullptr);
LOAD_GLES(glTexStorage3D, void, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
LOAD_GLES_FUNC(glTexStorage3D)
gles_glTexStorage3D(target, levels, internalFormat, width, height, depth);
CHECK_GL_ERROR
}
void glCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border) {
LOG();
LOG_D("glCopyTexImage1D not implemented!");
LOG()
LOG_D("glCopyTexImage1D not implemented!")
LOG_D("glCopyTexImage1D, target: %d, level: %d, internalFormat: %d, x: %d, y: %d, width: %d, border: %d",
target, level, internalFormat, x, y, width, border);
target, level, internalFormat, x, y, width, border)
return;
// LOAD_GLES(glCopyTexImage1D, void, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
// LOAD_GLES_FUNC(glCopyTexImage1D, void, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
// gles_glCopyTexImage1D(target, level, internalFormat, x, y, width, border);
CHECK_GL_ERROR
@ -449,28 +449,26 @@ static GLenum get_binding_for_target(GLenum target) {
}
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
LOG();
LOG()
INIT_CHECK_GL_ERROR
LOAD_GLES_FUNC(glGetTexLevelParameteriv);
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
GLint realInternalFormat;
gles_glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &realInternalFormat);
internalFormat = (GLenum)realInternalFormat;
LOG_D("glCopyTexImage2D, target: %d, level: %d, internalFormat: %d, x: %d, y: %d, width: %d, height: %d, border: %d",
target, level, internalFormat, x, y, width, height, border);
target, level, internalFormat, x, y, width, height, border)
if (is_depth_format(internalFormat)) {
GLenum format = GL_DEPTH_COMPONENT;
GLenum type = GL_UNSIGNED_INT;
internal_convert(&internalFormat, &type, &format);
LOAD_GLES(glTexImage2D, void, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
gles_glTexImage2D(target, level, internalFormat, width, height, border, format, type, NULL);
LOAD_GLES_FUNC(glTexImage2D)
gles_glTexImage2D(target, level, (GLint)internalFormat, width, height, border, format, type, nullptr);
CHECK_GL_ERROR_NO_INIT
// GLint prevReadFBO, prevDrawFBO;
GLint prevDrawFBO;
// glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &prevReadFBO);
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &prevDrawFBO);
CHECK_GL_ERROR_NO_INIT
GLuint tempDrawFBO;
@ -494,7 +492,7 @@ void glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x
}
CHECK_GL_ERROR_NO_INIT
LOAD_GLES(glBlitFramebuffer, void, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
LOAD_GLES_FUNC(glBlitFramebuffer)
gles_glBlitFramebuffer(x, y, x + width, y + height,
0, 0, width, height,
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
@ -505,7 +503,7 @@ void glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x
glDeleteFramebuffers(1, &tempDrawFBO);
CHECK_GL_ERROR_NO_INIT
} else {
LOAD_GLES(glCopyTexImage2D, void, GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
LOAD_GLES_FUNC(glCopyTexImage2D)
gles_glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
CHECK_GL_ERROR_NO_INIT
}
@ -514,12 +512,12 @@ void glCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x
}
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
LOG();
LOG()
GLint internalFormat;
LOAD_GLES_FUNC(glGetTexLevelParameteriv);
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
gles_glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &internalFormat);
LOG_D("glCopyTexSubImage2D, target: %d, level: %d, ......, internalFormat: %d", target, level, internalFormat);
LOG_D("glCopyTexSubImage2D, target: %d, level: %d, ......, internalFormat: %d", target, level, internalFormat)
if (is_depth_format((GLenum)internalFormat)) {
GLint prevReadFBO, prevDrawFBO;
@ -540,7 +538,7 @@ void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffse
return;
}
LOAD_GLES(glBlitFramebuffer, void, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
LOAD_GLES_FUNC(glBlitFramebuffer)
gles_glBlitFramebuffer(x, y, x + width, y + height,
xoffset, yoffset, xoffset + width, yoffset + height,
GL_DEPTH_BUFFER_BIT, GL_NEAREST);
@ -548,7 +546,7 @@ void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffse
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, prevDrawFBO);
glDeleteFramebuffers(1, &tempDrawFBO);
} else {
LOAD_GLES(glCopyTexSubImage2D, void, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
LOAD_GLES_FUNC(glCopyTexSubImage2D)
gles_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}
@ -556,13 +554,13 @@ void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffse
}
void glRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) {
LOG();
LOG()
INIT_CHECK_GL_ERROR_FORCE
CLEAR_GL_ERROR_NO_INIT
LOAD_GLES_FUNC(glGetTexLevelParameteriv);
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
GLint realInternalFormat;
gles_glGetTexLevelParameteriv(target, 0, GL_TEXTURE_INTERNAL_FORMAT, &realInternalFormat);
ERR = gles_glGetError();
@ -574,22 +572,22 @@ void glRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width,
CLEAR_GL_ERROR_NO_INIT
LOG_D("glRenderbufferStorage, target: 0x%x, internalFormat: 0x%x, width: %d, height: %d",
target, internalFormat, width, height);
target, internalFormat, width, height)
LOAD_GLES(glRenderbufferStorage, void, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height);
LOAD_GLES_FUNC(glRenderbufferStorage)
gles_glRenderbufferStorage(target, internalFormat, width, height);
CHECK_GL_ERROR_NO_INIT
}
void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) {
LOG();
LOG()
INIT_CHECK_GL_ERROR_FORCE
CLEAR_GL_ERROR_NO_INIT
LOAD_GLES_FUNC(glGetTexLevelParameteriv);
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
GLint realInternalFormat;
gles_glGetTexLevelParameteriv(target, 0, GL_TEXTURE_INTERNAL_FORMAT, &realInternalFormat);
ERR = gles_glGetError();
@ -600,40 +598,41 @@ void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum int
LOG_D("glRenderbufferStorageMultisample, target: %d, samples: %d, internalFormat: %d, width: %d, height: %d",
target, samples, internalFormat, width, height);
target, samples, internalFormat, width, height)
LOAD_GLES(glRenderbufferStorageMultisample, void, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height);
LOAD_GLES_FUNC(glRenderbufferStorageMultisample)
gles_glRenderbufferStorageMultisample(target, samples, internalFormat, width, height);
CHECK_GL_ERROR_NO_INIT
}
void glGetTexLevelParameterfv(GLenum target, GLint level,GLenum pname, GLfloat *params) {
LOG();
LOG_D("glGetTexLevelParameterfv,target: %d, level: %d, pname: %d",target,level,pname);
LOG()
LOG_D("glGetTexLevelParameterfv,target: %d, level: %d, pname: %d",target,level,pname)
GLenum rtarget = map_tex_target(target);
if (rtarget==GL_PROXY_TEXTURE_2D) {
switch (pname) {
case GL_TEXTURE_WIDTH:
(*params) = nlevel(gl_state->proxy_width, level);
(*params) = (float)nlevel(gl_state->proxy_width, level);
break;
case GL_TEXTURE_HEIGHT:
(*params) = nlevel(gl_state->proxy_height, level);
(*params) = (float)nlevel(gl_state->proxy_height, level);
break;
case GL_TEXTURE_INTERNAL_FORMAT:
(*params) = gl_state->proxy_intformat;
(*params) = (float)gl_state->proxy_intformat;
break;
default:
return;
}
return;
}
LOAD_GLES(glGetTexLevelParameterfv, void, GLenum target, GLint level,GLenum pname, GLfloat *params);
LOAD_GLES_FUNC(glGetTexLevelParameterfv)
gles_glGetTexLevelParameterfv(target,level,pname,params);
CHECK_GL_ERROR
}
void glGetTexLevelParameteriv(GLenum target, GLint level,GLenum pname, GLint *params) {
LOG();
LOG_D("glGetTexLevelParameteriv,target: %d, level: %d, pname: %d",target,level,pname);
LOG()
LOG_D("glGetTexLevelParameteriv,target: %d, level: %d, pname: %d",target,level,pname)
GLenum rtarget = map_tex_target(target);
if (rtarget==GL_PROXY_TEXTURE_2D) {
switch (pname) {
@ -644,25 +643,25 @@ void glGetTexLevelParameteriv(GLenum target, GLint level,GLenum pname, GLint *pa
(*params) = nlevel(gl_state->proxy_height, level);
break;
case GL_TEXTURE_INTERNAL_FORMAT:
(*params) = gl_state->proxy_intformat;
(*params) = (GLint)gl_state->proxy_intformat;
break;
default:
return;
}
return;
}
LOAD_GLES(glGetTexLevelParameteriv, void, GLenum target, GLint level,GLenum pname, GLint *params);
GLint *fparams = NULL;
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
gles_glGetTexLevelParameteriv(target,level,pname,params);
CHECK_GL_ERROR
}
void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
LOG_D("glTexParameteriv, target: %s, pname: %s, params[0]: %s",
params, glEnumToString(pname), params ? glEnumToString(params[0]) : "0");
LOAD_GLES_FUNC(glTexParameteriv);
LOAD_GLES_FUNC(glTexParameteri);
params, glEnumToString(pname), params ? glEnumToString(params[0]) : "0")
LOAD_GLES_FUNC(glTexParameteriv)
LOAD_GLES_FUNC(glTexParameteri)
if (pname == GL_TEXTURE_SWIZZLE_RGBA) {
LOG_D("find GL_TEXTURE_SWIZZLE_RGBA, now use glTexParameteri");
LOG_D("find GL_TEXTURE_SWIZZLE_RGBA, now use glTexParameteri")
if (params) {
// deferred those call to draw call?
gles_glTexParameteri(target, GL_TEXTURE_SWIZZLE_R, params[0]);
@ -677,7 +676,7 @@ void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
tex.swizzle_param[2] = params[2];
tex.swizzle_param[3] = params[3];
} else {
LOG_E("glTexParameteriv: params is null for GL_TEXTURE_SWIZZLE_RGBA");
LOG_E("glTexParameteriv: params is nullptr for GL_TEXTURE_SWIZZLE_RGBA")
}
} else {
gles_glTexParameteriv(target, pname, params);
@ -687,7 +686,7 @@ void glTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
}
void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {
LOG();
LOG()
LOAD_GLES_FUNC(glTexSubImage2D)
LOG_D("glTexSubImage2D, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = %d, format = %s, type = %s, pixels = 0x%x",
@ -705,26 +704,24 @@ void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, G
}
void glBindTexture(GLenum target, GLuint texture) {
LOG();
LOG_D("glBindTexture(%s, %d)", glEnumToString(target), texture);
LOG()
LOG_D("glBindTexture(%s, %d)", glEnumToString(target), texture)
LOAD_GLES_FUNC(glBindTexture)
INIT_CHECK_GL_ERROR
gles_glBindTexture(target, texture);
CHECK_GL_ERROR_NO_INIT
//if (target == GL_TEXTURE_2D) { // only care about 2D textures for now
g_textures[texture] = {
.target = target,
.texture = texture,
.format = 0,
.swizzle_param = {0}
};
bound_texture = texture;
//}
g_textures[texture] = {
.target = target,
.texture = texture,
.format = 0,
.swizzle_param = {0}
};
bound_texture = texture;
}
void glDeleteTextures(GLsizei n, const GLuint *textures) {
LOG();
LOG()
LOAD_GLES_FUNC(glDeleteTextures)
INIT_CHECK_GL_ERROR
gles_glDeleteTextures(n, textures);
@ -755,20 +752,26 @@ void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void*
LOG_D("glGetTexImage, target = %s, level = %d, format = %s, type = %s, pixel = 0x%x",
glEnumToString(target), level, glEnumToString(format), glEnumToString(type), pixels)
LOAD_GLES_FUNC(glGetIntegerv)
LOAD_GLES_FUNC(glActiveTexture)
LOAD_GLES_FUNC(glBindTexture)
LOAD_GLES_FUNC(glGetTexLevelParameteriv)
LOAD_GLES_FUNC(glViewport)
GLint prevFBO;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFBO);
gles_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prevFBO);
GLenum bindingTarget = get_binding_for_target(target);
if (bindingTarget == 0) return;
GLint oldTexBinding;
glActiveTexture(GL_TEXTURE0);
glGetIntegerv(bindingTarget, &oldTexBinding);
GLuint texture = static_cast<GLuint>(oldTexBinding);
gles_glActiveTexture(GL_TEXTURE0);
gles_glGetIntegerv(bindingTarget, &oldTexBinding);
auto texture = static_cast<GLuint>(oldTexBinding);
if (texture == 0) return;
GLint width, height;
glBindTexture(target, texture);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
glBindTexture(target, oldTexBinding);
gles_glBindTexture(target, texture);
gles_glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
gles_glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
gles_glBindTexture(target, oldTexBinding);
if (width <= 0 || height <= 0) return;
GLuint fbo;
glGenFramebuffers(1, &fbo);
@ -786,8 +789,8 @@ void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void*
return;
}
GLint oldViewport[4];
glGetIntegerv(GL_VIEWPORT, oldViewport);
glViewport(0, 0, width, height);
gles_glGetIntegerv(GL_VIEWPORT, oldViewport);
gles_glViewport(0, 0, width, height);
GLint oldPackAlignment;
glGetIntegerv(GL_PACK_ALIGNMENT, &oldPackAlignment);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
@ -805,7 +808,7 @@ void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void*
glReadPixels(0, 0, width, height, format, type, pixels);
glPixelStorei(GL_PACK_ALIGNMENT, oldPackAlignment);
glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
gles_glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
glDeleteFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, prevFBO);
}
@ -820,10 +823,8 @@ void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format
LOAD_GLES_FUNC(glReadPixels)
LOG_D("glReadPixels, x=%d, y=%d, width=%d, height=%d, format=0x%x, type=0x%x, pixels=0x%x",
x, y, width, height, format, type, pixels)
static int count = 0;
GLenum prevFormat = format;
static int count = 0;
if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8) {
format = GL_RGBA;
@ -863,52 +864,6 @@ void glTexParameteri(GLenum target, GLenum pname, GLint param) {
CHECK_GL_ERROR
}
template<typename T>
void readDataComponents(const void* data, GLenum type, T* out, size_t maxComponents) {
const uint8_t* src = static_cast<const uint8_t*>(data);
switch(type) {
case GL_UNSIGNED_BYTE:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(src[i]);
}
break;
case GL_BYTE:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const int8_t*>(src + i));
}
break;
case GL_UNSIGNED_SHORT:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const uint16_t*>(src + i*2));
}
break;
case GL_SHORT:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const int16_t*>(src + i*2));
}
break;
case GL_UNSIGNED_INT:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const uint32_t*>(src + i*4));
}
break;
case GL_INT:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const int32_t*>(src + i*4));
}
break;
case GL_FLOAT:
for(size_t i = 0; i < maxComponents; ++i) {
out[i] = static_cast<T>(*reinterpret_cast<const float*>(src + i*4));
}
break;
default:
break;
}
}
void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
{
LOG()
@ -930,44 +885,49 @@ void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, co
return;
}
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
LOAD_GLES_FUNC(glClearColor)
LOAD_GLES_FUNC(glClearDepthf)
LOAD_GLES_FUNC(glClearStencil)
LOAD_GLES_FUNC(glClear)
gles_glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
CHECK_GL_ERROR_NO_INIT
if (data != nullptr) {
if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
const GLubyte* byteData = static_cast<const GLubyte*>(data);
glClearColor(byteData[0] / 255.0f, byteData[1] / 255.0f, byteData[2] / 255.0f, byteData[3] / 255.0f);
auto* byteData = static_cast<const GLubyte*>(data);
gles_glClearColor((float)byteData[0] / 255.0f, (float)byteData[1] / 255.0f, (float)byteData[2] / 255.0f, (float)byteData[3] / 255.0f);
}
else if (format == GL_RGB && type == GL_UNSIGNED_BYTE) {
const GLubyte* byteData = static_cast<const GLubyte*>(data);
glClearColor(byteData[0] / 255.0f, byteData[1] / 255.0f, byteData[2] / 255.0f, 1.0f);
auto* byteData = static_cast<const GLubyte*>(data);
gles_glClearColor((float)byteData[0] / 255.0f, (float)byteData[1] / 255.0f, (float)byteData[2] / 255.0f, 1.0f);
}
else if (format == GL_RGBA && type == GL_FLOAT) {
const GLfloat* floatData = static_cast<const GLfloat*>(data);
glClearColor(floatData[0], floatData[1], floatData[2], floatData[3]);
auto* floatData = static_cast<const GLfloat*>(data);
gles_glClearColor(floatData[0], floatData[1], floatData[2], floatData[3]);
}
else if (format == GL_RGB && type == GL_FLOAT) {
const GLfloat* floatData = static_cast<const GLfloat*>(data);
glClearColor(floatData[0], floatData[1], floatData[2], 1.0f);
auto* floatData = static_cast<const GLfloat*>(data);
gles_glClearColor(floatData[0], floatData[1], floatData[2], 1.0f);
}
else if (format == GL_DEPTH_COMPONENT && type == GL_FLOAT) {
const GLfloat* depthData = static_cast<const GLfloat*>(data);
glClearDepthf(depthData[0]);
glClear(GL_DEPTH_BUFFER_BIT);
auto* depthData = static_cast<const GLfloat*>(data);
gles_glClearDepthf(depthData[0]);
gles_glClear(GL_DEPTH_BUFFER_BIT);
}
else if (format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE) {
const GLubyte* stencilData = static_cast<const GLubyte*>(data);
glClearStencil(stencilData[0]);
glClear(GL_STENCIL_BUFFER_BIT);
auto* stencilData = static_cast<const GLubyte*>(data);
gles_glClearStencil(stencilData[0]);
gles_glClear(GL_STENCIL_BUFFER_BIT);
}
}
CHECK_GL_ERROR_NO_INIT
if (format == GL_DEPTH_COMPONENT || format == GL_STENCIL_INDEX) {
glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
gles_glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
CHECK_GL_ERROR_NO_INIT
} else {
glClear(GL_COLOR_BUFFER_BIT);
gles_glClear(GL_COLOR_BUFFER_BIT);
CHECK_GL_ERROR_NO_INIT
}
@ -978,7 +938,7 @@ void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, co
void glPixelStorei(GLenum pname, GLint param) {
LOG_D("glPixelStorei, pname = %s, param = %d", glEnumToString(pname), param)
LOAD_GLES_FUNC(glPixelStorei)
gles_glPixelStorei(pname, param);
CHECK_GL_ERROR
}

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

@ -91,7 +91,7 @@ GL_FUNC_TYPEDEF(void, glGetBooleanv, GLenum pname, GLboolean *data)
GL_FUNC_TYPEDEF(void, glGetBufferParameteriv, GLenum target, GLenum pname, GLint *params)
GL_FUNC_TYPEDEF(GLenum, glGetError)
GL_FUNC_TYPEDEF(const GLubyte *, glGetString, GLenum)
GL_FUNC_TYPEDEF(const GLubyte *, glGetStringi, GLenum, GLuint) ;
GL_FUNC_TYPEDEF(const GLubyte *, glGetStringi, GLenum, GLuint)
GL_FUNC_TYPEDEF(void, glGetFloatv, GLenum pname, GLfloat *data)
GL_FUNC_TYPEDEF(void, glGetFramebufferAttachmentParameteriv, GLenum target, GLenum attachment,
GLenum pname, GLint *params)
@ -520,6 +520,7 @@ GL_FUNC_TYPEDEF(void, glGetQueryObjectivEXT, GLuint id, GLenum pname, GLint *par
GL_FUNC_TYPEDEF(void, glGetQueryObjecti64vEXT, GLuint id, GLenum pname, GLint64 *params)
GL_FUNC_TYPEDEF(void, glBindFragDataLocationEXT, GLuint program, GLuint colorNumber,
const GLchar *name)
GL_FUNC_TYPEDEF(void*, glMapBufferOES, GLenum target, GLenum access)
#define GL_FUNC_DECL(name) \
name##_PTR name;
@ -890,6 +891,7 @@ struct gles_func_t {
GL_FUNC_DECL(glGetQueryObjectivEXT)
GL_FUNC_DECL(glGetQueryObjecti64vEXT)
GL_FUNC_DECL(glBindFragDataLocationEXT)
GL_FUNC_DECL(glMapBufferOES)
};
extern struct gles_func_t g_gles_func;

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

@ -3,8 +3,8 @@
//
#include <linux/limits.h>
#include <string.h>
#include <stdio.h>
#include <cstring>
#include <cstdio>
#include "loader.h"
#include "../includes.h"
#include "loader.h"
@ -19,7 +19,7 @@
#define DEBUG 0
void *gles = NULL, *egl = NULL;
void *gles = nullptr, *egl = nullptr;
struct gles_func_t g_gles_func;
@ -28,7 +28,7 @@ static const char *path_prefix[] = {
"/opt/vc/lib/",
"/usr/local/lib/",
"/usr/lib/",
NULL,
nullptr,
};
static const char *lib_ext[] = {
@ -40,13 +40,13 @@ static const char *lib_ext[] = {
"so.2",
"dylib",
"dll",
NULL,
nullptr,
};
static const char *gles3_lib[] = {
"libGLESv3_CM",
"libGLESv3",
NULL
nullptr
};
static const char *egl_lib[] = {
@ -54,24 +54,24 @@ static const char *egl_lib[] = {
"libbrcmEGL",
#endif
"libEGL",
NULL
nullptr
};
const char *GLES_ANGLE = "libGLESv2_angle.so";
const char *EGL_ANGLE = "libEGL_angle.so";
void *open_lib(const char **names, const char *override) {
void *lib = NULL;
void *lib = nullptr;
char path_name[PATH_MAX + 1];
int flags = RTLD_LOCAL | RTLD_NOW;
if (override) {
if ((lib = dlopen(override, flags))) {
strncpy(path_name, override, PATH_MAX);
LOG_D("LIBGL:loaded: %s\n", path_name);
LOG_D("LIBGL:loaded: %s\n", path_name)
return lib;
} else {
LOG_E("LIBGL_GLES override failed: %s\n", dlerror());
LOG_E("LIBGL_GLES override failed: %s\n", dlerror())
}
}
for (int p = 0; path_prefix[p]; p++) {
@ -91,14 +91,13 @@ void load_libs() {
static int first = 1;
if (!first) return;
first = 0;
const char *gles_override = global_settings.angle ? GLES_ANGLE : NULL;
const char *egl_override = global_settings.angle ? EGL_ANGLE : NULL;
const char *gles_override = global_settings.angle ? GLES_ANGLE : nullptr;
const char *egl_override = global_settings.angle ? EGL_ANGLE : nullptr;
gles = open_lib(gles3_lib, gles_override);
egl = open_lib(egl_lib, egl_override);
}
void *proc_address(void *lib, const char *name) {
// printf("proc_address(%s)\n", name);
return dlsym(lib, name);
}
@ -118,16 +117,16 @@ void init_gl_state() {
void LogOpenGLExtensions() {
const GLubyte *raw_extensions = glGetString(GL_EXTENSIONS);
LOG_D("Extensions list using glGetString:\n%s",
raw_extensions ? (const char *) raw_extensions : "(null)");
raw_extensions ? (const char *) raw_extensions : "(nullptr)")
GLint num_extensions = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
LOG_D("Extensions list using glGetStringi:\n");
LOG_D("Extensions list using glGetStringi:\n")
for (GLint i = 0; i < num_extensions; ++i) {
const GLubyte *extension = glGetStringi(GL_EXTENSIONS, i);
if (extension) {
LOG_D("%s", (const char *) extension);
LOG_D("%s", (const char *) extension)
} else {
LOG_D("(null)");
LOG_D("(nullptr)")
}
}
}
@ -147,11 +146,11 @@ void InitGLESCapabilities() {
GLint num_es_extensions = 0;
gles_glGetIntegerv(GL_NUM_EXTENSIONS, &num_es_extensions);
LOG_D("Detected %d OpenGL ES extensions.", num_es_extensions);
LOG_D("Detected %d OpenGL ES extensions.", num_es_extensions)
for (GLint i = 0; i < num_es_extensions; ++i) {
const char *extension = (const char *) gles_glGetStringi(GL_EXTENSIONS, i);
if (extension) {
LOG_D("%s", (const char *) extension);
LOG_D("%s", (const char *) extension)
if (strcmp(extension, "GL_EXT_buffer_storage") == 0) {
g_gles_caps.GL_EXT_buffer_storage = 1;
} else if (strcmp(extension, "GL_EXT_disjoint_timer_query") == 0) {
@ -164,10 +163,12 @@ void InitGLESCapabilities() {
g_gles_caps.GL_EXT_texture_format_BGRA8888 = 1;
} else if (strcmp(extension, "GL_EXT_read_format_bgra") == 0) {
g_gles_caps.GL_EXT_read_format_bgra = 1;
} else if (strcmp(extension, "GL_OES_mapbuffer") == 0) {
g_gles_caps.GL_OES_mapbuffer = 1;
}
} else {
LOG_D("(null)");
LOG_D("(nullptr)")
}
}
@ -558,8 +559,9 @@ void init_target_gles() {
INIT_GLES_FUNC(glGetQueryObjectivEXT)
INIT_GLES_FUNC(glGetQueryObjecti64vEXT)
INIT_GLES_FUNC(glBindFragDataLocationEXT)
INIT_GLES_FUNC(glMapBufferOES)
LOG_D("Initializing %s @ hardware", RENDERERNAME);
LOG_D("Initializing %s @ hardware", RENDERERNAME)
set_hardware();
InitGLESCapabilities();

101
src/main/cpp/gles/loader.h
View File

@ -1,14 +1,13 @@
#ifndef MOBILEGLUES_GLES_LOADER_H_
#define MOBILEGLUES_GLES_LOADER_H_
#include <stdbool.h>
#include "../gl/log.h"
#include "../gl/gl.h"
#include "gles.h"
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#ifdef __cplusplus
extern "C" {
@ -21,68 +20,40 @@ void init_target_gles();
void load_libs();
#define WARN_NULL(name) if (name == NULL) { LOG_W("%s line %d function %s: " #name " is NULL\n", __FILE__, __LINE__, __func__); }
#define WARN_GLES_NULL(name) \
if (g_gles_func.name == NULL) { \
LOG_W("%s line %d function %s: " #name " is NULL\n", __FILE__, __LINE__, __func__); \
}
#if GLOBAL_DEBUG
#define INIT_GLES_FUNC(name) \
{ \
LOG_D("INIT_GLES_FUNC(%s)", #name); \
g_gles_func.name = (name##_PTR)proc_address(gles, #name); \
WARN_GLES_NULL(name) \
#define INIT_GLES_FUNC(name) \
{ \
LOG_D("INIT_GLES_FUNC(%s)", #name); \
g_gles_func.name = (name##_PTR)proc_address(gles, #name); \
LOG_W("Error: GLES function " #name " is NULL\n"); \
}
#else
#define INIT_GLES_FUNC(name) \
{ \
g_gles_func.name = (name##_PTR)proc_address(gles, #name); \
#define INIT_GLES_FUNC(name) \
{ \
g_gles_func.name = (name##_PTR)proc_address(gles, #name); \
}
#endif
#define LOAD_GLES_FUNC(name) \
name##_PTR gles_##name = g_gles_func.name;
#define LOAD_GLES(name,type, ...) LOAD_GLES_FUNC(name)
#define LOAD_GLES2(name,type, ...) LOAD_GLES_FUNC(name)
#define LOAD_GLES3(name,type, ...) LOAD_GLES_FUNC(name)
void *open_lib(const char **names, const char *override);
#define LOAD_RAW_GLES(name, type, ...) \
gles_##name = g_gles_func.name; \
//#define LOAD_RAW_GLES(name, type, ...) \
// { \
// if (gles != NULL) { \
// gles_##name = (name##_PTR)proc_address(gles, #name); \
// } \
// WARN_NULL(gles_##name); \
// }
#define LOAD_LIB(type, name, ...) \
typedef type (*name##_PTR)(__VA_ARGS__); \
name##_PTR gles_##name = NULL; \
LOAD_RAW_GLES(name, type, __VA_ARGS__)
//#define LOAD_GLES(name,type, ...) LOAD_LIB(type, name, __VA_ARGS__)
//#define LOAD_GLES2(name,type, ...) LOAD_LIB(type, name, __VA_ARGS__)
//#define LOAD_GLES3(name,type, ...) LOAD_LIB(type, name, __VA_ARGS__)
#define LOAD_EGL(name) \
static name##_PTR egl_##name = NULL; \
{ \
static bool first = true; \
if (first) { \
first = false; \
if (egl != NULL) { \
egl_##name = (name##_PTR)proc_address(egl, #name); \
} \
WARN_NULL(egl_##name); \
} \
#define LOAD_EGL(name) \
static name##_PTR egl_##name = NULL; \
{ \
static bool first = true; \
if (first) { \
first = false; \
if (egl != NULL) { \
egl_##name = (name##_PTR)proc_address(egl, #name); \
} \
LOG_W("Error: " #name " is NULL\n"); \
} \
}
#define CLEAR_GL_ERROR \
LOAD_GLES(glGetError, GLenum) \
LOAD_GLES_FUNC(glGetError) \
GLenum ERR = gles_glGetError(); \
while (ERR != GL_NO_ERROR) \
ERR = gles_glGetError();
@ -94,7 +65,7 @@ static name##_PTR egl_##name = NULL; \
#if GLOBAL_DEBUG
#define CHECK_GL_ERROR \
LOAD_GLES(glGetError, GLenum) \
LOAD_GLES_FUNC(glGetError) \
GLenum ERR = gles_glGetError(); \
while (ERR != GL_NO_ERROR) { \
LOG_E("ERROR: %d @ %s:%d", ERR, __FILE__, __LINE__) \
@ -102,7 +73,7 @@ static name##_PTR egl_##name = NULL; \
}
#define INIT_CHECK_GL_ERROR \
LOAD_GLES(glGetError, GLenum) \
LOAD_GLES_FUNC(glGetError) \
GLenum ERR = GL_NO_ERROR;
#define CHECK_GL_ERROR_NO_INIT \
@ -118,21 +89,20 @@ static name##_PTR egl_##name = NULL; \
#endif
#define INIT_CHECK_GL_ERROR_FORCE \
LOAD_GLES(glGetError, GLenum) \
LOAD_GLES_FUNC(glGetError) \
GLenum ERR = GL_NO_ERROR;
#define NATIVE_FUNCTION_HEAD(type,name,...) \
GLAPI GLAPIENTRY type name##ARB(__VA_ARGS__) __attribute__((alias(#name))); \
GLAPI GLAPIENTRY type name(__VA_ARGS__) { \
LOAD_GLES_FUNC(name)
GLAPI GLAPIENTRY type name(__VA_ARGS__) {
#if GLOBAL_DEBUG
#define NATIVE_FUNCTION_END(type,name,...) \
LOG_D("Use native function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
LOAD_RAW_GLES(name, type, __VA_ARGS__); \
type ret = gles_##name(__VA_ARGS__); \
LOAD_GLES(glGetError, GLenum) \
LOAD_GLES_FUNC(glGetError) \
GLenum ERR = gles_glGetError(); \
if (ERR != GL_NO_ERROR) \
LOG_E("ERROR: %d", ERR) \
@ -141,7 +111,7 @@ LOAD_GLES_FUNC(name)
#else
#define NATIVE_FUNCTION_END(type,name,...) \
LOG_D("Use native function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
LOAD_RAW_GLES(name, type, __VA_ARGS__); \
LOAD_GLES_FUNC(name); \
type ret = gles_##name(__VA_ARGS__); \
CHECK_GL_ERROR \
return ret; \
@ -158,7 +128,7 @@ LOAD_GLES_FUNC(name)
#else
#define NATIVE_FUNCTION_END_NO_RETURN(type,name,...) \
LOG_D("Use native function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
LOAD_RAW_GLES(name, type, __VA_ARGS__); \
LOAD_GLES_FUNC(name); \
gles_##name(__VA_ARGS__); \
}
#endif
@ -167,21 +137,22 @@ LOAD_GLES_FUNC(name)
GLAPI GLAPIENTRY type name(__VA_ARGS__) {
#define STUB_FUNCTION_END(type,name,...) \
LOG_W("No function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
LOG_W("Stub function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
return (type)0; \
}
#define STUB_FUNCTION_END_NO_RETURN(type,name,...) \
LOG_W("No function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
LOG_W("Stub function: %s @ %s(...)", RENDERERNAME, __FUNCTION__); \
}
struct gles_caps_t {
int GL_EXT_buffer_storage;
int GL_EXT_disjoint_timer_query;
int GL_QCOM_texture_lod_bias;
int GL_EXT_blend_func_extended;
int GL_EXT_texture_format_BGRA8888;
int GL_EXT_read_format_bgra;
[[maybe_unused]] int GL_EXT_blend_func_extended;
[[maybe_unused]] int GL_EXT_texture_format_BGRA8888;
[[maybe_unused]] int GL_EXT_read_format_bgra;
int GL_OES_mapbuffer;
};
extern struct gles_caps_t g_gles_caps;

2
src/main/cpp/version.h
View File

@ -13,7 +13,7 @@
#define REVISION 5
#define PATCH 0
const int version_type = VERSION_RELEASE;
#define VERSION_TYPE VERSION_DEVELOPMENT
#define MOBILEGLUES_VERSION_H