[Misc] (...): Changes for fpe.

src/main/cpp/CMakeLists.txt

@@ -53,6 +53,7 @@ add_library(${CMAKE_PROJECT_NAME} SHARED
         config/settings.cpp
         gl/glsl/glslconv_gl4es.cpp
 
+        gl/gl4es/gl/vgpu/shaderconv.c
         gl/gl4es/gl/string_utils.c
         gl/gl4es/gl/arbconverter.c
         gl/gl4es/gl/arbgenerator.c

src/main/cpp/gl/framebuffer.cpp

@@ -350,6 +350,13 @@ EXPORT void glFramebufferTexture3DARB(GLenum target, GLenum attachment,
 EXPORT void glDrawBuffersARB(GLsizei n, const GLenum *bufs) {
     glDrawBuffers(n, bufs);
 }
-
+EXPORT void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget,
-
+                                      GLuint texture, GLint level) {
+    glFramebufferTexture2D(target, attachment, GL_TEXTURE_2D, texture, level);
+}
+EXPORT void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget,
+                                      GLuint texture, GLint level, GLint zoffset) {
+    LOG()
+    GLES.glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
+}
 }

src/main/cpp/gl/gl4es/gl/framebuffers.c

@@ -1497,7 +1497,7 @@ void APIENTRY_GL4ES gl4es_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX
     memcpy(vp, &glstate->raster.viewport, sizeof(vp));
     gl4es_glViewport(0, 0, fbowidth, fboheight);
     // TODO: Handle the conflict between Core Profile with Compatibility Profile
