Feat[shader_wrapper]: "support" uniform initializer

Author: artdeell

ltw/src/main/tinywrapper/Android.mk

@@ -412,6 +412,6 @@ LOCAL_SRC_FILES := \
 LOCAL_STATIC_LIBRARIES := glsl_optimizer
 LOCAL_LDFLAGS := -ffunction-sections -fdata-sections -Wl,--version-script=$(LOCAL_PATH)/version.script
 # Comment for debugging
-#LOCAL_LDFLAGS += -flto -Wl,--gc-sections
-LOCAL_LDLIBS := -llog -lEGL
+LOCAL_LDFLAGS += -flto -Wl,--gc-sections
+LOCAL_LDLIBS := -llog
 include $(BUILD_SHARED_LIBRARY)

ltw/src/main/tinywrapper/glsl_optimizer/src/code/ir_print_glsl_visitor.cpp

@@ -691,6 +691,45 @@ IR_TO_GLSL::visit(ir_variable* ir)
 	print_var_name(ir);
 	print_type_post(generated_source, ir->type, false);
 
+    if(ir->data.mode == ir_var_uniform) {
+        ir_constant* const_val = ir->constant_value;
+        if(const_val == NULL) const_val = ir->constant_initializer;
+        if(const_val != NULL) {
+            const glsl_type* assign_type = const_val->type;
+            const glsl_base_type base_type = assign_type->base_type;
+            if(assign_type->is_array() || assign_type->is_struct() || assign_type->is_matrix()) {
+                printf("shader_print: %s default value is array, struct or matrix\n", ir->name);
+                abort();
+            }
+            char type;
+            switch (base_type) {
+                case GLSL_TYPE_FLOAT:
+                case GLSL_TYPE_FLOAT16:
+                    type = 'f';
+                    break;
+                case GLSL_TYPE_INT:
+                case GLSL_TYPE_INT8:
+                case GLSL_TYPE_INT16:
+                case GLSL_TYPE_INT64:
+                    type = 'i';
+                    break;
+                case GLSL_TYPE_UINT:
+                case GLSL_TYPE_UINT8:
+                case GLSL_TYPE_UINT16:
+                case GLSL_TYPE_UINT64:
+                    type = 'u';
+                default:
+                    printf("shader_print: %s default value is not float, int or uint\n", ir->name);
+                    abort();
+                    break;
+            }
+
+            generated_source.append("/* LTW UNIFORM INIT %c %i %s ", type, assign_type->vector_elements, ir->name);
+            visit(const_val);
+            generated_source.append(" */");
+        }
+    }
+
 	if (ir->constant_value &&
 		ir->data.mode != ir_var_shader_in &&
 		ir->data.mode != ir_var_shader_out &&

ltw/src/main/tinywrapper/shader_wrapper.c

@@ -13,16 +13,104 @@
 #include "egl.h"
 #include "proc.h"
 
+struct def_uval {
+    struct def_uval* next;
+    char name[128];
+    char type;
+    int vector_len;
+    union {
+        GLint iv[4];
+        GLuint uv[4];
+        GLfloat fv[4];
+    };
+};
+
+typedef struct {
+    struct def_uval* first;
+    struct def_uval* last;
+} uval_list_t;
+
 typedef struct {
     GLenum shader_type;
     const GLchar* source;
+    uval_list_t uval_list;
 } shader_info_t;
 
 typedef struct {
     GLuint frag_shader;
     GLchar* colorbindings[MAX_DRAWBUFFERS];
+    uval_list_t uval_list;
 } program_info_t;
 
+static void uval_list_add(uval_list_t* list, struct def_uval entry) {
+    const size_t struct_size = sizeof(struct def_uval);
+    struct def_uval* new_entry = malloc(struct_size);
+    memcpy(new_entry, &entry, struct_size);
+    new_entry->next = NULL;
+    if(list->first == NULL) {
+        list->first = list->last = new_entry;
+    }else {
+        list->last->next = new_entry;
+        list->last = new_entry;
+    }
+}
+
+static void uval_list_add_unique(uval_list_t* list, struct def_uval entry) {
+    for(struct def_uval *current = list->first; current != NULL; current = current->next) {
+        if(strcmp(current->name, entry.name) == 0) return;
+    }
+    uval_list_add(list, entry);
+}
+
+static void uval_list_free(uval_list_t* list) {
+    struct def_uval *current = list->first;
+    for(;current != NULL;) {
+        void* old_current = current;
+        current = current->next;
+        free(old_current);
+    }
+}
+
+static void uval_apply(GLint loc, const struct def_uval* uval) {
+#define APPLY_4(type, arr) es3_functions.glUniform4##type(loc, uval->arr[0], uval->arr[1], uval->arr[2], uval->arr[3])
+#define APPLY_3(type, arr) es3_functions.glUniform3##type(loc, uval->arr[0], uval->arr[1], uval->arr[2])
+#define APPLY_2(type, arr) es3_functions.glUniform2##type(loc, uval->arr[0], uval->arr[1])
+#define APPLY_1(type, arr) es3_functions.glUniform1##type(loc, uval->arr[0])
+#define APPLY_LEN(len) \
+    case len:                   \
+    switch (uval->type) { \
+        case 'i': APPLY_##len(i, iv); break; \
+        case 'f': APPLY_##len(f, fv); break; \
+        case 'u': APPLY_##len(ui, uv); break; \
+    }                  \
+    break;
+
+    switch (uval->vector_len) {
+        APPLY_LEN(1)
+        APPLY_LEN(2)
+        APPLY_LEN(3)
+        APPLY_LEN(4)
+    }
+
+#undef APPLY_LEN
+#undef APPLY_1
+#undef APPLY_2
+#undef APPLY_3
+#undef APPLY_4
+}
+
+static void uval_list_apply(uval_list_t* list, GLuint program) {
+    GLint oldprogram;
+    es3_functions.glGetIntegerv(GL_CURRENT_PROGRAM, &oldprogram);
+    es3_functions.glUseProgram(program);
+    for(struct def_uval *current = list->first; current != NULL; current = current->next) {
+        GLint location = es3_functions.glGetUniformLocation(program, current->name);
+        if(location == -1) continue;
+        uval_apply(location, current);
+    }
+}
+
+
 GLuint glCreateProgram(void) {
     if(!current_context) return 0;
     GLuint phys_program = es3_functions.glCreateProgram();
@@ -45,6 +133,7 @@ void glDeleteProgram(GLuint program) {
         const GLchar* binding = old_programinfo->colorbindings[i];
         if(binding != NULL) free((void*)binding);
     }
+    uval_list_free(&old_programinfo->uval_list);
     free(old_programinfo);
 }
 
@@ -54,8 +143,13 @@ void glAttachShader( 	GLuint program,
     es3_functions.glAttachShader(program, shader);
     program_info_t* program_info = unordered_map_get(current_context->program_map, (void*)program);
     shader_info_t* shader_info = unordered_map_get(current_context->shader_map, (void*)shader);
-    if(program_info == NULL || shader_info == NULL || shader_info->shader_type != GL_FRAGMENT_SHADER) return;
-    program_info->frag_shader = shader;
+    if(program_info == NULL || shader_info == NULL) return;
+    if(shader_info->shader_type == GL_FRAGMENT_SHADER) program_info->frag_shader = shader;
+
+    struct def_uval *current = shader_info->uval_list.first;
+    for(;current != NULL; current = current->next) {
+        uval_list_add_unique(&program_info->uval_list, *current);
+    }
 }
 
 void glBindFragDataLocation( 	GLuint program,
@@ -91,17 +185,12 @@ static void insert_fragout_pos(char* source, int* size, const char* name, GLuint
     gl4es_inplace_replace_simple(source, size, src_string, dst_string);
 }
 
-void glLinkProgram(GLuint program) {
-    if(!current_context) return;
-    program_info_t* program_info = unordered_map_get(current_context->program_map, (void*)program);
-    if(program_info == NULL || program_info->frag_shader == 0) {
-        // Don't have any fragment shader to patch the locations in, fall through.
-        goto fallthrough;
-    }
+static GLuint patch_fragdata_loc(program_info_t* program_info) {
+    if(program_info->frag_shader == 0) return 0;
     shader_info_t *shader = unordered_map_get(current_context->shader_map, (void*)program_info->frag_shader);
     if(shader == NULL) {
         printf("LTWShdrWp: failed to patch frag data location due to missing shader info\n");
-        goto fallthrough;
+        return 0;
     }
     int nsrc_size = (int)(strlen(shader->source) + 1);
     char* new_source = malloc(nsrc_size);
@@ -115,7 +204,7 @@ void glLinkProgram(GLuint program) {
     }
     if(!changesMade) {
         free(new_source);
-        goto fallthrough;
+        return 0;
     }else {
         //printf("\n\n\nShader Result POST PATCH\n%s\n\n\n", new_source);
     }
@@ -124,7 +213,7 @@ void glLinkProgram(GLuint program) {
     if(patched_shader == 0) {
         free(new_source);
         printf("LTWShdrWp: failed to initialize patched shader\n");
-        goto fallthrough;
+        return 0;
     }
     es3_functions.glShaderSource(patched_shader, 1, &const_source, NULL);
     es3_functions.glCompileShader(patched_shader);
@@ -136,16 +225,74 @@ void glLinkProgram(GLuint program) {
         es3_functions.glGetShaderiv(patched_shader, GL_INFO_LOG_LENGTH, &logSize);
         GLchar log[logSize];
         es3_functions.glGetShaderInfoLog(patched_shader, logSize, NULL, log);
+        es3_functions.glDeleteShader(patched_shader);
         printf("LTWShdrWp: failed to compile patched fragment shader, using default. Log:\n\n%s\n\nShader content:\n\n%s\n\n", log, const_source);
-        goto fallthrough;
+        return 0;
+    }
+    return patched_shader;
+}
+
+void glLinkProgram(GLuint program) {
+    if(!current_context) return;
+    program_info_t* program_info = unordered_map_get(current_context->program_map, (void*)program);
+    if(program_info == NULL) {
+        printf("LTWShdrWp: program info missing for program %u\n", program);
+        es3_functions.glLinkProgram(program);
+        return;
+    }
+    GLuint patched_frag_shader = patch_fragdata_loc(program_info);
+    if(patched_frag_shader != 0) {
+        es3_functions.glDetachShader(program, program_info->frag_shader);
+        es3_functions.glAttachShader(program, patched_frag_shader);
     }
-    es3_functions.glDetachShader(program, program_info->frag_shader);
-    es3_functions.glAttachShader(program, patched_shader);
     es3_functions.glLinkProgram(program);
-    es3_functions.glDeleteShader(patched_shader);
+    if(patched_frag_shader != 0) es3_functions.glDeleteShader(patched_frag_shader);
+    uval_list_apply(&program_info->uval_list, program);
     return;
-    fallthrough:
-    es3_functions.glLinkProgram(program);
+}
+
+static const char* vec1_initializer = "  %%%c ";
+static const char* vec2_initializer = " %svec2(%%%2$c, %%%2$c) ";
+static const char* vec3_initializer = " %svec3(%%%2$c, %%%2$c, %%%2$c) ";
+static const char* vec4_initializer = " %svec4(%%%2$c, %%%2$c, %%%2$c, %%%2$c) ";
+
+static void print_scan_template(char type, int veclen, char out[64]) {
+    char type_str[] = {type , 0};
+    if(type == 'f') type_str[0] = 0;
+    switch (veclen) {
+        case 1: snprintf(out, sizeof(char) * 64, vec1_initializer, type); break;
+        case 2: snprintf(out, sizeof(char) * 64, vec2_initializer, type_str, type); break;
+        case 3: snprintf(out, sizeof(char) * 64, vec3_initializer, type_str, type); break;
+        case 4: snprintf(out, sizeof(char) * 64, vec4_initializer, type_str, type); break;
+        default:
+            abort();
+    }
+}
+
+static void find_constant_uniforms(shader_info_t * programInfo, const char* source) {
+    char vector_scan_template[64] = { 0 }, var_value[128] = { 0 };
+    float initval[4];
+    for(;;) {
+        source = strstr(source, "/* LTW UNIFORM INIT");
+        if(source == NULL) break;
+        struct def_uval entry;
+        if(sscanf(source, "/* LTW UNIFORM INIT %c %i %127s %127s */", &entry.type, &entry.vector_len, entry.name, var_value) < 2) {
+            abort();
+        }
+        print_scan_template(entry.type, entry.vector_len, vector_scan_template);
+        int scancnt = 0;
+        switch (entry.type) {
+            case 'f': scancnt = sscanf(var_value, vector_scan_template, &entry.fv[0], &entry.fv[1], &entry.fv[2], &entry.fv[3]); break;
+            case 'i': scancnt = sscanf(var_value, vector_scan_template, &entry.iv[0], &entry.iv[1], &entry.iv[2], &entry.iv[3]); break;
+            case 'u': scancnt = sscanf(var_value, vector_scan_template, &entry.uv[0], &entry.uv[1], &entry.uv[2], &entry.uv[3]); break;
+        }
+        if(scancnt != entry.vector_len) {
+            printf("LTWShdrWp: could not scan for initializer, value %s\n template %s\n", var_value, vector_scan_template);
+            abort();
+        }
+        uval_list_add(&programInfo->uval_list, entry);
+        source = gl4es_next_line(source);
+    }
 }
 
 GLuint glCreateShader(GLenum shaderType) {
@@ -168,6 +315,7 @@ void glDeleteShader(GLuint shader) {
     shader_info_t * old_shaderinfo = unordered_map_remove(current_context->shader_map, (void*)shader);
     if(old_shaderinfo == NULL) return;
     if(old_shaderinfo->source != NULL) free((void*)old_shaderinfo->source);
+    uval_list_free(&old_shaderinfo->uval_list);
     free(old_shaderinfo);
 }
 
@@ -192,6 +340,9 @@ void glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, co
 
 #undef SRC_LEN
     GLchar* new_source = optimize_shader(target_string, shader_info->shader_type, 460, current_context->shader_version);
+    if(new_source != NULL) {
+        find_constant_uniforms(shader_info, new_source);
+    }
     //printf("\n\n\nShader Result\n%s\n\n\n", new_source);
     if(shader_info->source != NULL) free((void*)shader_info->source);
     shader_info->source = new_source;

ltw/src/main/tinywrapper/string_utils.c

@@ -248,7 +248,7 @@ char* gl4es_next_blank(char* pBuffer) {
     return pBuffer;
 }
 
-char* gl4es_next_line(char* pBuffer) {
+char* gl4es_next_line(const char* pBuffer) {
     if(!pBuffer) return NULL;
     while(*pBuffer && *pBuffer!='\n')
         ++pBuffer;

ltw/src/main/tinywrapper/string_utils.h

@@ -26,7 +26,7 @@ char* gl4es_str_next(char *pBuffer, const char* S); // mostly as strstr, but go
 char* gl4es_next_str(char* pBuffer);   // go to next non "blank"
 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)
+char* gl4es_next_line(const 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