-    gl4es_blitTexture(glname, srcX0, srcY0, srcW, srcH, nwidth, nheight, zoomx, zoomy, 0, 0, dstX0, dstY0, BLIT_OPAQUE);
+    //gl4es_blitTexture(glname, srcX0, srcY0, srcW, srcH, nwidth, nheight, zoomx, zoomy, 0, 0, dstX0, dstY0, BLIT_OPAQUE);
     gl4es_glViewport(vp[0], vp[1], vp[2], vp[3]);
     if(created) {
         gl4es_glDeleteTextures(1, &texture);

src/main/cpp/gl/gl4es/gl/gl4es.c

@@ -17,6 +17,7 @@
 #include "loader.h"
 #include "matrix.h"
 #include "buffers.h"
+#include "vgpu/shaderconv.h"
 #ifdef _WIN32
 #ifdef _WINBASE_
 #define GSM_CAST(c) ((LPFILETIME)c)

src/main/cpp/gl/gl4es/gl/gl4es.h

@@ -122,6 +122,7 @@ static inline void errorGL() {	// next glGetError will be from GL
         glstate->type_error = 1;    // will need to read glGetError...
 }
 static inline void errorShim(GLenum error) {	// next glGetError will be "error" from gl4es
+    DBG(LOGD("    -> error set: %d", error))
     if(glstate->type_error && glstate->shim_error==GL_NO_ERROR)
 	    glstate->type_error = 1;
     if(glstate->shim_error == GL_NO_ERROR)

src/main/cpp/gl/gl4es/gl/init.c

@@ -425,11 +425,14 @@ void initialize_gl4es() {
         globals4es.nointovlhack = 1;
         SHUT_LOGD("MobileGlues-gl4es: No hack in shader converter to define overloaded function with int\n");
     }
+    globals4es.nointovlhack = 1;
     if(GL4ES_IsEnvVarTrue("LIBGL_NOSHADERLOD")) {
         globals4es.noshaderlod = 1;
         SHUT_LOGD("MobileGlues-gl4es: No GL_EXT_shader_texture_lod used even if present\n");
         hardext.shaderlod=0;
     }
+    hardext.shaderlod=0;
+    globals4es.noshaderlod = 1;
 
     int env_begin_end;
     if(GL4ES_GetEnvVarInt("LIBGL_BEGINEND",&env_begin_end,0)) {
@@ -618,7 +621,7 @@ void initialize_gl4es() {
     env(LIBGL_SHADERNOGLES, globals4es.shadernogles, "Remove GLES part in shader");
     env(LIBGL_NOES2COMPAT, globals4es.noes2, "Don't expose GLX_EXT_create_context_es2_profile extension");
     env(LIBGL_NORMALIZE, globals4es.normalize, "Force normals to be normalized on FPE shaders");
-
+    globals4es.normalize=1;
     globals4es.dbgshaderconv=GL4ES_ReturnEnvVarIntDef("LIBGL_DBGSHADERCONV",0);
     if(globals4es.dbgshaderconv) {
       if(globals4es.dbgshaderconv==1)

src/main/cpp/gl/gl4es/gl/program.c

@@ -11,7 +11,7 @@
 #include "shaderconv.h"
 #include "fpe_shader.h"
 
-//#define DEBUG
+#define DEBUG
 #ifdef DEBUG
 #define DBG(a) a
 #else
@@ -46,11 +46,12 @@ void APIENTRY_GL4ES gl4es_glAttachShader(GLuint program, GLuint shader) {
     // send to hadware
     LOAD_GLES2(glAttachShader);
     if(gl4es_gles_glAttachShader) {
-        if(strstr((glshader->converted)?glshader->converted:glshader->source, "FPE")!=NULL) {
+        if(glshader->is_gl4es_conv_shader) {
-            gl4es_gles_glAttachShader(glprogram->id, glshader->id);
+//            gl4es_gles_glAttachShader(glprogram->id, glshader->id);
+            gl4es_gles_glAttachShader(program, glshader->id);
+            // use fronted program id?
         }
-        
+
-        {} //STUB of gl4es_gles_glAttachShader(glprogram->id, glshader->id);
         errorGL();
     } else
         noerrorShim();
@@ -795,10 +796,8 @@ void APIENTRY_GL4ES gl4es_glLinkProgram(GLuint program) {
     if(gl4es_gles_glLinkProgram) {
         LOAD_GLES(glGetError);
         LOAD_GLES2(glGetProgramiv);
-        if(strstr((glprogram->last_vert->converted)?glprogram->last_vert->converted:glprogram->last_vert->source, "FPE")!=NULL) {
+         
-            gl4es_gles_glLinkProgram(glprogram->id);
+        gl4es_gles_glLinkProgram(glprogram->id);
-        }
-        {} //STUB of gl4es_gles_glLinkProgram(glprogram->id);
         GLenum err = gl4es_gles_glGetError();
         // Get Link Status
       gl4es_gles_glGetProgramiv(glprogram->id, GL_LINK_STATUS, &glprogram->linked);

src/main/cpp/gl/gl4es/gl/shader.c

@@ -8,7 +8,7 @@
 #include "loader.h"
 #include "shaderconv.h"
 
-//#define DEBUG
+#define DEBUG
 #ifdef DEBUG
 #define DBG(a) a
 #else
@@ -110,7 +110,8 @@ void APIENTRY_GL4ES gl4es_glDeleteShader(GLuint shader) {
         LOAD_GLES2(glDeleteShader);
         if(gl4es_gles_glDeleteShader) {
             errorGL();
-            {} //STUB of gl4es_gles_glDeleteShader(shader);
+            if(glshader->is_gl4es_conv_shader)
+                gl4es_gles_glDeleteShader(shader);
         }   
     }
 }
@@ -123,10 +124,8 @@ void APIENTRY_GL4ES gl4es_glCompileShader(GLuint shader) {
     glshader->compiled = 1;
     LOAD_GLES2(glCompileShader);
     if(gl4es_gles_glCompileShader) {
-        {} //STUB of gl4es_gles_glCompileShader(glshader->id);
+        gl4es_gles_glCompileShader(glshader->id);
-        if(strstr((glshader->converted)?glshader->converted:glshader->source, "FPE")!=NULL) {
+        
-            gl4es_gles_glCompileShader(glshader->id);
-        }
         errorGL();
         if(globals4es.logshader) {
             // get compile status and print shaders sources if compile fail...
@@ -178,9 +177,15 @@ void APIENTRY_GL4ES gl4es_glShaderSource(GLuint shader, GLsizei count, const GLc
         if(glstate->glsl->es2 && !strncmp(glshader->source, "#version 100", 12))
             glshader->converted = strdup(glshader->source);
         else
-            glshader->converted = ConvertShader(glshader->source, glshader->type==GL_VERTEX_SHADER?1:0, &glshader->need);
+            glshader->converted = strdup(ConvertShaderConditionally(glshader));
         // send source to GLES2 hardware if any
-        if(strstr((glshader->converted)?glshader->converted:glshader->source, "FPE")!=NULL) {
+        int getGLSLVersion(const char* glsl_code);
+        SHUT_LOGD("shader version: %d",getGLSLVersion(glshader->source))
+        SHUT_LOGD("\nshader source: %s\n",glshader->source)
+        glshader->is_gl4es_conv_shader=0;
+        if(getGLSLVersion(glshader->source) < 140 || strstr((glshader->converted)?glshader->converted:glshader->source, "FPE")!=NULL) {
+            glshader->is_gl4es_conv_shader=1;
+            SHUT_LOGD("\nconverted and used in gl4es:\n%s\n",glshader->converted);
             gl4es_gles_glShaderSource(shader, 1, (const GLchar * const*)((glshader->converted)?(&glshader->converted):(&glshader->source)), NULL);
         }
         errorGL();
@@ -237,7 +242,7 @@ void redoShader(GLuint shader, shaderconv_need_t *need) {
         return;
     free(glshader->converted);
     memcpy(&glshader->need, need, sizeof(shaderconv_need_t));
-    glshader->converted = ConvertShader(glshader->source, glshader->type==GL_VERTEX_SHADER?1:0, &glshader->need);
+    glshader->converted = ConvertShaderConditionally(glshader);
     // send source to GLES2 hardware if any
     gl4es_gles_glShaderSource(shader, 1, (const GLchar * const*)((glshader->converted)?(&glshader->converted):(&glshader->source)), NULL);
     // recompile...

src/main/cpp/gl/gl4es/gl/shader.h

@@ -35,6 +35,7 @@ struct shader_s {
     char*           converted;  // converted source (or null if nothing)
     // shaderconv
     shaderconv_need_t  need;    // the varying need / provide of the shader
+    int is_gl4es_conv_shader;
 }; // shader_t defined in oldprogram.h
 
 KHASH_MAP_DECLARE_INT(shaderlist, struct shader_s *);

src/main/cpp/gl/gl4es/gl/shaderconv.h

@@ -4,7 +4,8 @@
 #include "gles.h"
 #include "program.h"
 
-char* ConvertShader(const char* pBuffer, int isVertex, shaderconv_need_t *need);
+char * ConvertShaderConditionally(struct shader_s * shader_source);
+char* ConvertShader(const char* pBuffer, int isVertex, shaderconv_need_t *need, int forwardPort);
 
 int isBuiltinAttrib(const char* name);
 int isBuiltinMatrix(const char* name);

src/main/cpp/gl/gl4es/gl/string_utils.c

@@ -8,6 +8,67 @@ const char* AllSeparators = " \t\n\r.,;()[]{}-<>+*/%&\\\"'^$=!:?";
 
 char* gl4es_resize_if_needed(char* pBuffer, int *size, int addsize);
 
+void AppendToEnd(char **str, const char *suffix) {
+    size_t len = strlen(*str);
+    size_t suffixLen = strlen(suffix);
+    char *newStr = (char *)malloc(len + suffixLen + 1);
+    if (newStr == NULL) {
+        return;
+    }
+    strcpy(newStr, *str);
+    strcpy(newStr + len, suffix);
+    free(*str);
+    *str = newStr;
+}
+void InsertAtBeginning(char **str, const char *prefix) {
+    size_t len = strlen(*str);
+    size_t prefixLen = strlen(prefix);
+    char *newStr = (char *)malloc(len + prefixLen + 1);
+    strcpy(newStr, prefix);
+    strcpy(newStr + prefixLen, *str);
+    free(*str);
+    *str = newStr;
+}
+
+
+char * InplaceReplaceByIndex(char* pBuffer, int* size, const int startIndex, const int endIndex, const char* replacement)
+{
+    //printf("BY INDEX: %s", replacement);
+    //printf("BY INDEX: %i", strlen(replacement));
+    int length_difference;
+    if(endIndex < startIndex)
+        length_difference = strlen(replacement) + (endIndex - startIndex);
+    else if(endIndex == startIndex)
+        length_difference = strlen(replacement) - 1; // The initial char gets replaced
+    else
+        length_difference = strlen(replacement) - (endIndex - startIndex); // Can be negative if repl is smaller
+    pBuffer = gl4es_resize_if_needed(pBuffer, size, length_difference);
+    //printf("BEFORE MOVING: \n%s", pBuffer);
+    // Move the end of the string
+    memmove(pBuffer + startIndex + strlen(replacement) , pBuffer + endIndex + 1, strlen(pBuffer) - endIndex + 1);
+    //printf("AFTER MOVING 1: \n%s", pBuffer);
+    // Insert the replacement
+    memcpy(pBuffer + startIndex, replacement, strlen(replacement));
+    //strncpy(pBuffer + startIndex, replacement, strlen(replacement));
+    //printf("AFTER MOVING 2: \n%s", pBuffer);
+    return pBuffer;
+}
+/**
+ * Insert the string at the index, pushing "every chars to the right"
+ * @param source The shader as a string
+ * @param sourceLength The ALLOCATED length of the shader
+ * @param insertPoint The index at which the string is inserted.
+ * @param insertedString The string to insert
+ * @return The shader as a string, maybe in a different memory location
+ */
+char * InplaceInsertByIndex(char * source, int *sourceLength, const int insertPoint, const char *insertedString){
+    int insertLength = strlen(insertedString);
+    source = gl4es_resize_if_needed(source, sourceLength, insertLength);
+    memmove(source + insertPoint + insertLength,  source + insertPoint, strlen(source) - insertPoint + 1);
+    memcpy(source + insertPoint, insertedString, insertLength);
+    return source;
+}
+
 char* gl4es_inplace_replace(char* pBuffer, int* size, const char* S, const char* D)
 {
     int lS = strlen(S), lD = strlen(D);
@@ -26,7 +87,7 @@ char* gl4es_inplace_replace(char* pBuffer, int* size, const char* S, const char*
             p+=lD;
         } else p+=lS;
     }
-    
+
     return pBuffer;
 }
 
@@ -129,13 +190,21 @@ char* gl4es_resize_if_needed(char* pBuffer, int *size, int addsize) {
     char* p = pBuffer;
     int newsize = strlen(pBuffer)+addsize+1;
     if (newsize>*size) {
-        newsize += 100;
+        //newsize += 100;
         p = (char*)realloc(pBuffer, newsize);
         *size=newsize;
     }
     return p;
 }
 
+int isDigit(char value){
+    return (value >= '0' && value <= '9');
+}
+
+int isValidFunctionName(char value){
+    return ((value >= 'a' && value <= 'z') || (value >= 'A' && value <= 'Z') || (value == '_'));
+}
+
 char* gl4es_append(char* pBuffer, int* size, const char* S) {
     char* p =pBuffer;
     p = gl4es_resize_if_needed(pBuffer, size, strlen(S));
@@ -243,6 +312,27 @@ char* gl4es_inplace_replace_simple(char* pBuffer, int* size, const char* S, cons
         // next
         p+=lD;
     }
-    
+
     return pBuffer;
 }
+
+
+// for vgpu/shaderconv.c
+const char* FindString(const char* pBuffer, const char* S) __attribute__((alias("gl4es_find_string")));
+char* FindStringNC(char* pBuffer, const char* S) __attribute__((alias("gl4es_find_string_nc")));
+int CountString(const char* pBuffer, const char* S) __attribute__((alias("gl4es_count_string")));
+char* ResizeIfNeeded(char* pBuffer, int *size, int addsize) __attribute__((alias("gl4es_resize_if_needed")));
+char* InplaceReplace(char* pBuffer, int* size, const char* S, const char* D) __attribute__((alias("gl4es_inplace_replace")));
+char* Append(char* pBuffer, int* size, const char* S) __attribute__((alias("gl4es_append")));
+char* InplaceInsert(char* pBuffer, const char* S, char* master, int* size) __attribute__((alias("gl4es_inplace_insert")));
+char* GetLine(char* pBuffer, int num) __attribute__((alias("gl4es_getline")));
+int CountLine(const char* pBuffer) __attribute__((alias("gl4es_countline")));
+int GetLineFor(const char* pBuffer, const char* S) __attribute__((alias("gl4es_getline_for")));
+char* StrNext(char *pBuffer, const char* S) __attribute__((alias("gl4es_str_next")));
+char* NextStr(char* pBuffer) __attribute__((alias("gl4es_next_str")));
+char* PrevStr(char* Str, char* pBuffer) __attribute__((alias("gl4es_prev_str")));
+char* NextBlank(char* pBuffer) __attribute__((alias("gl4es_next_blank")));
+char* NextLine(char* pBuffer) __attribute__((alias("gl4es_next_line")));
+const char* GetNextStr(char* pBuffer) __attribute__((alias("gl4es_get_next_str")));
+int CountStringSimple(char* pBuffer, const char* S) __attribute__((alias("gl4es_countstring_simple")));
+char* InplaceReplaceSimple(char* pBuffer, int* size, const char* S, const char* D) __attribute__((alias("gl4es_inplace_replace_simple")));

src/main/cpp/gl/gl4es/gl/string_utils.h

@@ -20,11 +20,40 @@ char* gl4es_prev_str(char* Str, char* pBuffer);    // go to previous non "blank"
 char* gl4es_next_blank(char* pBuffer);   // go to next "blank"
 char* gl4es_next_line(char* pBuffer);   // go to next new line (crlf not included)
 
+
 const char* gl4es_get_next_str(char* pBuffer); // get a (static) copy of next str (until next separator), can be a simple number or separator also
 
 // those function don't try to be smart with separators...
 int gl4es_countstring_simple(char* pBuffer, const char* S);
 char* gl4es_inplace_replace_simple(char* pBuffer, int* size, const char* S, const char* D);
 
+// dare not to change their names into gl4es_xxx :(
+int isDigit(char value);
+int isValidFunctionName(char value);
+void AppendToEnd(char **str, const char *suffix);
+void InsertAtBeginning(char **str, const char *prefix);
+
+char * InplaceReplaceByIndex(char* pBuffer, int* size, int startIndex, int endIndex, const char* replacement);
+char * InplaceInsertByIndex(char * source, int *sourceLength, int insertPoint, const char *insertedString);
+
+extern const char* FindString(const char* pBuffer, const char* S);
+extern char* FindStringNC(char* pBuffer, const char* S);
+extern int CountString(const char* pBuffer, const char* S);
+extern char* ResizeIfNeeded(char* pBuffer, int *size, int addsize);
+extern char* InplaceReplace(char* pBuffer, int* size, const char* S, const char* D);
+extern char* Append(char* pBuffer, int* size, const char* S);
+extern char* InplaceInsert(char* pBuffer, const char* S, char* master, int* size);
+extern char* GetLine(char* pBuffer, int num);
+extern int CountLine(const char* pBuffer);
+extern int GetLineFor(const char* pBuffer, const char* S);
+extern char* StrNext(char *pBuffer, const char* S);
+extern char* NextStr(char* pBuffer);
+extern char* PrevStr(char* Str, char* pBuffer);
+extern char* NextBlank(char* pBuffer);
+extern char* NextLine(char* pBuffer);
+extern const char* GetNextStr(char* pBuffer);
+extern int CountStringSimple(char* pBuffer, const char* S);
+extern char* InplaceReplaceSimple(char* pBuffer, int* size, const char* S, const char* D);
+
 
 #endif // _GL4ES_STRING_UTILS_H_

src/main/cpp/gl/gl4es/gl/texture_params.c

@@ -400,7 +400,7 @@ void APIENTRY_GL4ES gl4es_glTexParameterf(GLenum target, GLenum pname, GLfloat p
     gl4es_glTexParameterfv(target, pname, &param);
 }
 void gl4es_glTexParameterf_real(GLenum target, GLenum pname, GLfloat param) {
-    DBG(SHUT_LOGD("MobileGlues-gl4es: glTexParameterfv(%s, %s, [%f(%s)...])\n", PrintEnum(target), PrintEnum(pname), params[0], PrintEnum(params[0]));)
+    DBG(SHUT_LOGD("MobileGlues-gl4es: glTexParameterfv(%s, %s, [%f(%s)...])\n", PrintEnum(target), PrintEnum(pname), param, PrintEnum(param));)
     GLfloat* params = &param;
     if(!glstate->list.pending) {
         PUSH_IF_COMPILING(glTexParameterfv);
@@ -462,7 +462,7 @@ void APIENTRY_GL4ES gl4es_glTexParameteri(GLenum target, GLenum pname, GLint par
     gl4es_glTexParameterfv(target, pname, &fparam);
 }
 void gl4es_glTexParameteri_real(GLenum target, GLenum pname, GLint param) {
-    DBG(SHUT_LOGD("MobileGlues-gl4es: glTexParameterfv(%s, %s, [%f(%s)...])\n", PrintEnum(target), PrintEnum(pname), params[0], PrintEnum(params[0]));)
+    DBG(SHUT_LOGD("MobileGlues-gl4es: glTexParameterfv(%s, %s, [%f(%s)...])\n", PrintEnum(target), PrintEnum(pname), param, PrintEnum(param));)
     if(!glstate->list.pending) {
         GLfloat *params = &param;
         PUSH_IF_COMPILING(glTexParameterfv);

src/main/cpp/gl/gl4es/gl/uniform.c

@@ -1,3 +1,4 @@
+#include <GLES3/gl32.h>
 #include "uniform.h"
 
 #include "../glx/hardext.h"
@@ -227,6 +228,10 @@ void GoUniformiv(program_t *glprogram, GLint location, int size, int count, cons
         return;
     }
     m = kh_value(glprogram->uniform, k);
+    if(m->type == GL_FLOAT && count == 1) {
+        glUniform1f(location, (float)*value);
+        return;
+    }
     if(size != n_uniform(m->type) || !is_uniform_int(m->type)  || count>m->size) {
         errorShim(GL_INVALID_OPERATION);
         return;

src/main/cpp/gl/gl4es/gl/vgpu/shaderconv.h

@@ -0,0 +1,47 @@
+//
+// Created by serpentspirale on 13/01/2022.
+//
+
+#ifndef UNTITLED_SHADERCONV_H
+#define UNTITLED_SHADERCONV_H
+
+#include "../shader.h"
+
+char* ConvertShaderVgpu(struct shader_s* shader_source);
+
+char * GLSLHeader(char* source);
+char * RemoveConstInsideBlocks(char* source, int * sourceLength);
+char * ForceIntegerArrayAccess(char* source, int * sourceLength);
+char * CoerceIntToFloat(char * source, int * sourceLength);
+char * ReplaceModOperator(char * source, int * sourceLength);
+char * WrapIvecFunctions(char * source, int * sourceLength);
+char * WrapFunction(char * source, int * sourceLength, char * functionName, char * wrapperFunctionName, char * wrapperFunction);
+int FindPositionAfterDirectives(char * source);
+int FindPositionAfterVersion(char * source);
+char * ReplaceGLFragData(char * source, int * sourceLength);
+char * ReplaceGLFragColor(char * source, int * sourceLength);
+char * ReplaceVariableName(char * source, int * sourceLength, char * initialName, char* newName);
+char * ReplaceFunctionName(char * source, int * sourceLength, char * initialName, char * finalName);
+char * RemoveUnsupportedExtensions(char * source);
+int doesShaderVersionContainsES(const char * source);
+char *ReplacePrecisionQualifiers(char *source, int *sourceLength, int isVertex);
+char * GetClosingTokens(char openingToken);
+int isOpeningToken(char openingToken);
+int GetClosingTokenPosition(const char * source, int initialTokenPosition);
+int GetClosingTokenPositionTokenOverride(const char * source, int initialTokenPosition, char initialToken);
+int GetNextTokenPosition(const char * source, int initialPosition, char token, const char * acceptedChars);
+void GetNextWord(char *source, int startPoint, int * startWord, int * endWord);
+unsigned long strstrPos(const char * haystack, const char * needle);
+char * insertIntAtFunctionCall(char * source, int * sourceSize, const char * functionName, int argumentPosition);
+char * InsertExtension(char * source, int * sourceLength, int insertPoint, const char * extension);
+char * InsertExtensions(char *source, int *sourceLength);
+int GetShaderVersion(const char * source);
+char * ReplaceFragmentOut(char * source, int *sourceLength);
+char * BackportConstArrays(char *source, int * sourceLength);
+char * ExtractString(char * source, int startString, int endString);
+char* ProcessSwitchCases(char* source, int* length);
+
+
+char* GetOperandFromOperator(char* source, int operatorIndex, int rightOperand, int * limit);
+
+#endif //UNTITLED_SHADERCONV_H

src/main/cpp/gl/gl4es/glx/hardext.c

@@ -424,23 +424,29 @@ void GetHardwareExtensions(int notest)
         hardext.vendor = VEND_ARM;
     else if(strstr(vendor, "Imagination Technologies"))
         hardext.vendor = VEND_IMGTEC;
-    if(hardext.esversion>1) {
+
-        if(testGLSL("#version 120", 1))
+    hardext.glsl120 = 0;
-            hardext.glsl120 = 1;
+    hardext.glsl300es = 1;
-        if(testGLSL("#version 300 es", 0))
+    hardext.glsl310es = 1;
-            hardext.glsl300es = 1;
+    // TODO: Check gles caps
-        if(testGLSL("#version 310 es", 1))
+    
-            hardext.glsl310es = 1;
+    //if(hardext.esversion>1) {
-    }
+    //    if(testGLSL("#version 120", 1))
-    if(hardext.glsl120) {
+    //        hardext.glsl120 = 1;
-        SHUT_LOGD("MobileGlues-gl4es: GLSL 120 supported and used\n");
+    //    if(testGLSL("#version 300 es", 0))
-    }
+    //        hardext.glsl300es = 1;
-    if(hardext.glsl300es) {
+    //    if(testGLSL("#version 310 es", 1))
-        SHUT_LOGD("MobileGlues-gl4es: GLSL 300 es supported%s\n", (hardext.glsl120||hardext.glsl310es)?"":" and used");
+    //        hardext.glsl310es = 1;
-    }
+    //}
-    if(hardext.glsl310es) {
+    //if(hardext.glsl120) {
-        SHUT_LOGD("MobileGlues-gl4es: GLSL 310 es supported%s\n", hardext.glsl120?"":" and used");
+    //    SHUT_LOGD("MobileGlues-gl4es: GLSL 120 supported and used\n");
-    }
+    //}
+    //if(hardext.glsl300es) {
+    //    SHUT_LOGD("MobileGlues-gl4es: GLSL 300 es supported%s\n", (hardext.glsl120||hardext.glsl310es)?"":" and used");
+    //}
+    //if(hardext.glsl310es) {
+    //    SHUT_LOGD("MobileGlues-gl4es: GLSL 310 es supported%s\n", hardext.glsl120?"":" and used");
+    //}
 
 #ifndef NOEGL
     if(strstr(gl4es_egl_eglQueryString(eglDisplay, EGL_EXTENSIONS), "EGL_KHR_gl_colorspace")) {

src/main/cpp/gl/gl_native.cpp

@@ -32,13 +32,13 @@ NATIVE_FUNCTION_HEAD(void, glClearColor, GLfloat red, GLfloat green, GLfloat blu
 NATIVE_FUNCTION_HEAD(void, glClearDepthf, GLfloat d) NATIVE_FUNCTION_END_NO_RETURN(void, glClearDepthf, d)
 NATIVE_FUNCTION_HEAD(void, glClearStencil, GLint s) NATIVE_FUNCTION_END_NO_RETURN(void, glClearStencil, s)
 NATIVE_FUNCTION_HEAD(void, glColorMask, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) NATIVE_FUNCTION_END_NO_RETURN(void, glColorMask, red,green,blue,alpha)
-NATIVE_FUNCTION_HEAD(void, glCompileShader, GLuint shader) NATIVE_FUNCTION_END_NO_RETURN(void, glCompileShader, shader)
+//NATIVE_FUNCTION_HEAD(void, glCompileShader, GLuint shader) NATIVE_FUNCTION_END_NO_RETURN(void, glCompileShader, shader)
 NATIVE_FUNCTION_HEAD(void, glCompressedTexImage2D, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) NATIVE_FUNCTION_END_NO_RETURN(void, glCompressedTexImage2D, target,level,internalformat,width,height,border,imageSize,data)
 NATIVE_FUNCTION_HEAD(void, glCompressedTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) NATIVE_FUNCTION_END_NO_RETURN(void, glCompressedTexSubImage2D, target,level,xoffset,yoffset,width,height,format,imageSize,data)
 //NATIVE_FUNCTION_HEAD(void, glCopyTexImage2D, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) NATIVE_FUNCTION_END_NO_RETURN(void, glCopyTexImage2D, target,level,internalformat,x,y,width,height,border)
 //NATIVE_FUNCTION_HEAD(void, glCopyTexSubImage2D, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) NATIVE_FUNCTION_END_NO_RETURN(void, glCopyTexSubImage2D, target,level,xoffset,yoffset,x,y,width,height)
-NATIVE_FUNCTION_HEAD(GLuint, glCreateProgram) NATIVE_FUNCTION_END(GLuint, glCreateProgram)
+//NATIVE_FUNCTION_HEAD(GLuint, glCreateProgram) NATIVE_FUNCTION_END(GLuint, glCreateProgram)
-NATIVE_FUNCTION_HEAD(GLuint, glCreateShader, GLenum type) NATIVE_FUNCTION_END(GLuint, glCreateShader, type)
+//NATIVE_FUNCTION_HEAD(GLuint, glCreateShader, GLenum type) NATIVE_FUNCTION_END(GLuint, glCreateShader, type)
 NATIVE_FUNCTION_HEAD(void, glCullFace, GLenum mode) NATIVE_FUNCTION_END_NO_RETURN(void, glCullFace, mode)
 //NATIVE_FUNCTION_HEAD(void, glDeleteBuffers, GLsizei n, const GLuint *buffers) NATIVE_FUNCTION_END_NO_RETURN(void, glDeleteBuffers, n,buffers)
 NATIVE_FUNCTION_HEAD(void, glDeleteFramebuffers, GLsizei n, const GLuint *framebuffers) NATIVE_FUNCTION_END_NO_RETURN(void, glDeleteFramebuffers, n,framebuffers)

src/main/cpp/gl/gl_stub.cpp

@@ -943,7 +943,7 @@ STUB_FUNCTION_HEAD(void, glEvaluateDepthValuesARB,void); STUB_FUNCTION_END_NO_RE
 //STUB_FUNCTION_HEAD(void, glGetObjectParameterfvARB, GLhandleARB obj, GLenum pname, GLfloat* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterfvARB,obj,pname,params)
 //STUB_FUNCTION_HEAD(void, glGetObjectParameterivARB, GLhandleARB obj, GLenum pname, GLint* params); STUB_FUNCTION_END_NO_RETURN(void, glGetObjectParameterivARB,obj,pname,params)
 STUB_FUNCTION_HEAD(void, glGetInfoLogARB, GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog); STUB_FUNCTION_END_NO_RETURN(void, glGetInfoLogARB,obj,maxLength,length,infoLog)
-STUB_FUNCTION_HEAD(void, glGetAttachedObjectsARB, GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj); STUB_FUNCTION_END_NO_RETURN(void, glGetAttachedObjectsARB,containerObj,maxCount,count,obj)
+//STUB_FUNCTION_HEAD(void, ,glGetAttachedObjectsARB GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj); STUB_FUNCTION_END_NO_RETURN(void, glGetAttachedObjectsARB,containerObj,maxCount,count,obj)
 STUB_FUNCTION_HEAD(void, glNamedStringARB, GLenum type, GLint namelen, const GLchar* name, GLint stringlen, const GLchar* string); STUB_FUNCTION_END_NO_RETURN(void, glNamedStringARB,type,namelen,name,stringlen,string)
 STUB_FUNCTION_HEAD(void, glDeleteNamedStringARB, GLint namelen, const GLchar* name); STUB_FUNCTION_END_NO_RETURN(void, glDeleteNamedStringARB,namelen,name)
 STUB_FUNCTION_HEAD(void, glCompileShaderIncludeARB, GLuint shader, GLsizei count, const GLchar* const*path, const GLint* length); STUB_FUNCTION_END_NO_RETURN(void, glCompileShaderIncludeARB,shader,count,path,length)
@@ -1627,8 +1627,8 @@ STUB_FUNCTION_HEAD(void, glFogCoordfvEXT,const GLfloat* coord); STUB_FUNCTION_EN
 STUB_FUNCTION_HEAD(void, glFogCoorddEXT, GLdouble coord); STUB_FUNCTION_END_NO_RETURN(void, glFogCoorddEXT,coord)
 STUB_FUNCTION_HEAD(void, glFogCoorddvEXT,const GLdouble* coord); STUB_FUNCTION_END_NO_RETURN(void, glFogCoorddvEXT,coord)
 STUB_FUNCTION_HEAD(void, glFogCoordPointerEXT, GLenum type, GLsizei stride, const void* pointer); STUB_FUNCTION_END_NO_RETURN(void, glFogCoordPointerEXT,type,stride,pointer)
-STUB_FUNCTION_HEAD(void, glFramebufferTexture1DEXT, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); STUB_FUNCTION_END_NO_RETURN(void, glFramebufferTexture1DEXT,target,attachment,textarget,texture,level)
+//STUB_FUNCTION_HEAD(void, glFramebufferTexture1DEXT, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); STUB_FUNCTION_END_NO_RETURN(void, glFramebufferTexture1DEXT,target,attachment,textarget,texture,level)
-STUB_FUNCTION_HEAD(void, glFramebufferTexture3DEXT, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); STUB_FUNCTION_END_NO_RETURN(void, glFramebufferTexture3DEXT,target,attachment,textarget,texture,level,zoffset)
+//STUB_FUNCTION_HEAD(void, glFramebufferTexture3DEXT, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); STUB_FUNCTION_END_NO_RETURN(void, glFramebufferTexture3DEXT,target,attachment,textarget,texture,level,zoffset)
 STUB_FUNCTION_HEAD(void, glProgramEnvParameters4fvEXT, GLenum target, GLuint index, GLsizei count, const GLfloat* params); STUB_FUNCTION_END_NO_RETURN(void, glProgramEnvParameters4fvEXT,target,index,count,params)
 STUB_FUNCTION_HEAD(void, glProgramLocalParameters4fvEXT, GLenum target, GLuint index, GLsizei count, const GLfloat* params); STUB_FUNCTION_END_NO_RETURN(void, glProgramLocalParameters4fvEXT,target,index,count,params)
 //STUB_FUNCTION_HEAD(void, glBindFragDataLocationEXT, GLuint program, GLuint color, const GLchar* name); STUB_FUNCTION_END_NO_RETURN(void, glBindFragDataLocationEXT,program,color,name)

src/main/cpp/gl/glsl/glsl_for_es.cpp

@@ -705,6 +705,11 @@ std::string process_uniform_declarations(const std::string& glslCode) {
     return result;
 }
 
+extern "C" char* process_uniform_declarations_for_c(char* glslCode) {
+    std::string glslCode_str(glslCode);
+    return strdup(process_uniform_declarations(glslCode_str).c_str());
+}
+
 std::string processOutColorLocations(const std::string& glslCode) {
     const static std::regex pattern(R"(\n(out highp vec4 outColor)(\d+);)");
     const std::string replacement = "\nlayout(location=$2) $1$2;";
@@ -732,13 +737,7 @@ std::string GLSLtoGLSLES(const char* glsl_code, GLenum glsl_type, uint essl_vers
     }
     
     int return_code = -1;
-    //std::string converted = /*glsl_version<140? GLSLtoGLSLES_1(glsl_code, glsl_type, essl_version, return_code):*/GLSLtoGLSLES_2(glsl_code, glsl_type, essl_version, return_code);
+    std::string converted = /*glsl_version<140? GLSLtoGLSLES_1(glsl_code, glsl_type, essl_version, return_code):*/GLSLtoGLSLES_2(glsl_code, glsl_type, essl_version, return_code);
-    std::string converted;
-    if (glsl_version<140) {
-        converted = GLSLtoGLSLES_3(glsl_code, glsl_type, essl_version, return_code);
-    } else {
-        converted = GLSLtoGLSLES_2(glsl_code, glsl_type, essl_version, return_code);
-    }
     if (return_code == 0 && !converted.empty()) {
         converted = process_uniform_declarations(converted);
         Cache::get_instance().put(sha256_string.c_str(), converted.c_str());
@@ -750,6 +749,7 @@ std::string GLSLtoGLSLES(const char* glsl_code, GLenum glsl_type, uint essl_vers
 
 std::string GLSLtoGLSLES_3(const char *glsl_code, GLenum glsl_type, uint essl_version, int& return_code) {
     LOG_W("Warning: use gl4es shaderconv to convert shader.")
+    /*
     gl4es_code::GL4ES_shaderconv_need_t need;
     need.need_texcoord = -1;
     int shaderCompileStatus;
@@ -775,6 +775,7 @@ std::string GLSLtoGLSLES_3(const char *glsl_code, GLenum glsl_type, uint essl_ve
     LOG_D("converted:\n%s", converted)
     return_code = 0;
     return std::string(converted);
+     */
 }
 
 std::string replace_line_starting_with(const std::string& glslCode, const std::string& starting, const std::string& substitution = "") {

src/main/cpp/gl/glsl/glsl_for_es.h

@@ -21,6 +21,6 @@ std::string GLSLtoGLSLES(const char *glsl_code, GLenum glsl_type, uint esversion
 std::string GLSLtoGLSLES_1(const char *glsl_code, GLenum glsl_type, uint esversion, int& return_code);
 std::string GLSLtoGLSLES_2(const char *glsl_code, GLenum glsl_type, uint essl_version, int& return_code);
 std::string GLSLtoGLSLES_3(const char *glsl_code, GLenum glsl_type, uint essl_version, int& return_code);
-int getGLSLVersion(const char* glsl_code);
+extern "C" int getGLSLVersion(const char* glsl_code);
 
 #endif

src/main/cpp/gl/glsl/glslconv_gl4es.cpp

@@ -12,7 +12,7 @@
 #include <cmath>
 #include <clocale>
 
-#define DEBUG 1
+#define DEBUG 0
 
 namespace gl4es_code {
 

src/main/cpp/gl/program.cpp

@@ -88,10 +88,15 @@ void glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) {
     shaderInfo.frag_data_changed = 1;
 }
 
+extern "C" EXPORT GLuint glCreateProgram() {
+    LOG()
+    GLuint program = gl4es_glCreateProgram();
+    CHECK_GL_ERROR
+    return program;
+}
+
 void glLinkProgram(GLuint program) {
     LOG()
-    GET_GL4ES_FUNC(void, glLinkProgram, GLuint program)
-    CALL_GL4ES_FUNC(glLinkProgram, program)
     LOG_D("glLinkProgram(%d)", program)
     if (!shaderInfo.converted.empty() && shaderInfo.frag_data_changed) {
         GLES.glShaderSource(shaderInfo.id, 1, (const GLchar * const*) &shaderInfo.frag_data_changed_converted, nullptr);
@@ -111,7 +116,9 @@ void glLinkProgram(GLuint program) {
     shaderInfo.converted = "";
     shaderInfo.frag_data_changed_converted = nullptr;
     shaderInfo.frag_data_changed = 0;
-    GLES.glLinkProgram(program);
+    //GLES.glLinkProgram(program);
+    GET_GL4ES_FUNC(void, glLinkProgram, GLuint program)
+    CALL_GL4ES_FUNC(glLinkProgram, program)
 
     CHECK_GL_ERROR
 }
@@ -191,4 +198,13 @@ EXPORT GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInt
 }
 EXPORT void glGetProgramResourceLocationIndexARB(GLuint program, GLenum programInterface, const char *name) __attribute__((alias("glGetProgramResourceLocationIndex")));
 
+EXPORT void glGetAttachedObjectsARB(GLhandleARB program, GLsizei maxCount, GLsizei* count, GLhandleARB* objects) {
+    if (program == 0 || glIsProgram(program) == GL_FALSE) {
+        return;
+    }
+    glGetAttachedShaders(program, maxCount, count, (GLuint*)objects);
+}
+
+EXPORT GLhandleARB glCreateProgramARB() { return glCreateProgram(); }
+
 }

src/main/cpp/gl/shader.cpp

@@ -40,10 +40,22 @@ bool is_direct_shader(const char *glsl)
     return es3_ability;
 }
 
+extern "C" EXPORT GLuint glCreateShader(GLenum type) {
+    LOG()
+    GLuint shader = gl4es_glCreateShader(type);
+    CHECK_GL_ERROR
+    return shader;
+}
+
+extern "C" EXPORT void glCompileShader(GLuint shader) {
+    LOG()
+    gl4es_glCompileShader(shader);
+    CHECK_GL_ERROR
+}
+
 void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, const GLint *length) {
     LOG()
-    GET_GL4ES_FUNC(void, glShaderSource, GLuint shader, GLsizei count, const GLchar *const* string, const GLint *length)
+    gl4es_glShaderSource(shader,count,string,length);
-    CALL_GL4ES_FUNC(glShaderSource, shader, count, string, length)
     shaderInfo.id = 0;
     shaderInfo.converted = "";
     shaderInfo.frag_data_changed = 0;
@@ -69,6 +81,7 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, c
             essl_src = glsl_src;
         } else {
             int glsl_version = getGLSLVersion(glsl_src.c_str());
+            if (glsl_version < 140) { LOG_D("Shader won't be processed in mg shaderconv."); return; } // will be converted in gl4es
             LOG_D("[INFO] [Shader] Shader source: ")
             LOG_D("%s", glsl_src.c_str())
             GLint shaderType;
@@ -87,9 +100,7 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, c
             shaderInfo.converted = essl_src;
             const char* s[] = { essl_src.c_str() };
             GLES.glShaderSource(shader, count, s, nullptr);
-        }
+        } else LOG_E("Failed to convert glsl.")
-        else
-        LOG_E("Failed to convert glsl.")
         CHECK_GL_ERROR
     } else {
         LOG_E("No GLES.glShaderSource")
@@ -209,6 +220,9 @@ EXPORT void glVertexAttrib4ubvARB(GLuint index, const GLubyte *v) { glVertexAttr
 EXPORT void glVertexAttrib4usvARB(GLuint index, const GLushort *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
 EXPORT void glVertexAttrib4uivARB(GLuint index, const GLuint *v) { glVertexAttrib4fv(index, (GLfloat*)v); }
 
+EXPORT void glCompileShaderARB(GLhandleARB shader) { glCompileShader(shader); }
+EXPORT GLhandleARB glCreateShaderARB(GLenum shaderType) { return glCreateShader(shaderType); }
+
 //EXPORT void glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
 //    glVertexAttribPointer(index, size, type, normalized, stride, pointer);
 //}

src/main/cpp/gles/gles.h

@@ -526,6 +526,8 @@ GL_FUNC_TYPEDEF(void, glMultiDrawArraysIndirectEXT, GLenum mode, const void *ind
 GL_FUNC_TYPEDEF(void, glMultiDrawElementsIndirectEXT, GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 GL_FUNC_TYPEDEF(void, glBruh)
 GL_FUNC_TYPEDEF(void, glMultiDrawElementsBaseVertexEXT, GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex)
+GL_FUNC_TYPEDEF(void, glFramebufferTexture3DOES, GLenum target, GLenum attachment, GLenum textarget,
+                GLuint texture, GLint level, GLint layer)
 
 #define GL_FUNC_DECL(name) \
 name##_PTR name;
@@ -903,6 +905,8 @@ struct gles_func_t {
     GL_FUNC_DECL(glMultiDrawElementsBaseVertexEXT)
 
     GL_FUNC_DECL(glBruh)
+    
+    GL_FUNC_DECL(glFramebufferTexture3DOES)
 };
 
 extern struct gles_func_t g_gles_func;

src/main/cpp/gles/loader.cpp

@@ -580,6 +580,8 @@ void init_target_gles() {
     INIT_GLES_FUNC(glMultiDrawArraysIndirectEXT)
     INIT_GLES_FUNC(glMultiDrawElementsIndirectEXT)
     INIT_GLES_FUNC(glMultiDrawElementsBaseVertexEXT)
+    
+    INIT_GLES_FUNC(glFramebufferTexture3DOES)
 //    INIT_GLES_FUNC(glBruh)
 
     LOG_D("glMultiDrawArraysIndirectEXT() @ 0x%x", GLES.glMultiDrawArraysIndirectEXT)